异步编程基础
使用 async 和 await 进行异步操作的基础知识，其中只会涉及自然异步操作，如 HTTP 请求、数据库指令、Web 服务调用等。
一、需要通过 异步签名实现同步方法时，返回已完成的任务
如果在继承异步接口或者基类的同时又想同步实现该任务，便可能发生这样的情况。当需要异步接口的简单签名或模拟对象时，或者当需要对异步代码做单元测试时，这项技术特别有用。
public interface IMyAsyncInterface
{
Task<int> GetValueAsync();
Task DoSomethingAsync();
Task<T> NotImplementedAsync<T>();
Task<int> GetValueAsync(CancellationToken token);
Task<T> DelayResult<T>(T result, TimeSpan delay);
}
public class MySynchronousImplementation : IMyAsyncInterface
{
public async Task<T> DelayResult<T>(T result, TimeSpan delay)
{//暂停一段时间，当程序需要异步等待一段时间。在进行单元测试或实现重试延迟时，这是一种常见的场景。
await Task.Delay(delay);
return result;
}
public Task DoSomethingAsync()
{
//1.异步签名实现同步方法，并且无返回值
try
{
//DoSomethingSynchronously()
return Task.CompletedTask;
}
catch (Exception ex)
{//同步实现可能会失败，就应当捕捉异常并通过Task.FromExceptiion 来返回它们。
return Task.FromException(ex);
}
}
public Task<int> GetValueAsync()
{
//2.异步签名实现同步方法，并且有返回值
return Task.FromResult(13);
}
public Task<int> GetValueAsync(CancellationToken token)
{
//3.带取消功能的任务
if (token.IsCancellationRequested)
return Task.FromCanceled<int>(token);
return Task.FromResult(13);
}
public Task<T> NotImplementedAsync<T>()
{
//4.需要返回异常报错信息
return Task.FromException<T>(new NotImplementedException());
}
}
二、实时更新进度
Progress<T> 会在创建时捕获当前上下文，并在此上下文中调用回调函数。即：如果是在 UI 线程中创建的，那么即使使用异步方法在后台线程中调用 Report ,我们也可以在它的回调函数中更新 UI .
IProgress<T>.Report 方法通常是异步，T 最好定义为值类型。
IProgress<T> 并非专用于异步代码，在耗时较长的同步代码中也可以使用。
public async Task MyMethodAsync(IProgress<double> progress = null)
{
double percentComlete = 0;
do
{
percentComlete += 2;
progress?.Report(percentComlete);//报告进度
}
while (percentComlete < 100);
}
public async Task CallMyMethodAsync()
{
var progress = new Progress<double>();
progress.ProgressChanged += (sender, e) =>
{
Console.WriteLine(e.ToString());
};
await MyMethodAsync(progress);
}
运行结果：
三、等待多个任务完成
场景：有多个任务，需要等等他们全部完成。
3.1 无返回结果的任务
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);
3.2 全部任务都有着相同返回结果类型
Task<int> task1 = Task.FromResult(3);
Task<int> task2 = Task.FromResult(5);
Task<int> task3 = Task.FromResult(7);
int[] results = await Task.WhenAll(task1, task2, task3);
foreach (int result in results)
{
Console.WriteLine(result.ToString());
}
运行结果：3，5，7
3.3. Task.WhenAll() 的 IEnumerable 参数类型重载
public async Task<string> DownloadAllAsync(HttpClient httpClient, IEnumerable<string> urls)
{
//为每个 URL 定义请求操作
var downloads = urls.Select(url => httpClient.GetStringAsync(url));
Task<string>[] downloadTasks = downloads.ToArray();
//异步等待所有下载任务完成，并返回结果
string[] htmlPages = await Task.WhenAll(downloadTasks);
return string.Concat(htmlPages);
}
3.4 等待多个任务的异常处理
async Task ThrowNotimplmentedExceptionAsync()
{
throw new NotImplementedException();
}
async Task ThrowInvalidOperationExceptionAsync()
{
throw new InvalidOperationException();
}
3.4.1 仅捕捉其中的一个异常(推荐)
public async Task ObserveOneExceptionAsync()
{
var task1=ThrowNotimplmentedExceptionAsync();
var task2=ThrowInvalidOperationExceptionAsync();
try
{
await Task.WhenAll(task1, task2);
}
catch (Exception ex)
{//仅能捕捉一个任务的异常
//ex 不是 NotImplementedException 就是 InvalidOperationException
}
}
3.4.2 捕捉全部异常
public async Task ObserveAllExceptionsAsync() { var task1=ThrowNotimplmentedExceptionAsync(); var task2=ThrowInvalidOperationExceptionAsync(); Task allTasks= Task.WhenAll(task1, task2); try { await allTasks; } catch {//捕捉全部任务的异常 AggregateException allExceptions = allTasks.Exception; } }
四、仅等待其中任意一个任务完成
场景：针对同一个操作进行多次独立尝试，并且一次成功即可算作任务完成。比如：同时从多个 Web 服务请求股票行情信息，只要有一个请求有响应任务就算完成。
public async Task<int> FirstRespondingUrlAsync(HttpClient client, string urlA, string urlB)
{
//设置两个下载任务
Task<byte[]> downloadTaskA = client.GetByteArrayAsync(urlA);
Task<byte[]> downloadTaskB = client.GetByteArrayAsync(urlB);
//等待两个任务中的任务一个任务完成，即可得到结果
Task<byte[]> completedTask = await Task.WhenAny(downloadTaskA, downloadTaskB);
//返回从 URL 中获取的数据长度
byte[] result = await completedTask;
return result.Length;
}
五、等待全部任务完成，同时 其中任意一个任务完成时，实时处理相关结果
async Task<int> DelayAndReturnAsync(int value)
{
await Task.Delay(TimeSpan.FromSeconds(value));
return value;
}
错误示范：
public async Task ProcessTasksAsync()
{//1.按任务在列表中的顺序依次执行，即：执行顺序为：task1->task2->task3 。(不推荐)
//打印结果：2，3，1，理想的打印结果：1，2，3，因为 task3 只等待1秒，最先完成。
Task<int> task1 = DelayAndReturnAsync(2);
Task<int> task2 = DelayAndReturnAsync(3);
Task<int> task3 = DelayAndReturnAsync(1);
Task<int>[] tasks = new[] { task1, task2, task3 };
foreach (var task in tasks)
{//按顺序等待每个任务
var result=await task;
Trace.WriteLine(result);
}
}
正确示范：
async Task AwaitAndProcessAsync(Task<int> task)
{
int result=await task;
Trace.WriteLine(result);//处理当前已完成的任务结果
}
public async Task ProcessTasksAsync2()
{//2.1 任务完成时，实时处理结果，与任务在列表中的顺序无关。(推荐)
//打印结果：1，2，3
Task<int> task1 = DelayAndReturnAsync(2);
Task<int> task2 = DelayAndReturnAsync(3);
Task<int> task3 = DelayAndReturnAsync(1);
Task<int>[] tasks = new[] { task1, task2, task3 };
IEnumerable<Task> taskQuery=from t in tasks select AwaitAndProcessAsync(t);
Task[] processingTasks=taskQuery.ToArray();
//等待全部任务完成
await Task.WhenAll(processingTasks);
}
public async Task ProcessTasksAsync3()
{//2.2 任务完成时，实时处理结果，与任务在列表中的顺序无关。(可选)
//打印结果：1，2，3
Task<int> task1 = DelayAndReturnAsync(2);
Task<int> task2 = DelayAndReturnAsync(3);
Task<int> task3 = DelayAndReturnAsync(1);
Task<int>[] tasks = new[] { task1, task2, task3 };
Task[] processingTasks =tasks.Select(async t =>
{
var result=await t;
Trace.WriteLine(result);//处理当前已完成的任务结果
}).ToArray();
//等待全部任务完成
await Task.WhenAll(processingTasks);
}
六、当任务完成时，不需要恢复上下文
async Task ResumeOnContextAsync()
{
await Task.Delay(TimeSpan.FromSeconds(1));
//当任务执行完成时，继续执行方法时恢复上下文
//dosomething...
}
async Task ResumeWithoutContextAsync()
{
await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
//当任务执行完成时，继续执行方法时，已丢弃上下文
//dosomething...
}
当 async 在 await 之后恢复时，它默认会在主线程当前上下文中继续执行。如果是在UI主线程，并且有很多 async 方法时，可能会引发性能问题。
建议：在UI主线程中，每秒上百个尚可，每秒上千个则过多。
最好从一开始就避免这个问题，针对任意无须在原始上下文中恢复的 async 方法，调用 configureAwait(false) 方法。这样做不会产生任何负作用。
如果有一个 async 方法，其中部分需要上下文，分部不需要上下文，那么可以考虑将其拆分成两个或多个 async 方法，这样在组织代码时，层次会更为清晰。
