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

7 回答

• 89

  这两个答案都没有提及等待的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状态结束 . 如果提供的array / enumerable不包含任务，则返回的任务将在返回给调用者之前立即转换到RanToCompletion状态 .

  回复于 2024-04-28T15:46:51+08:00
• 5

  你可以创建许多任务，如：

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

  回复于 2024-04-28T15:46:51+08:00
• 21

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

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

  回复于 2024-04-28T15:46:51+08:00
• 9

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

  

  Example

  var tasks = new Task[] {
      await TaskOperationOne(),
      await TaskOperationTwo()
  };
  
  Task.WaitAll(tasks);
  // or
  await Task.WhenAll(tasks);
  

  如果你想以特定的顺序运行任务，你可以从this anwser获得灵感 .

  回复于 2024-04-28T15:46:51+08:00
• 12

  你想链接 Task ，还是可以并行调用？

  For chaining
  做一些像

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

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

  For the parallel manner
  我遇到的最简单的方法是：Parallel.Invoke否则有Task.WaitAll或者您甚至可以使用 WaitHandle 来倒数零操作倒计时（等待，有一个新类：CountdownEvent），或者......

  回复于 2024-04-28T15:46:51+08:00
• 317

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

  回复于 2024-04-28T15:46:51+08:00
• 1

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

  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
  }
  

  回复于 2024-04-28T15:46:51+08:00