运行多个异步任务并等待它们全部完成

Question

我需要在控制台应用程序中运行多个异步任务，并等待它们全部完成，然后再进行进一步处理。

那里有很多文章，但我似乎越读越困惑。我已经阅读并理解了任务库的基本原理，但我显然在某处缺少链接。

我知道可以链接任务，以便它们在另一个完成后开始（这几乎是我读过的所有文章的场景），但我希望我的所有任务同时运行，我希望完成后就知道了。

对于这样的场景，最简单的实现是什么？

Answer 1

两个答案都没有提到等待的Task.WhenAll：

var task1 = DoWorkAsync();
var task2 = DoMoreWorkAsync();

await Task.WhenAll(task1, task2);

Task.WaitAll 和 Task.WhenAll 之间的主要区别在于前者会阻塞（类似于在单个任务上使用 Wait），而后者不会也可以等待，将控制权交还给调用者，直到所有任务完成。

更何况，异常处理不同：

Task.WaitAll：

至少有一个 Task 实例被取消 - 或 - 在至少一个 Task 实例的执行过程中引发了异常。如果任务被取消，则 AggregateException 在其 InnerExceptions 集合中包含 OperationCanceledException。

Task.WhenAll：

如果提供的任何任务在故障状态下完成，则返回的任务也将在故障状态下完成，其异常将包含来自每个提供的任务的未包装异常集的聚合。

如果提供的任务都没有出错，但至少有一个任务被取消，则返回的任务将以 Canceled 状态结束。

如果没有任务出错并且没有任务被取消，则生成的任务将以 RanToCompletion 状态结束。 如果提供的数组/可枚举不包含任务，则返回的任务将在返回给调用者之前立即转换为 RanToCompletion 状态。

Answer 2

您可以创建许多任务，例如：

List<Task> TaskList = new List<Task>();
foreach(...)
{
   var LastTask = new Task(SomeFunction);
   LastTask.Start();
   TaskList.Add(LastTask);
}

Task.WaitAll(TaskList.ToArray());

Answer 3

您可以使用WhenAll，它将返回一个可等待的Task 或WaitAll，它没有返回类型，并会阻止类似于Thread.Sleep 的进一步代码执行，直到所有任务都完成、取消或出错。

	WhenAll	WaitAll
Any of the supplied tasks completes in a faulted state	A task with the faulted state will be returned. The exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.	An AggregateException will be thrown.
None of the supplied tasks faulted but at least one of them was canceled	The returned task will end in the TaskStatus.Canceled state	An AggregateException will be thrown which contains an OperationCanceledException in its InnerExceptions collection
An empty list was given	An ArgumentException will be thrown	The returned task will immediately transition to a TaskStatus.RanToCompletion State before it's returned to the caller.
	Doesn't block the current thread	Blocks the current thread

示例

var tasks = new Task[] {
    TaskOperationOne(),
    TaskOperationTwo()
};

Task.WaitAll(tasks);
// or
await Task.WhenAll(tasks);

如果您想以特定/特定顺序运行任务，您可以从this 答案中获得灵感。

Answer 4

我见过的最佳选择是以下扩展方法：

public static Task ForEachAsync<T>(this IEnumerable<T> sequence, Func<T, Task> action) {
    return Task.WhenAll(sequence.Select(action));
}

这样称呼它：

await sequence.ForEachAsync(item => item.SomethingAsync(blah));

或者使用异步 lambda：

await sequence.ForEachAsync(async item => {
    var more = await GetMoreAsync(item);
    await more.FrobbleAsync();
});

Answer 5

还有另一个答案...但我通常会遇到这样的情况，即我需要同时加载数据并将其放入变量中，例如：

var cats = new List<Cat>();
var dog = new Dog();

var loadDataTasks = new Task[]
{
    Task.Run(async () => cats = await LoadCatsAsync()),
    Task.Run(async () => dog = await LoadDogAsync())
};

try
{
    await Task.WhenAll(loadDataTasks);
}
catch (Exception ex)
{
    // handle exception
}

Answer 6

您想链接Tasks，还是可以以并行方式调用它们？

用于链接
只需做类似的事情

Task.Run(...).ContinueWith(...).ContinueWith(...).ContinueWith(...);
Task.Factory.StartNew(...).ContinueWith(...).ContinueWith(...).ContinueWith(...);

并且不要忘记检查每个 ContinueWith 中的前一个 Task 实例，因为它可能有问题。

为并行方式
我遇到的最简单的方法：Parallel.Invoke 否则有 Task.WaitAll 或者你甚至可以使用 WaitHandles 倒计时到零个动作（等等，有一个新类：CountdownEvent），或者......

Answer 7

这就是我使用数组 Func 的方式：

var tasks = new Func<Task>[]
{
   () => myAsyncWork1(),
   () => myAsyncWork2(),
   () => myAsyncWork3()
};

await Task.WhenAll(tasks.Select(task => task()).ToArray()); //Async    
Task.WaitAll(tasks.Select(task => task()).ToArray()); //Or use WaitAll for Sync

Answer 8

应该有一个比公认答案更简洁的解决方案。同时运行多个任务并获得结果不应需要三个步骤。

1. 创建任务
2. 等待 Task.WhenAll(tasks)
3. 获取任务结果（例如，task1.Result）

这里有一种方法可以将其缩减为两个步骤：

    public async Task<Tuple<T1, T2>> WhenAllGeneric<T1, T2>(Task<T1> task1, Task<T2> task2)
    {
        await Task.WhenAll(task1, task2);
        return Tuple.Create(task1.Result, task2.Result);
    }

你可以这样使用它：

var taskResults = await Task.WhenAll(DoWorkAsync(), DoMoreWorkAsync());
var DoWorkResult = taskResults.Result.Item1;
var DoMoreWorkResult = taskResults.Result.Item2;

这消除了对临时任务变量的需要。使用它的问题在于，虽然它适用于两个任务，但您需要为三个任务或任何其他数量的任务更新它。如果其中一项任务没有返回任何内容，它也不能很好地工作。确实，.Net 库应该提供可以做到这一点的东西

Answer 9

我准备了一段代码来向您展示如何在其中一些场景中使用该任务。

    // method to run tasks in a parallel 
    public async Task RunMultipleTaskParallel(Task[] tasks) {

        await Task.WhenAll(tasks);
    }
    // methode to run task one by one 
    public async Task RunMultipleTaskOneByOne(Task[] tasks)
    {
        for (int i = 0; i < tasks.Length - 1; i++)
            await tasks[i];
    }
    // method to run i task in parallel 
    public async Task RunMultipleTaskParallel(Task[] tasks, int i)
    {
        var countTask = tasks.Length;
        var remainTasks = 0;
        do
        {
            int toTake = (countTask < i) ? countTask : i;
            var limitedTasks = tasks.Skip(remainTasks)
                                    .Take(toTake);
            remainTasks += toTake;
            await RunMultipleTaskParallel(limitedTasks.ToArray());
        } while (remainTasks < countTask);
    }

Answer 10

如果您使用async/await pattern，您可以像这样并行运行多个任务：

public async Task DoSeveralThings()
{
    // Start all the tasks
    Task first = DoFirstThingAsync();
    Task second = DoSecondThingAsync();

    // Then wait for them to complete
    var firstResult = await first;
    var secondResult = await second;
}