为什么我要在多个等待中选择一个“等待任务.WhenAll”？

如果我不在乎任务完成的顺序，而只需要全部完成，我还是应该使用await Task.WhenAll而不是多个await？例如，DoWork2下面是一种首选方法DoWork1（为什么？）：

using System;
using System.Threading.Tasks;

namespace ConsoleApp
{
    class Program
    {
        static async Task<string> DoTaskAsync(string name, int timeout)
        {
            var start = DateTime.Now;
            Console.WriteLine("Enter {0}, {1}", name, timeout);
            await Task.Delay(timeout);
            Console.WriteLine("Exit {0}, {1}", name, (DateTime.Now - start).TotalMilliseconds);
            return name;
        }

        static async Task DoWork1()
        {
            var t1 = DoTaskAsync("t1.1", 3000);
            var t2 = DoTaskAsync("t1.2", 2000);
            var t3 = DoTaskAsync("t1.3", 1000);

            await t1; await t2; await t3;

            Console.WriteLine("DoWork1 results: {0}", String.Join(", ", t1.Result, t2.Result, t3.Result));
        }

        static async Task DoWork2()
        {
            var t1 = DoTaskAsync("t2.1", 3000);
            var t2 = DoTaskAsync("t2.2", 2000);
            var t3 = DoTaskAsync("t2.3", 1000);

            await Task.WhenAll(t1, t2, t3);

            Console.WriteLine("DoWork2 results: {0}", String.Join(", ", t1.Result, t2.Result, t3.Result));
        }


        static void Main(string[] args)
        {
            Task.WhenAll(DoWork1(), DoWork2()).Wait();
        }
    }
}

是的，请使用，WhenAll因为它可以一次传播所有错误。如果有多个等待，则如果较早的等待之一抛出，则会丢失错误。

另一个重要的区别是，即使存在故障（故障或取消的任务），WhenAll也将等待所有任务完成。依次手动等待会导致意外的并发，因为要等待的程序部分实际上会提前进行。

我认为这也使阅读代码更加容易，因为所需的语义已直接记录在代码中。

我的理解是，更喜欢Task.WhenAll使用awaits的主要原因是性能/任务“搅动”：该DoWork1方法执行以下操作：

• 从给定的上下文开始
• 保存上下文
• 等待t1
• 恢复原始上下文
• 保存上下文
• 等待t2
• 恢复原始上下文
• 保存上下文
• 等待t3
• 恢复原始上下文

相比之下，DoWork2这样做：

• 从给定的上下文开始
• 保存上下文
• 等待所有t1，t2和t3
• 恢复原始上下文

当然，这对于您的特定情况是否足够大，取决于“上下文相关”（请原谅）。

异步方法被实现为状态机。可以编写使方法不被编译为状态机的方法，这通常称为快速异步方法。这些可以这样实现：

public Task DoSomethingAsync()
{
    return DoSomethingElseAsync();
}

使用时Task.WhenAll，可以在保持快速调用代码的同时仍确保调用者能够等待所有任务完成，例如：

public Task DoSomethingAsync()
{
    var t1 = DoTaskAsync("t2.1", 3000);
    var t2 = DoTaskAsync("t2.2", 2000);
    var t3 = DoTaskAsync("t2.3", 1000);

    return Task.WhenAll(t1, t2, t3);
}

（免责声明：此答案取自/启发自Ian Griffiths的TPL异步课程，了解Pluralsight）

选择WhenAll的另一个原因是异常处理。

假设您在DoWork方法上有一个try-catch块，并假设它们正在调用不同的DoTask方法：

static async Task DoWork1() // modified with try-catch
{
    try
    {
        var t1 = DoTask1Async("t1.1", 3000);
        var t2 = DoTask2Async("t1.2", 2000);
        var t3 = DoTask3Async("t1.3", 1000);

        await t1; await t2; await t3;

        Console.WriteLine("DoWork1 results: {0}", String.Join(", ", t1.Result, t2.Result, t3.Result));
    }
    catch (Exception x)
    {
        // ...
    }

}

在这种情况下，如果所有3个任务都抛出异常，则仅捕获第一个任务。以后的任何异常都将丢失。即，如果t2和t3引发异常，则仅捕获t2；否则，将仅捕获t2。等等。后续任务异常将不会被观察到。

与whenAll一样-如果任何或所有任务出错，则生成的任务将包含所有异常。关键字await仍然始终重新引发第一个异常。因此，其他例外仍然有效地未被发现。解决此问题的一种方法是在WhenAll任务之后添加一个空的延续，并在其中放置等待。这样，如果任务失败，则result属性将引发完整的Aggregate Exception：

static async Task DoWork2() //modified to catch all exceptions
{
    try
    {
        var t1 = DoTask1Async("t1.1", 3000);
        var t2 = DoTask2Async("t1.2", 2000);
        var t3 = DoTask3Async("t1.3", 1000);

        var t = Task.WhenAll(t1, t2, t3);
        await t.ContinueWith(x => { });

        Console.WriteLine("DoWork1 results: {0}", String.Join(", ", t.Result[0], t.Result[1], t.Result[2]));
    }
    catch (Exception x)
    {
        // ...
    }
}

这个问题的其他答案提供了技术原因 await Task.WhenAll(t1, t2, t3);要优先使用的。这个答案旨在从较软的角度（@usr暗示）进行研究，同时得出相同的结论。

await Task.WhenAll(t1, t2, t3); 是一种更具功能性的方法，因为它声明了意图并且是原子的。

使用await t1; await t2; await t3;，没有什么可以阻止队友（甚至您将来的自我！）在各个await语句之间添加代码。当然，您已将其压缩到一行以基本上完​​成该操作，但这并不能解决问题。此外，在团队设置中，在给定的代码行中包含多个语句通常是不好的形式，因为它会使人眼难以扫描源文件。

简而言之，await Task.WhenAll(t1, t2, t3);它更具可维护性，因为它可以更清楚地传达您的意图，并且不易受到特有错误的影响，这些错误可能是源于对代码的善意更新，甚至是合并出错。