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

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

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

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

对于这种情况，最简单的实现是什么？

这两个答案都没有提到等待的问题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：

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

如果提供的任务均未发生故障，但至少有一个被取消，则返回的任务将以“已取消”状态结束。

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

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

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

Task.WaitAll(TaskList.ToArray());

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

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();
});

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

例

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

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

如果您想按特定顺序运行任务，则可以从此答案中获得启发。

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

对于链接
只需执行以下操作

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

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

对于并行方式
，我遇到的最简单的方法是：Parallel.Invoke 否则，Task.WaitAll甚至可以使用WaitHandles进行倒数，以使剩余的动作减少为零（等待，这里有一个新类：）CountdownEvent，或者...

这就是我使用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

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

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
}

我准备了一段代码，向您展示如何在某些情况下使用该任务。

    // 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);
    }