如何在手动创建的任务中调用异步方法？

Question

I need to implement something like a cold observable object in RxJS (just a standard Observable). I need to call an async method inside a task I create myself via constructor (new Task()). I need to implement this because before executing any asynchronous code I want to do some stuff which is very specific to my project. So I want to recieve a task that is not started yet which I can start manually a little bit later.

So far I came to the following decision and to my surprise it isn't working!

class Program
{
    static void Main(string[] args)
    {
        var task1 = CallApi(() => t.Go());
        var task2 =  CallApi2(() => t.Go());


        task1.Start();
        task2.Start();

    }



    public static Task<T> CallApi<T>(Func<Task<T>> function)
    {
        if (function == null)
        {
            throw new ArgumentNullException(nameof(function));
        }


        return new Task<Task<T>>(async () =>
        {
            return await function();
        }).Unwrap();


    }

    public static Task<T> CallApi2<T>(Func<Task<T>> function)
    {
        if (function == null)
        {
            throw new ArgumentNullException(nameof(function));
        }

        var tcs = new TaskCompletionSource<T>();

        var resultTask = new Task<Task<T>>(() =>
        {
            var t = function();

            t.ContinueWith(
                task => {
                    tcs.SetResult(task.Result);
                },
                TaskContinuationOptions.OnlyOnRanToCompletion
            );

            t.ContinueWith(
                task => {
                    tcs.SetCanceled();
                },
                TaskContinuationOptions.OnlyOnCanceled
            );

            t.ContinueWith(
                task => {
                    tcs.SetException(task.Exception);

                },
                TaskContinuationOptions.OnlyOnFaulted
            );
            return tcs.Task;
        });

        return resultTask.Unwrap();

    }
}

It seems that calling Unwrap or using TaskCompletionSource creates a task in a WaitingForActivation state. And calling Start method on tasks in this state leads me to the exception which is saying:

Start may not be called on a promise-style task.

So it's very likely that .NET distinguishes special kind of tasks - promise-style tasks.

In summary my questions are:

1. What do these promise-style tasks mean?

2. How can I do what I want to do?

Answer 1

Promise style tasks are tasks that are not based on threads, they are based on events, For a TaskCompletionSource the "event" is the act of calling SetResult , SetCanceled or SetException

To receive a task that is not started yet which you can start manually a little bit later, simply hold on to the Func<Task<T>> and you evaluate the function to start up the task at the later point in time. This can be done quite simply.

    public void Example()
    {
        Func<Task<T>> func1 = () => t.Go();

        //Do other work

        Task<T> task1 = func1(); //t.Go() is not called until this point then the task starts.

    }