如何在不启动任务的情况下构建任务？

Question

我想使用this Task<TResult> 构造函数。我似乎无法正确使用语法。有人可以更正我的代码吗？

另外，我认为如果Task 是这样构造的，它不会启动吗？

我认为我需要的构造函数是：

Task<TResult>(Func<Object, TResult>, Object)

我得到的错误是：

参数 1：无法从“方法组”转换为“System.Func<object,int>”

static void Main(string[] args)
{
    var t = new Task<int>(GetIntAsync, "3"); // error is on this line
    // ...
}

static async Task<int> GetIntAsync(string callerThreadId)
{
    // ...
    return someInt;
}

Answer 1

有一个类似的问题，我们希望确保任务可重用，而无需重新启动任务。 Rx 救了我们的培根。您将需要 nuget 包 System.Reactive。

见下文GetIntTask 返回一个未启动的任务，GetIntOnce 确保任务启动，并且任务的结果被缓冲并重播给任何调用者（使用Replay(1)）

async Task Main()
{
    var awaitableResult = GetIntOnce();
    Console.WriteLine("Has the task started yet? No!");
    var firstResult = await awaitableResult;
    Console.WriteLine($"Awaited Once: {firstResult}");
    var secondResult = await awaitableResult;
    Console.WriteLine($"Awaited Twice: {secondResult}");
}

public static IObservable<int> GetIntOnce()
{
    return Observable.FromAsync(() =>
        {
            var t = GetIntTask();
            t.Start();
            return t;
        }).Replay(1).AutoConnect();
}

public static Task<int> GetIntTask()
{
    var t = new Task<int>(
    () =>
    {
        Console.WriteLine("Task is running!");
        return 10;
    });
    return t;
}

输出是：

Has the task started yet? No!
Task is running!
Awaited Once: 10
Awaited Twice: 10

Answer 2

.net 5 中的一种新方法（其实我不知道你什么时候可以开始这样做，我现在正在使用 .net 5）

Task<int> MyStartLaterTask = null;
//... Some Time Later
MyStartLaterTask ??= GetIntAsync(string callerThreadId);
await MyStartLaterTask;

我很欣赏这并不完全是“预先定义并稍后使用”，但据我所知，这也是同样的事情。我有一个循环，我想定义一个只在需要时运行并且只运行一次的任务。这就是这样做的，它创建了一个任务，我可以在第一次需要它时分配它，然后在需要它的输出时等待它。

Answer 3

我发现异步 lambda 效果最好，因为：

1. 工作是通过调用方法开始的，这意味着你不需要调用.Start，所以不可能忘记这样做。
2. 这种方法不会“遭受”内部/外部任务问题；你总是在等待正确的任务，而不是它的包装。

Func<Task<int>> f = async () => await WorkAsync(2);

Console.WriteLine("Sleeping before start");

await Task.Delay(100);

Console.WriteLine("Waking up to start");

var result = await f();

Console.WriteLine($"The work is done and the answer is: {result}");

这会产生以下输出：

Sleeping before start
Waking up to start
Starting 2
Ending 2
The work is done and the answer is: 4

Answer 4

要使用接受object state 参数的Task 构造函数，您还必须有一个接受object 参数的函数。一般这是不方便的。存在此构造函数的原因是为了避免在热路径中分配对象（closure）。对于正常使用，闭包的开销可以忽略不计，避免它们会使您的代码无缘无故地复杂化。所以this 是你应该使用的构造函数：

public Task (Func<TResult> function);

...用这个 lambda 作为参数：

() => GetIntAsync("3")

不过，您的情况有一个特点：您传递给构造函数的 lambda 返回一个 Task<int>。这意味着泛型类型TResult 被解析为Task<int>，所以你最终得到了一个嵌套任务：

var t = new Task<Task<int>>(() => GetIntAsync("3"));

启动外部任务将导致创建内部任务。要获得最终结果，您必须使用两次await 运算符，一次用于完成外部任务，一次用于完成内部任务：

static async Task Main(string[] args)
{
    var outerTask = new Task<Task<int>>(() => GetIntAsync("3"));
    //...
    outerTask.Start(); // or outerTask.RunSynchronously() to use the current thread
    //...
    Task<int> innerTask = await outerTask; // At this point the inner task has been created
    int result = await innerTask; // At this point the inner task has been completed
}

Answer 5

var t = new Task<int>(() => GetIntAsync("3").Result);

或者

var t = new Task<int>((ob) => GetIntAsync((string) ob).Result, "3");

为避免使用 lambda，您需要编写如下静态方法：

private static int GetInt(object state)
{
   return GetIntAsync(((string) state)).Result;
}

然后：

var t = new Task<int>(GetInt, "3");

Answer 6

   //creating task
   var yourTask = Task<int>.Factory.StartNew(() => GetIntAsync("3").Result);

   //...

   int result = yourTask.Result;

更新：

是的，不幸的是它确实启动了任务。改用上面提到的代码：

   //creating task
   var yourTask = new Task<int>(() => GetIntAsync("3").Result);

   //...

   // call task when you want
   int result = yourTask.Start();