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

 

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

 

等待一组任务的完成使用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);                    

}

 

参考资料：C#并发编程经典实例