异步编程基础[五]
Table of contents
1. 概述
前面的文章介绍了标识了 async 和 await 的代码，是怎么被线程执行的。
2. 报告进度
使用 IProgress<T> 和 Progress<T> 类型
构造
Progress<T>实例时捕获当前 同步上下文 实例；Progress<T>实例的ProgressChanged事件被调用时使用上面捕获的同步上下文；如果在执行构造函数的线程没有同步上下文时（隐含使用的Default同步上下文），则将在 ThreadPool 中调用事件
static async Task DoProgressAsync(int count, IProgress<int> progress = null)
{
for (int i = 0; i < count; i++)
{
await Task.Delay(200);
if (progress != null)
progress.Report(i + 1);
}
}
static async Task CallProgressAsync()
{
int count = 5;
var progress = new Progress<int>();
progress.ProgressChanged += (sender, args) =>
{
System.Console.WriteLine($"{args}/{count}");
};
await DoProgressAsync(count, progress);
}
输出为:
1/5
2/5
3/5
4/5
5/5
3. 等待一组任务完成
Task.WhenAll 方法有以 IEnumerable 类型作为参数的重载，但建议大家不要使用。
- 调用
ToList或ToArray方法后，序列中没有启动的任务就开始了
static async Task DownloadAllAsync()
{
Stopwatch sw = new Stopwatch();
sw.Start();
IEnumerable<string> urls = new string[]{
"https://www.baidu.com/",
"https://cn.bing.com/"
};
var httpClient = new HttpClient();
// 定义每一个 url 的使用方法。
var downloads = urls.Select(url =>
{
Console.WriteLine($"{url}:start");
var res = httpClient.GetStringAsync(url);
res.ContinueWith(t => Console.WriteLine($"{url}:{sw.ElapsedMilliseconds}ms"));
return res;
});
// 注意，到这里，序列还没有求值，所以所有任务都还没真正启动。
// 下面，所有的 URL 下载同步开始。
Task<string>[] downloadTasks = downloads.ToArray();
// 到这里，所有的任务已经开始执行了。
Console.WriteLine($"await Task.WhenAll");
// 用异步方式等待所有下载完成。
string[] htmlPages = await Task.WhenAll(downloadTasks);
Console.WriteLine($"jobs done.");
}
输出为:
https://www.baidu.com/:start
https://cn.bing.com/:start
await Task.WhenAll
https://www.baidu.com/:270ms
jobs done.
; 由于返回的是请求的 Task 不是 ContinueWith 的打印 Task
https://cn.bing.com/:1089ms
4. 异常处理
如果有一个任务抛出异常，则
Task.WhenAll会出错，并把这个异常放在返回的Task中如果多个任务抛出异常，则这些异常都会放在返回的
Task中如果这个
Task在被await调用，就只会抛出该异步方法的一个异常如果要得到每个异常，可以检查
Task.WhenAll返回的Task的Exception属性:
示例：
static async Task ThrowNotImplementedExceptionAsync()
{
await Task.Delay(10);
throw new NotImplementedException();
}
static async Task<int> ThrowInvalidOperationExceptionAsync()
{
TaskCompletionSource<int> completionSource = new TaskCompletionSource<int>();
completionSource.TrySetException(new InvalidOperationException());
return await completionSource.Task;
}
static async Task ObserveOneExceptionAsync()
{
System.Console.WriteLine("OneException");
var task1 = ThrowNotImplementedExceptionAsync();
var task2 = ThrowInvalidOperationExceptionAsync();
try
{
await Task.WhenAll(task1, task2);
}
catch (Exception ex)
{
// ex 要么是 NotImplementedException，要么是 InvalidOperationException
System.Console.WriteLine(ex.GetType().Name);
}
}
static async Task ObserveAllExceptionsAsync()
{
System.Console.WriteLine("AllExceptions");
var task1 = ThrowNotImplementedExceptionAsync();
var task2 = ThrowInvalidOperationExceptionAsync();
Task allTasks = Task.WhenAll(task1, task2);
try
{
await allTasks;
}
catch
{
AggregateException allExceptions = allTasks.Exception;
allExceptions.Handle(ex =>
{
System.Console.WriteLine(ex.GetType().Name);
return true;
});
}
}
输出为:
OneException
NotImplementedException
AllExceptions
NotImplementedException
InvalidOperationException
5. 等待任意一个任务完成
// 返回第一个响应的 URL 的数据长度。
private static async Task<int> FirstRespondingUrlAsync()
{
string urlA = "https://www.baidu.com/";
string urlB = "https://cn.bing.com/";
var httpClient = new HttpClient();
// 并发地开始两个下载任务。
Task<byte[]> downloadTaskA = httpClient.GetByteArrayAsync(urlA);
Task<byte[]> downloadTaskB = httpClient.GetByteArrayAsync(urlB);
// 等待任意一个任务完成。
Task<byte[]> completedTask = await Task.WhenAny(downloadTaskA, downloadTaskB);
// 返回从 URL 得到的数据的长度。
byte[] data = await completedTask;
Console.WriteLine($"Finish: {(completedTask == downloadTaskA ? nameof(downloadTaskA) : nameof(downloadTaskA))}");
Console.WriteLine($"downloadTaskA: {downloadTaskA.Status}");
Console.WriteLine($"downloadTaskB: {downloadTaskB.Status}");
return data.Length;
}
输出为:
Finish: downloadTaskA
downloadTaskA: RanToCompletion
downloadTaskB: WaitingForActivation
如果这个任务完成时有异常，这个异常也不会传递给 Task.WhenAny 返回的 Task 对象。因此，通常需要在 Task 对象完成后继续使用 await。
第一个任务完成后，考虑是否要取消剩下的任务。如果其他任务没有被取消，也没有被继续 await，那它们就处于被遗弃的状态。被遗弃的任务会继续运行直到完成，它们的结果会被忽略，抛出的任何异常也会被忽略。
// 每个任务需要等到Trace.WriteLine执行完才能执行下一个
static async Task<int> DelayAndReturnAsync(int val)
{
await Task.Delay(TimeSpan.FromSeconds(val));
return val;
}
// 当前，此方法输出“2”,“3”,“1”。 // 我们希望它先输出先完成的，期望 输出“1”,“2”,“3”。
static async Task ProcessTasksAsync1()
{
// 创建任务队列。
Task<int> taskA = DelayAndReturnAsync(2);
Task<int> taskB = DelayAndReturnAsync(3);
Task<int> taskC = DelayAndReturnAsync(1);
var tasks = new[] { taskA, taskB, taskC };
// 按顺序 await 每个任务。
foreach (var task in tasks)
{
var result = await task;
Console.WriteLine(result);
}
}
//不等Trace.WriteLine切任务并行的解决方案
// 现在，这个方法输出“1”,“2”,“3”。
static async Task ProcessTasksAsync2()
{
// 创建任务队列。
Task<int> taskA = DelayAndReturnAsync(2);
Task<int> taskB = DelayAndReturnAsync(3);
Task<int> taskC = DelayAndReturnAsync(1);
var tasks = new[] { taskA, taskB, taskC };
var processingTasks = tasks.Select(async t =>
{
var result = await t;
Console.WriteLine(result);
}).ToArray();
// 等待全部处理过程的完成。
await Task.WhenAll(processingTasks);
}
static async Task ProcessTasksAsyncExe()
{
Stopwatch sw = Stopwatch.StartNew();
System.Console.WriteLine("ProcessTasksAsync1");
await ProcessTasksAsync1();
System.Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
sw.Restart();
System.Console.WriteLine();
System.Console.WriteLine("ProcessTasksAsync2");
await ProcessTasksAsync2();
System.Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
}
输出为:
ProcessTasksAsync1
2
3
1
3007ms
ProcessTasksAsync2
1
2
3
3004ms
6. 避免上下文延续
默认情况下，一个 async 方法在被 await 调用后恢复运行时，会在原来的上下文中运行。 如果是 UI上下文 ，并且有大量的 async 方法在 UI上下文 中恢复，就会引起性能上的问题。
ConfigureAwait(true)延续上下文（执行完异步await，回到同步上下文）ConfigureAwait(false)不延续上下文（执行完异步await，由于没有记录之前的同步上下文，后续代码在 Default上下文 中运行）
7. async void
处理 async void 方法的异常有一个办法: