Почему я должен отдать предпочтение одиночному 'waitait Task.WhenAll' за несколько ожиданий?

Question

В случае, если мне не нужен порядок завершения задачи, и вам просто нужно их заполнить, должен ли я использовать await Task.WhenAll вместо нескольких await? Например, является DoWord2 ниже предпочтительным методом 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(); 
     } 
    } 
} 

Answer 1

Да, используйте WhenAll, потому что он распространяется все ошибки сразу. С множественным ожиданием вы теряете ошибки, если один из ранних ожиданий бросает.

Другое важное отличие заключается в том, что WhenAll будет ждать всего задач для завершения. Цепочка await прервала бы , ожидая при первом исключении, но выполнение не ожидаемых задач продолжается. Это приводит к неожиданному параллелизму.

Я думаю, что это также облегчает чтение кода, потому что семантика, которую вы хотите, напрямую документируется в коде.

Answer 2

Я понимаю, что основная причина предпочесть Task.WhenAll к множеству await сек является производительность/задача «штамповать»: метод DoWork1 делает что-то вроде этого:

• старт с заданной context
• сохранить контекст
• ждать t1
• восстановить первоначальный контекст
• сохранить контекст
• ждать t2
• восстановить первоначальный контекст
• сохранить контекст
• ожидание t3
• восстановить первоначальный контекст

В противоположность этому, DoWork2 делает это:

• начинаются с заданного контекста
• сохранить контекст
• ожидания для всех t1, t2 и t3
• восстановления оригинального контекста

ли это достаточно большая проблема для вашего конкретного случая, конечно же, «контекстно-зависимый »(помилуй каламбур).

Answer 3

Асинхронный метод реализуется как государственная машина. Можно написать методы, чтобы они не были скомпилированы в государственные машины, что часто называют быстрым методом асинхронной генерации. Они могут быть реализованы следующим образом:

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

Answer 4

Другие ответы на этот вопрос предлагают технические причины, по которым 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); более удобен в обслуживании, поскольку он более четко информирует о ваших намерениях и менее уязвим к специфическим ошибкам, которые могут возникнуть из-за благонамеренных обновлений кода или даже просто сливаются с ошибками.