等待所有或任意异步任务完成,以及异步任务完成时的处理方案

本篇体验如何等待所有异步任务完成、等待任意一个异步任务完成，以及异步任务完成时的处理。

等待一组任务的完成使用Task.WhenAll方法。

Task task1 = Task.Delay(TimeSpan.FromSeconds(1));
Task task2 = Task.Delay(TimeSpan.FromSeconds(2));
Task task3 = Task.Delay(TimeSpan.FromSeconds(3));
await Task.WhenAll(task1, task2, task3);

如果所有任务的结果类型相同且全部完成，Task.WhenAll返回每个任务执行结果的数组。

Task task1 = Task.FromResult(1);
Task task2 = Task.FromResult(2);
Task task3 = Task.FromResult(3);
int[] results = await Task.WhenAll(task1, task2, task3);
foreach(var item in results)
{
  Console.WriteLine(item);
}

举个例子，提供一个url的集合，要求根据这个url集合去远程下载对应的内容，写一个方法。

static async Task<string> DownloadAllAsync(IEnumerable<string> urls)
{
  var httpClient = new HttpClient();
  //定义每一个ulr的使用方法
  var downloads = urls.Select(url => httpClient.GetStringAsync(url));
  //下载真正开始
  Task<string>[] downloadTasks = downloads.ToArray();
  //异步等待
  string[] hmtls = await Task.WhenAll(downloadTasks);
  return string.Concat(htmls);
}

如果在等待所有任务完成的过程中有异常发生怎么办呢？

如果想在等待过程中捕获异常，那么应该把WhenAll方法放在try语句块中；如果想在所有任务完成后捕获异常，那就应该把WhenAll方法返回的Task类型放在try语句块中。

先模拟两个异步异常。

static async Task ThrowNotImplementedExceptionAsync()
{
  throw new NotImplementedException();
}
static async Task ThrowInvalidOperationExceptionAsync()
{
  throw new InvalidOperationException();
}

首先来看等待结果出来时的异常处理。

stati async Task ObserveOneExceptionAsync()
{
  var task1 = ThrowNotImplementedExceptionAsync();
  var task2 = ThrwoInvalidOperationExceptionAsync();
  try
  {
    await Task.WhenAll(task1, ask2);
  }
  cach(Exception ex)
  {
  }
}

再来看等所有结果出来后的异常处理。

static async Task ObserveAllExceptionAsync()
{
  var task1 = ThrowNotImplementedExceptionAsync();
  var task2 = ThrwoInvalidOperationExceptionAsync();
  Task allTasks = Task.WhenAll(task1, task2);
  try
  {
    await allTasks;
  }
  catch(Eexception ex)
  {
  }
}

等待任意一个任务的完成使用WhenAny方法。

比如有2个任务，通过2个url获取异步远程内容。

private static async Task<int> DownloadAsync(string url1, url2)
{
  var httpClient = new HttpClient();
  Task<byte[]> download1 = httpClient.GetByteArrayAsync(url1);
  Task<byte[]> download2 = httpClient.GetByteArrayAsync(url2);
  //等待任意一个任务完成
  Task<byte[]> completedTask = await Task.WhenAny(download1, download2);
  byte[] data = await completedTask;
  return data.Length;
}

任务完成时如何处理呢？

思路有2个，一个是根据我们安排的顺序出结果，还有一个是根据任务本身出结果的先后顺序自然输出结果。

首先来一个异步方法。

static async Task<int> DelayAsync(int val)
{
  await Task.Delay(TimeSpan.FromSeconds(val));
  return val;
}

再写一个手动部署任务顺序的方法。

static async Task ProcessTasksAsync()
{
  //创建任务队列
  Task<int> task1 = DelayAsync(2);
  Task<int> task2 = DelayAsync(3);
  Task<int> task3 = DelayAsync(1);
  //手动安排任务的顺序
  var tasks = new[]{task1, task2, task3};
  //按顺序遍历任务列表，逐一输出结果
  foreach(var task in tasks)
  {
    var result = await task;
    Console.Write(result);
  }
}

输出结果为231，是根据我们手动安排任务的顺序输出结果的。

如果我们想输出123呢？即按照任务的不同让结果自然发生。

思路是：以异步的方式处理输出结果。

可以写一个针对每个任务的异步方法。

static async Task AwaitAndProessAync(Task<int> task)
{
  var result = await task;
  Console.Write(result);
}

现在修改ProcessTasksAsync方法如下：

static async Task ProcessTasksAsync()
{
  //创建任务队列
  Task<int> task1 = DelayAsync(2);
  Task<int> task2 = DelayAsync(3);
  Task<int> task3 = DelayAsync(1);
  //手动安排任务的顺序
  var tasks = new[]{task1, task2, task3};
  var processingTasks = (from t in tasks
            select AwaitAndProessAync(t)).ToArray();
   await Task.WhenAll(processingTasks);          
}

当然，也可以这样修改ProcessTasksAsync方法。

static async Task ProcessTasksAsync()
{
  //创建任务队列
  Task<int> task1 = DelayAsync(2);
  Task<int> task2 = DelayAsync(3);
  Task<int> task3 = DelayAsync(1);
  //手动安排任务的顺序
  var tasks = new[]{task1, task2, task3};
  var processingTasks = tasks.Select( async t => {
    var result = await t;
    Console.Write(result);
  }).ToArray();
            
   await Task.WhenAll(processingTasks);          
}