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

两个答案都没有提到可等待的 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 状态。

---

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

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

Task.WaitAll(TaskList.ToArray());

---

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

WhenAll WaitAll 提供的任何任务在故障状态下完成 将返回具有故障状态的任务。异常将包含来自每个提供的任务的一组未包装异常的聚合。将抛出 AggregateException。提供的任务均未出现故障，但至少有一个已取消 返回的任务将以 TaskStatus.Canceled 状态结束 将引发 AggregateException，其 InnerExceptions 集合中包含 OperationCanceledException 给出空列表 将引发 ArgumentException 返回任务将在返回给调用者之前立即转换为 TaskStatus.RanToCompletion 状态。不阻塞当前线程 阻塞当前线程

例子

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

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

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

---

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

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

---

另一个答案......但我通常会发现自己处于一个案例中，当我需要同时加载数据并将其放入变量中时，例如：

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
}

---

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

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

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

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

对于并行方式
我遇到的最简单的方法：Parallel.Invoke 否则有 Task.WaitAll 或者您甚至可以使用 WaitHandle 来倒计时到零操作（等等，有一个新类：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

---

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

创建任务 await Task.WhenAll(tasks) 获取任务结果（例如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 库应该提供可以做到这一点的东西

---

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

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

---

如果您使用 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;
}

---