C#异步编程
关于异步的概述，这里引用MSDN的一段文字：
异步编程是一项关键技术，使得能够简单处理多个核心上的阻塞 I/O 和并发操作。 如果需要 I/O 绑定（例如从网络请求数据或访问数据库），则需要利用异步编程。 还可以使用 CPU 绑定代码（例如执行成本高昂的计算），对编写异步代码而言，这是一个不错的方案。
异步代码具有以下特点：
- 等待 I/O 请求返回的同时，可通过生成处理更多请求的线程，处理更多的服务器请求。
- 等待 I/O 请求的同时生成 UI 交互线程，并通过将长时间运行的工作转换到其他 CPU 核心，让 UI 的响应速度更快。
- 许多较新的 .NET APIs 都是异步的。
使用异步编程，方法的调用是后台运行，并且不会阻塞调用线程。
异步编程的基础
异步编程的核心是
Task和Task<T>对象，这两个对象对异步操作建模。 它们受关键字async和await的支持。 在大多数情况下模型十分简单：对于 I/O 绑定代码，当你
await一个操作，它将返回async方法中的一个Task或Task<T>。
对于 CPU 绑定代码，当你await一个操作，它将在后台线程通过Task.Run方法启动。await关键字有这奇妙的作用。 它控制执行await的方法的调用方，且它最终允许 UI 具有响应性或服务具有灵活性。
async和await关键字只是编译器功能，实质是编译器会用Task类创建代码。
创建任务
我们先定义一个简单的方法，在该方法中，等待3秒之后返回一个字符串：
public static string Greeting(string name) { //等待3秒 Task.Delay(3000).Wait(); //Wait方法用来等待之前的任务完成 return "Hello," + name; }上述方法中使用了Wait()方法，该方法是一个同步方法，它使调用线程等到当前任务完成。如果当前任务尚未开始执行，则Wait()方法尝试从调度程序中删除该任务，并在当前线程上内联执行该任务。如果无法执行此操作，或者当前任务已经开始执行，则会阻止调用线程，直到任务完成。
我们使用一个简单的代码来测试一下运行效果，如下：
Stopwatch sw = new Stopwatch(); Console.WriteLine("-----开始程序-----"); //开始计时 sw.Start(); //调用方法 Console.WriteLine( AsyncDemo.Greeting("world")); Console.WriteLine("总执行时间：" + sw.Elapsed.Seconds + "秒"); sw.Stop(); Console.WriteLine("-----结束程序-----"); Console.Read();控制台在打印出“-----开始程序-----”后，将会花费3秒时间调用Greeting()方法，上述执行结果如下：
-----开始程序-----
Hello,world 总执行时间：3秒 -----结束程序-----接着我们定义一个将此方法异步化的另一个方法GreetingAsync()，基于任务的异步模式，指定在异步方法名后加上Async后缀，并返回一个任务。如下：
private static Task<string> GreetingAsync(string name) { return Task.Run<string>(() => { return Greeting(name); }); }上述Task<string>定义了一个返回字符串的任务，该方法返回的是一个任务，该任务返回的是一个字符串。
调用异步方法
可以使用await关键字来调用返回任务的异步方法。使用await关键字需要使用async修饰符声明的方法。
public async static void CallerWithAsync() { string result = await GreetingAsync("异步调用方法"); Console.WriteLine(result); }在GreetingAsync()方法完成前，CallerWithAsync()内的其他代码不会继续执行。但是调用CallerWithAsync()方法的线程并没有阻塞，可以被重用。调用CallerWithAsync()方法如下：
Stopwatch sw = new Stopwatch(); Console.WriteLine("-----开始程序-----"); //开始计时 sw.Start(); AsyncDemo.CallerWithAsync(); Console.WriteLine("总执行时间：" + sw.Elapsed.Seconds + "秒"); sw.Stop(); Console.WriteLine("-----结束程序-----"); Console.Read();在上述代码中，直接调用了CallerWithAsync()方法，由于外部并不会被阻塞，所以直接会执行AsyncDemo.CallerWithAsync()之后的代码，得到的结果如下：
-----开始程序-----
总执行时间：0秒 -----结束程序----- Hello,异步调用方法延续任务（await关键字的实质）
Task类的ContinueWith()方法定义了任务完成后就调用的代码。指派给ContinueWith()方法的委托接收将已完成的任务作为参数传入，使用Result属性可以访问任务返回的结果。
将上述使用await关键字调用的方法CallerWithAsync()，使用Task类的ContinueWith()进行实现：
public static void CallerWithContinuationTask() { Task<string> t1 = GreetingAsync("异步调用方法"); t1.ContinueWith(t => { string result = t.Result; Console.WriteLine(result); }); }C#编译器会把await关键字后的所有代码放进ContinueWith()方法的代码块中来转换await关键字。
因此该方法的执行效果和CallerWithAsync()方法的执行效果一样，它们输出结果也相同。
同步上下文
在上述的方法CallerWithAsync()中（或CallerWithContinuationTask()方法中），不同的执行阶段使用了不同的线程，一个线程用于调用CallerWithAsync()方法，我们把这个线程称作为外部调用线程或前台线程、主线程，另一个线程执行await关键字后面的代码，或者继续执行ContinueWith()方法内的代码块，我们把这个线程称为方法内部执行线程或后台线程。在使用异步时，必须保证在所有应该完成的后台任务之前，至少有一个前台线程仍然在运行。上述实例中的Console.Read()就是用来保证主线程一直在运行。
有时候，为了执行某些动作，有些应用程序会绑定到指定的线程上。例如，在winform或WPF应用程序中，只有UI线程才能访问UI元素，这将会是一个问题。在未出现async和await之前，需要借助委托来解决这类问题，代码相对比较繁琐。
而使用
async和await关键字，当await完成之后，不需要进行任何特别处理，就能访问UI线程。默认情况下，生成的代码就会把线程转换到拥有同步上下文的线程中。WPF设置了DispatcherSynchronizationContext属性，winfrom设置了WindowsFormsSynchronizationContext属性。如果调用异步方法的线程分配了同步上下文，await完成之后将继续执行。默认情况下，使用了同步上下文。如果不使用相同的同步上下文，则必须调用Task方法ConfigureAwait(continueOnCapturedContext:false)。例如， 一个WPF应用程序，其await后面的代码没有用到任何的UI元素。在这种情况下，避免切换到同步上下文会执行的更快。
使用多个异步方法
在一个异步方法里，可以调用一个或多个异步方法。如何编写代码，取决于一个异步方法的结果是否依赖于另一个异步方法。
按顺序调用多个异步方法
如果某个异步方法，需要在之前的其他的异步方法执行完后才被调用，就需要使用await关键字。它可以实现一个异步方法依赖另一个异步方法的结果的情况。
public async static void MultipleAsyncMehtods() { string s1 =await GreetingAsync("Mul1"); string s2 =await GreetingAsync("Mul2"); Console.WriteLine("Mul:" + s1 + " " + s2); }使用组合器
如果异步方法不依赖于其他异步方法，比如无返回值的异步方法或返回值互不联系，可以在异步方法被调用时，不使用await关键字，而是把每个异步方法的返回结果赋值给Task变量，这样运行的就会更快一些。
使用组合器，可以同时并行运行多个异步方法。一个组合器可以接受多个同一类型的参数，并返回同一类型的值。多个同一类型的参数被组合成一个参数来传递。Task组合器接受多个Task对象作为参数，并返回一个Task。
下述示例中使用Task.WhenAll组合器方法，它可以等待，直到两个任务都完成：
public async static void MultipleAsyncMethodsWithCombinators1() { Task<string> t1 = GreetingAsync("mulA"); Task<string> t2 = GreetingAsync("mulB"); await Task.WhenAll(t1, t2); Console.WriteLine("结果：" + t1.Result + " " + t2.Result); }Task类型的WhenAll方法定义了多个重载版本，如果所有的任务返回相同的类型，可以使用该类型的数组接收await返回的结果。如下：
private async static void MultipleAsyncMethodsWithCombinators2() { Task<string> t1 = GreetingAsync("mulA"); Task<string> t2 = GreetingAsync("mulB"); string[] result = await Task.WhenAll(t1, t2); Console.WriteLine("结果:" + result[0] + " " + result[1]); }除了WhenAll组合器外，Task类还定义了WhenAny组合器。
WhenAll：从WhenAll方法返回的Task，是在所有传入方法的任务都完成了才会返回Task。WhenAny：从WhenAny返回的Task，是在其中一个传入方法的任务完成了就会返回Task。
转换异步模式
并非.NET Framework的所有类都引入了新的异步方法，有些类只提供了BeginXXX方法和EndXXX方法的异步模式，没有提供基于任务的异步模式。我们可以把这些旧的异步模式转换为新的基于任务的异步模式。
为了模拟出BeginXXX和EndXXX这种形式的方法，对之前的同步方法Greeting()进行扩展：
public static string Greeting(string name) { //等待3秒 Task.Delay(3000).Wait(); //Wait方法用来等待之前的任务完成 return "Hello," + name; } //定义一个委托 private static Func<string, string> greetingInvoker = Greeting; //模拟异步模式 private static IAsyncResult BeginGreeting( string name,AsyncCallback callback, object state) { return greetingInvoker.BeginInvoke(name, callback, state); } //该方法返回来自于Greeting的结果 private static string EndGreeting(IAsyncResult ar) { return greetingInvoker.EndInvoke(ar); } //使用新的基于任务的异步模式进行调用 public static async void ConvertingAsyncPattern() { string s = await Task<string>.Factory.FromAsync<string>( BeginGreeting, EndGreeting, "测试", null); Console.WriteLine(s); }上述实例中，使用
TaskFactory类的FromAsync()方法，把使用旧的异步模式的方法转换为基于任务的异步模式的方法（TAP）。其中，Task类型的第一个泛型参数Task<string>定义了调用方法的返回值类型。FromAsync()方法的泛型参数定义了方法的输入类型。FromAsync()方法的前两个参数是委托类型，传入BeginGreeting和EndGreeting方法的声明。紧跟这两个参数后面的是输入参数和对象状态参数。因对象状态没有用到，所以分配null值。因为FromAsync()方法返回Task类型，可以使用await修饰。
错误处理
为了说明多个异步方法出现错误时的异常处理情况，我们先定义一个简单的方法，如下：
//注：该方法不是最终解决方案，终极方法见下述说明
public static async void ThrowAfter(int ms, string message) { await Task.Delay(ms); throw new Exception(message); }上述方法将在指定的时间间隔抛出一个异常。如果直接在try/catch块中调用该异步方法，并且没有等待，就会捕获不到异常，代码如下：
//注：该方法不是最终解决方案，终极方法见下述说明
public static void DontHandle() { try { ThrowAfter(200, "first"); } catch (Exception ex) { Console.WriteLine(ex.Message); } }上述的代码并不能捕获到任何异常，这是因为DontHandle()方法在ThrowAfter()抛出异常之前，就已经执行完毕。正确的做法是使用await关键字等待ThrowAfter()方法执行完才能捕获。由于ThrowAfter()是一个void方法，返回void的异步方法不能使用await关键字进行等待，就无法捕获异常，因此异常方法最好返回一个Task类型。对上述方法进行重构：
//注：终极方法
public async static Task ThrowAfter(int ms, string message) { await Task.Delay(ms); throw new Exception(message); } //注：终极方法 public async static void DontHandle() { try { await ThrowAfter(200, "first"); } catch (Exception ex) { Console.WriteLine(ex.Message); } }重构后的方法可以正常的捕获抛出的异常信息。
多个异步方法的异常处理
上述示例针对单一的异步方法比较容易捕获，如果是多个异步方法，使用上述这种做法并不能够捕获全部的异常。
例如：
//注：该方法不是最终解决方案，终极方法见下述说明
public static async void StartTwoTask() { try { await ThrowAfter(2000, "first"); await ThrowAfter(1000, "second"); } catch (Exception ex) { Console.WriteLine(ex.Message); } }上述代码中，在第一个ThrowAfter()方法抛出异常后，try/catch代码块就会捕获到异常，直接跳过第二个ThrowAfter()方法的执行，因此本示例只能捕获第一个方法抛出的异常，并不能够捕获第二次抛出的异常。
如果采用Task.WhenAll()方法并行的调用这两个ThrowAfter()方法，代码如下：
//注：该方法不是最终解决方案，终极方法见下述说明
public async static void StartTwoTaskParallel() { try { Task t1 = ThrowAfter(2000, "first"); Task t2 = ThrowAfter(1000, "second"); await Task.WhenAll(t1, t2); } catch (Exception ex) { Console.WriteLine(ex.Message); } }使用Task.WhenAll，不管任务是否抛出异常，都会等到两个任务完成。但是，如果只是单纯的使用Task.WhenAll，实际上并不能捕获所有的异常，上述代码只能捕获第一次调用抛出的异常，并不能捕获第二次抛出的异常。为了捕获所有的异常，需要结合使用AggregateException类型。
使用AggregateException信息捕获所有异常
并行调用异步方法捕获异常的终极解决方案如下：
//注：终极方案代码
public static async void ShowAggregatedException() { Task taskResult = null; try { Task t1 = ThrowAfter(2000, "first"); Task t2 = ThrowAfter(1000, "second"); await (taskResult = Task.WhenAll(t1, t2)); } catch (Exception ex) { Console.WriteLine(ex.Message); foreach(var ex1 in taskResult.Exception.InnerExceptions) { Console.WriteLine(ex1.Message); } } }通过外部任务的Exception属性，Exception属性是AggregateException类型的，这个类型定义了InnerExceptions属性，它包含了等待中的所有异常的列表，通过遍历列表，可以捕获每一次任务的异常信息。
取消任务
取消任务常常应用于长时间运行的后台任务。对于取消任务，.NET提供了一种标准的机制。这种机制可用于基于任务的异步模式。
取消框架基于协助行为，不是强制性的。一个运行时间很长的任务需要检查自己是否被取消，在这种情况下，它的工作就是清理所有已打开的资源，并结束相关工作。
取消基于CancellationTokenSource类，该类用于发送取消请求。请求发送给引用CancellationToken结构类的任务，其中CancellationToken结构与CancellationTokenSource类相关联。
CancellationTokenSource类还支持在指定时间后才取消任务。CancelAfter方法传入一个时间值，单位是毫秒，在该时间过后，就取消任务。
可以将CancellationToken传入异步方法，框架中的某些异步方法提供可以传入CancellationToken的重载版本，来支持取消任务。一旦取消，就会清理资源，之后抛出异常。
注：取消任务之后，都会抛出异常，可以通过调试的方式，在catch块中进行捕获对应的异常信息。
个人总结
await关键字用来修饰的是返回Task[<T>]的方法，而不是一个返回普通类型的方法，并不是方法名带有async就一定要使用await关键字修饰，需要根据该方法返回的类型进行确定。- 在方法的内部使用了
await关键字的方法，必须使用async关键字进行修饰。 - 使用了
async关键字修饰的方法，在被主线程调用时，该主线程并不会受方法内部的await关键字的影响，不会被阻塞，依然会运行。而方法内部使用await修饰的代码，在未完成前，其他代码不会被执行。