如何将任务结果传递给不使用延续的其他任务

Question

我在Func<Task>types 中定义了可变数量的任务，因此我可以定义任务但不能让它们自动启动。比如说：

Func<Task> task1Func = () => DoTask1Async();

以这种方式定义的一些任务返回值。我需要一种方法将此类任务的结果“传递”给以相同方式定义的后续任务的参数。所以，我想写：

Func<Task> task2Func = () => DoTask2Async(task1Func.Invoke().Result));

这样做的问题是task1Func.Invoke() 部分再次启动task1 任务，这是不好的。

我无法将输入重新构建为链延续，例如：

Func<Task> funcTasks = () => DoTask1Async().ContinueWith(t => DoTask2Async(t.Result));

因为我需要在代码中知道链中每个任务（即 DoTask1Async / DoTask2Async）完成运行其他代码的点。另一个问题是我不知道如何计算“链”中涉及多少任务。

我无法在任务结果完成时存储它们，因为任务需要像 task1Func 和 task2Func 这样以声明方式定义。

任务按定义的顺序处理，每个任务在处理下一个任务之前完成。任务的结果仅用于后续任务。

编辑

响应使用task1Func.Invoke().Result 的可运行代码的请求。创建一个新的 WPF 项目并向默认 Grid 添加一个按钮。然后清除 MainWindow.xaml.cs 文件并粘贴以下内容。这是最接近我真实项目的代码，同时删除了所有与问题无关的内容。

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Windows;

namespace WpfApplication2
{

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private async void Button_Click(object sender, RoutedEventArgs e)
    {
        // Declare first task that returns a result
        Func<Task<int>> deferredTask1 = () => DoTask1Async();
        // Declare second task using result of first.
        // BUT this isn't good as it calls deferredTask1 AGAIN, so need another approach.
        Func<Task> deferredTask2 = () => DoTask2Async(deferredTask1.Invoke().Result);

        var item1 = new MyItem() { MyDeferredTask = deferredTask1 };
        var item2 = new MyItem() { MyDeferredTask = deferredTask2 };

        List<MyItem> items = new List<MyItem>();

        items.Add(item1);
        items.Add(item2);

        await DoTasksAsync(items);

    }

    public static async Task<int> DoTask1Async()
    {
        return await Task<int>.Run(() => { return 3000; });
    }

    public static async Task DoTask2Async(int delay)
    {
        await Task.Delay(delay);
    }

    private async Task DoTasksAsync(IEnumerable<MyItem> items)
    {
        foreach (var item in items)
        {
            await item.MyDeferredTask();
        }
    }

    private class MyItem
    {
        public Func<Task> MyDeferredTask { get; set; }
    }
}
}

Answer 1

使用 Microsoft 的响应式框架，您可以做到这一点：

var query =
    from r1 in Observable.FromAsync(() => DoTask1Async())
    from r2 in Observable.FromAsync(() => DoTask2Async(r1))
    select new { r1, r2 };

await query;

Answer 2

您可以将这些延迟的异步操作表示为嵌套任务 (Task<Task>)。外层任务代表操作的开始，内层任务代表操作的完成。内层任务由unwrapping外层任务获取：

Task<Task<int>> task1 = new Task<Task<int>>(async () =>
{
    return await DoTask1Async();
});

Task<Task> task2 = new Task<Task>(async () =>
{
    try { task1.RunSynchronously(); } catch (InvalidOperationException) { }
    int task1Result = await task1.Unwrap();
    await DoTask2Async(task1Result);
});

外部任务开始它的生命是冷的。您必须调用其方法Start 或RunSynchronously 才能变热并开始运行。这两个方法只能调用一次。他们第二次抛出InvalidOperationException，所以为了保持在不同时间从多个位置启动任务的灵活性，你必须预料到这个异常并吞下它。

为了将这些操作存储在List 中，您必须分别存储外部任务和内部任务，因为外部任务是您开始的，内部任务是您等待的。把它们放在tuplesValueTuple<Task, Task> 里很方便：

List<(Task, Task)> tasks = new List<(Task, Task)>()
{
    (task1, task1.Unwrap()),
    (task2, task2.Unwrap()),
};

foreach (var (outerTask, innerTask) in tasks)
{
    try { outerTask.RunSynchronously(); } catch (InvalidOperationException) { }
    await innerTask;
}

这是允许的，因为泛型类 Task<TResult> 派生自基类 Task。

---

替代方案： 不使用嵌套的Task<Task>s，另一种选择是使用Lazy<Task>s。 Lazy 类保证被包装的任务只会被实例化一次，并且具有线程安全性。不过有一个困难。我们不能将Lazy<Task> 和Lazy<Task<T>> 的实例放在同一个List 中。 C# 编译器认为它们是完全不同的类。因此，让我们制作两个 LazyTask 包装器，通用的包装器派生自非通用包装器，模仿 Task<T> 和 Task 之间的关系：

class LazyTask
{
    private readonly Lazy<Task> _lazyTask;

    public LazyTask(Func<Task> function) => _lazyTask = new Lazy<Task>(function);

    public Task Task => _lazyTask.Value;

    public TaskAwaiter GetAwaiter() => this.Task.GetAwaiter(); // Make it awaitable
}

class LazyTask<T> : LazyTask
{
    public LazyTask(Func<Task<T>> function) : base(function) { }

    public new Task<T> Task => (Task<T>)base.Task;

    public T Result => this.Task.GetAwaiter().GetResult();

    public new TaskAwaiter<T> GetAwaiter() => this.Task.GetAwaiter();
}

有了这些类，实现变得比“嵌套任务”方法更简洁。无需手动启动任务并吞下异常。任务会根据需要自动创建。

LazyTask<int> task1 = new LazyTask<int>(async () =>
{
    return await DoTask1Async();
});

LazyTask task2 = new LazyTask(async () =>
{
    await DoTask2Async(await task1);
});

List<LazyTask> tasks = new List<LazyTask>() { task1, task2 };

foreach (var task in tasks)
{
    await task;
}