- A+
一 异步延迟
在异步方法中，如果需要让程序延迟等待一会后，继续往下执行，应使用Task.Delay()方法。
//创建一个在指定的毫秒数后完成的任务。
public static Task Delay(int millisecondsDelay);
//创建一个在指定的毫秒数后完成的可取消任务。
public static Task Delay(TimeSpan delay, CancellationToken cancellationToken);
下例演示Delay的简单用法：
public static void Main() { var t = Task.Run(async delegate { await Task.Delay(1000); return 42; }); t.Wait(); Console.WriteLine("Task t Status: {0}, Result: {1}", t.Status, t.Result); }
下面的例子启动了一个Task，该Task包含对Delay(Int32, CancellationToken)方法的调用，延迟时间为一秒。
token将在延迟时间间隔到期前被取消。因此将引发一个TaskCanceledException，并且Task.Status的属性被设置为Canceled。
public static void Main() { CancellationTokenSource source = new CancellationTokenSource(); var t = Task.Run(async delegate { await Task.Delay(1000, source.Token); return 42; }); source.Cancel(); try { t.Wait(); } catch (AggregateException ae) { foreach (var e in ae.InnerExceptions) Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message); } Console.Write("Task t Status: {0}", t.Status); if (t.Status == TaskStatus.RanToCompletion) Console.Write(", Result: {0}", t.Result); source.Dispose(); }
下面的例子用Task.Delay实现了一个简单的超时功能：
static async Task<string> DownloadStringWithTimeout(string uri) { using (var client = new HttpClient()) { var downloadTask = client.GetStringAsync(uri); var timeoutTask = Task.Delay(3000); //如果服务在3秒内没有响应，就返回null var completedTask = await Task.WhenAny(downloadTask, timeoutTask); if (completedTask == timeoutTask) return null; return await downloadTask; } }
二 返回完成的Task
2.1 Task.FromResult
如果从异步接口或基类继承代码，但希望用同步的方法来实现它，就会出现这样一个问题，如何实现一个具有异步签名的同步方法？
可以使用 Task.FromResult 方法创建并返回一个新的 Task<T> 对象，这个 Task 对象是已经成功完成的，并有指定的结果。
public static Task<TResult> FromResult<TResult>(TResult result);
如下所示：
interface IMyAsyncInterface { Task<int> GetValueAsync(); } class MySynchronousImplementation : IMyAsyncInterface { public Task<int> GetValueAsync() { return Task.FromResult(13); } }
在用同步代码实现异步接口时，要避免使用任何形式的阻塞操作。在异步方法中进行阻塞操作，然后返回一个完成的 Task 对象，这种做法并不可取。
2.1 TaskCompletionSource
Task.FromResult 只能提供结果正确的同步 Task 对象。如果要让返回的 Task 对象有一个其他类型的结果（例如以 NotImplementedException 结束的 Task 对象），
需要使用TaskCompletionSource ：
static Task<T> NotImplementedAsync<T>() { var tcs = new TaskCompletionSource<T>(); tcs.SetException(new NotImplementedException()); return tcs.Task; }
三 报告进度
异步操作执行的过程中，如果需要展示操作的进度，可以考虑使用IProgress<T> 和 Progress<T>。
static async Task CallMyMethodAsync() { var progress = new Progress<double>(); progress.ProgressChanged += (sender, args) => { Console.WriteLine($"当前进度：{args}%"); }; await MyMethodAsync(progress); } static async Task MyMethodAsync(IProgress<double> progress = null) { double percentComplete = 0; while (percentComplete < 100) { await Task.Delay(100); percentComplete++; if (progress != null) progress.Report(percentComplete); } }
按照惯例，如果不需要报告进度，IProgress<T> 参数可以是 null，因此在 async 方法中一定要对此进行检查。
需要注意的是，IProgress<T>.Report 方法可以是异步的。这意味着真正报告进度之前，MyMethodAsync 方法会继续运行。
基于这个原因，最好把 T 定义为一个不可变类型，或者至少是值类型。如果 T 是一个可变的引用类型，就必须在每次调用 IProgress<T>.Report 时，创建一个单独的副本。
Progress<T> 会在创建时捕获当前上下文，并且在这个上下文中调用回调函数。这意味着，如果在 UI 线程中创建了 Progress<T>，就能在 Progress<T> 的回调函数中更新 UI，
即使异步方法是在后台线程中调用 Report 的。
四 等待一组Task完成
如果需要执行几个Task，等待他们全部完成，可以使用Task.WhenAll方法。
//创建一个任务，该任务将在数组中的所有 Task 对象都已完成时完成。 public static Task WhenAll(params Task[] tasks);
下示简单例子：
Task task1 = Task.Delay(TimeSpan.FromSeconds(1)); Task task2 = Task.Delay(TimeSpan.FromSeconds(2)); Task task3 = Task.Delay(TimeSpan.FromSeconds(1)); await Task.WhenAll(task1, task2, task3);
如果所有任务的结果类型相同，并且全部成功地完成，则 Task.WhenAll 返回存有每个任务执行结果的数组：
Task task1 = Task.FromResult(3); Task task2 = Task.FromResult(5); Task task3 = Task.FromResult(7); int[] results = await Task.WhenAll(task1, task2, task3); // "results" 含有 { 3, 5, 7 }
Task.WhenAll 方法有以 IEnumerable 类型作为参数的重载，但最好不要使用。只要异步代码与 LINQ 结合，显式的“具体化”序列（即对序列求值，创建集合）就会使代码更清晰：
static async Task<string> DownloadAllAsync(IEnumerable<string> urls) { var httpClient = new HttpClient(); // 定义每一个 url 的使用方法。 var downloads = urls.Select(url => httpClient.GetStringAsync(url)); // 注意，到这里，序列还没有求值，所以所有任务都还没真正启动。 // 下面，所有的 URL 下载同步开始。 Task<string>[] downloadTasks = downloads.ToArray(); // 到这里，所有的任务已经开始执行了。 // 用异步方式等待所有下载完成。 string[] htmlPages = await Task.WhenAll(downloadTasks); return string.Concat(htmlPages); }
如果有一个任务抛出异常，则 Task.WhenAll 会出错，并把这个异常放在返回的 Task 中。如果多个任务抛出异常，则这些异常都会放在返回的 Task 中。
但是，如果这个 Task 在被await 调用，就只会抛出其中的一个异常。如果要得到每个异常，可以检查 Task.WhenALl返回的 Task 的 Exception 属性：
static async Task ThrowNotImplementedExceptionAsync() { throw new NotImplementedException(); } static async Task ThrowInvalidOperationExceptionAsync() { throw new InvalidOperationException(); } static async Task ObserveOneExceptionAsync() { var task1 = ThrowNotImplementedExceptionAsync(); var task2 = ThrowInvalidOperationExceptionAsync(); try { await Task.WhenAll(task1, task2); } catch (Exception ex) { // ex 要么是 NotImplementedException，要么是 InvalidOperationException } } static async Task ObserveAllExceptionsAsync() { var task1 = ThrowNotImplementedExceptionAsync(); var task2 = ThrowInvalidOperationExceptionAsync(); Task allTasks = Task.WhenAll(task1, task2); try { await allTasks; } catch { //如果要得到每个异常，可以检查 Task.WhenALl返回的 Task 的 Exception 属性： AggregateException allExceptions = allTasks.Exception; } }
五 等待任意一个Task完成
若需要执行若干个任务，只需要对其中任意一个的完成进行响应。如：对一个操作进行多种独立的尝试，只要一个尝试完成，任务就算完成。
可以使用Task.WhenAny方法，该方法的参数是一批任务，当其中任意一个任务完成时就会返回。作为返回结果的 Task 对象，就是那个完成的任务，即表示提供的任务之一已完成的任务。
public static Task<Task> WhenAny(params Task[] tasks);
下示简单例子：
// 返回第一个响应的 URL 的数据长度。 private static async Task<int> FirstRespondingUrlAsync(string urlA, string urlB) { 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; return data.Length; }
注意，返回的任务将在提供的任何任务完成时完成。
返回的任务将始终以 RanToCompletion 状态结束，其 Result 设置为完成的第一个任务。 即使第一个完成的任务以或Faulted状态结束Canceled，也是如此。
如果这个任务完成时有异常，这个异常也不会传递给Task.WhenAny 返回的 Task 对象。因此，通常需要在 Task 对象完成后继续使用 await。
注意，第一个任务完成后，考虑是否要取消剩下的任务。如果其他任务没有被取消，也没有被继续 await，那它们就处于被遗弃的状态。
被遗弃的任务会继续运行直到完成，它们的结果会被忽略，抛出的任何异常也会被忽略。
六 Task完成时的处理
如果正在 await 一批任务，希望在每个任务完成时对它做一些处理。另外，希望在任务一完成就立即进行处理，而不需要等待其他任务。
举个例子，下面的代码启动了 3 个延时任务，然后对每一个进行 await。
static async Task<int> DelayAndReturnAsync(int val) { await Task.Delay(TimeSpan.FromSeconds(val)); return val; } // 当前，此方法输出 2 3 1 // 我们希望它输出 1 2 3 static async Task ProcessTasksAsync() { // 创建任务队列。 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; Trace.WriteLine(result); }
}
虽然列表中的第二个任务是首先完成的，当前这段代码仍按列表的顺序对任务进行 await。
如果我们希望按任务完成的次序进行处理（例如 Trace.WriteLine），不必等待其他任务，可以考虑下面的方案：
static async Task AwaitAndProcessAsync(Task<int> task) { var result = await task; Trace.WriteLine(result); } // 现在，这个方法输出 1 2 3 static async Task ProcessTasksAsync() { // 创建任务队列。 Task<int> taskA = DelayAndReturnAsync(2); Task<int> taskB = DelayAndReturnAsync(3); Task<int> taskC = DelayAndReturnAsync(1); var tasks = new[] { taskA, taskB, taskC }; var processingTasks = (from t in tasks select AwaitAndProcessAsync(t)).ToArray(); // 等待全部处理过程的完成。 await Task.WhenAll(processingTasks); }
上面的代码也可以这么写：
static async Task ProcessTasksAsync() { 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; Trace.WriteLine(result); }).ToArray(); await Task.WhenAll(processingTasks); }
重构后的代码是解决本问题较清晰、可移植性较好的方法。不过它与原始代码有一个细微的区别。重构后的代码并发地执行处理过程，而原始代码是一个接着一个地处理。
七 避免上下文延续
在默认情况下，一个 async 方法在被 await 调用后恢复运行时，会在原来的上下文中运行。
如果是 UI 上下文，并且有大量的 async 方法在 UI 上下文中恢复，就会引起性能上的问题。
为了避免在上下文中恢复运行，可调用 ConfigureAwait 方法，将其参数continueOnCapturedContext 设为 false来解决：
async Task ResumeOnContextAsync() { await Task.Delay(TimeSpan.FromSeconds(1)); // 这个方法在同一个上下文中恢复运行。 } async Task ResumeWithoutContextAsync() { await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false); // 这个方法在恢复运行时，会丢弃上下文。 }
八 处理 async Task 方法的异常
可以用简单的 try/catch 来捕获异常，和同步代码使用的方法一样：
static async Task ThrowExceptionAsync() { await Task.Delay(TimeSpan.FromSeconds(1)); throw new InvalidOperationException("Test"); } static async Task TestAsync() { // 抛出异常并将其存储在 Task 中。 Task task = ThrowExceptionAsync(); try { // Task 对象被 await 调用，异常在这里再次被引发。 await task; } catch (InvalidOperationException) { // 这里，异常被正确地捕获。 } }
关于 asnyc void 方法抛出的异常处理，没什么好的方法，如果可以的话，方法的返回类型不要用 void，把它改为 Task。
最好不要从 async void 方法抛出异常。如果必须使用 async void 方法，可考虑把所有代码放在 try 块中，直接处理异常。
以上。
