Tasks

public static class CompletedTask
{
    public static Task<TResult> Create<TResult>(TResult result)
    {
        var tcs = new TaskCompletionSource<TResult>();
        tcs.TrySetResult(result);
        return tcs.Task;
    }
}

public static class TaskExtensions
{
    public static bool TrySetFromTask<TResult>(this TaskCompletionSource<TResult> resultSetter, Task task)
    {
        if (null == resultSetter) throw new ArgumentNullException("resultSetter");
        if (null == task) throw new ArgumentNullException("task");

        switch (task.Status)
        {
            case TaskStatus.RanToCompletion:
            {
                var taskResult = task as Task<TResult>;
                TResult result = (null == taskResult) ? default(TResult) : taskResult.Result;
                return resultSetter.TrySetResult(result);
            }
            case TaskStatus.Faulted:
            {
                var error = task.Exception;
                var errors = (null == error) ? Enumerable.Empty<Exception>() : error.InnerExceptions;
                return resultSetter.TrySetException(errors);
            }
            case TaskStatus.Canceled:
            {
                return resultSetter.TrySetCanceled();
            }
            default:
            {
                throw new InvalidOperationException();
            }
        }
    }

    public static Task<TResult> ToApm<TResult>(this Task<TResult> task, AsyncCallback callback, object state)
    {
        if (null == task) throw new ArgumentNullException("task");

        if (task.AsyncState == state)
        {
            if (null != callback)
            {
                task.ContinueWith(t => callback(t),
                    CancellationToken.None,
                    TaskContinuationOptions.ExecuteSynchronously,
                    TaskScheduler.Default);
            }

            return task;
        }

        var tcs = new TaskCompletionSource<TResult>(state);

        task.ContinueWith(t => tcs.TrySetFromTask(t),
            CancellationToken.None,
            TaskContinuationOptions.ExecuteSynchronously,
            TaskScheduler.Default);

        if (null != callback)
        {
            tcs.Task.ContinueWith(t => callback(t),
                CancellationToken.None,
                TaskContinuationOptions.ExecuteSynchronously,
                TaskScheduler.Default);
        }

        return tcs.Task;
    }
}