.NET异步程序设计之async&await

[TOC]

---

## 0.背景引入 现在的.net异步编程中，一般都是使用 **基于任务异步模式**(Task-based Asynchronous Pattern，TAP)实现异步编程 可参考[微软文档：使用基于任务的异步模式](https:/https://img.qb5200.com/download-x/docs.microsoft.com/zh-cnhttps://img.qb5200.com/download-x/dotnet/standard/asynchronous-programming-patterns/consuming-the-task-based-asynchronous-pattern) 基于任务的异步模式，是使用` System.Threading.Tasks.Task` 命名空间中的` System.Threading.Tasks.Task` 和 `System.Threading.Tasks `类型实现异步编程， 配合着C#5.0(.net 4.5)中添加的两个关于异步编程的关键字`async`和 `await`,可以快速的实现异步操作。

---

## 1.async和await基本语法 #### 1.1 简介 在C#5.0(.net 4.5)中添加了两个关于异步编程的关键字`async`和 `await` 两个关键字可以快速的创建和使用异步方法。`async`和`await`关键字只是编译器功能，编译后会用Task类创建代码，实现异步编程。其实只是C#对异步编程的语法糖，本质上是对Task对象的包装操作。 所以，如果不使用这两个关键字，也可以用C#4.0中Task类的方法来实现同样的功能，只是没有那么方便。(见:[.NET异步程序设计之任务并行库](https://www.cnblogs.com/shanzhiming/p/12315548.html)) #### 1.2 具体使用方法 1. `async`:用于异步方法的函数名前做修饰符，处于返回类型左侧。async只是一个标识符，只是说明该方法中有一个或多个await表达式，async本身并不创建异步操作。 2. `await`:用于异步方法内部，用于指明需要异步执行的操作（称之为**await表达式**），注意一个异步方法中可以有多个await表达式，而且应该至少有一个（若是没有的话编译的时候会警告，但还是可以构建和执行，只不过就相当于同步方法而已）。 其实这里你有没有想起Task类中为了实现延续任务而使用的等待者，比如:使用`task.GetAwaiter()`方法为task类创建一个等待者（可以参考；[3.3.2使用Awaiter](https://www.cnblogs.com/shanzhiming/p/12315548.html#%E4%B8%BAtask%E6%B7%BB%E5%8A%A0%E5%BB%B6%E7%BB%AD%E4%BB%BB%E5%8A%A1)）。`await`关键字就是基于 .net 4.5中的awaiter对象实现的。 3. 总而言之，若是有`await`表达式则函数一定要用`async`修饰，若是使用了`async`修饰的方法中没有`await`表达式，编译的时候会警告！ #### 1.3 返回值类型 0. 使用`async`和`await`定义的异步方法的返回值只有三种：`Task`、`Task`、`void` 1. 异步方法中有return语句，则返回值类型为`Task`,其中`T`是return语句返回对象的类型。（编译器帮我们把`T`类型数据转换为`Task`类型）。所以不要使用return返回一个`Task`类型的对象，而是只需要返回一个`T`类型数据即可 2. 异步方法中没有return语句，但是你需要查看异步方法的状态或是要对Task对象操作（比如task.Wait()），则可定义返回值类型为`Task`。 3. 异步方法中没有return语句且不需要查看异步方法的状态，则可认为是返回值是`void`类型。此时称之为“**调用并忘记**”（fire and forget），其实这并不是一个很好的用法（具体的分析可以看：异步方法的异常处理）！ 4. 若是真的需要返回一个`Task`类型的数据 (比如在非async修饰的方法中，定义返回值类型就是一个`Task`类型)，则： * `return Task.Run(()=>{……})` * 将`T`类型转换为`Task`类型:`return Task.FromResult(T data)` * 将`IAsyncResult`类型对象转换为Task类型：`return Task.Factory.FromTask(IAsyncResult data)` #### 1.4 其他细节 1. `async`修饰符**只能**用于返回`Task`、`Task`和`viod`的方法,或者Lambda表达式中。 2. `async`不能用于程序的入口点，即Main()不能使用`async`修饰符。 3. `await`**只能**用于返回值是Task的方法。 #### 1.5 async传染性 1. 简单的说：函数体中含有`await`表达式的函数，必须使用`async `修饰！ 而一个使用了`async`修饰的方法，在调用它的时候如有必要则必须使用`await`等待！ 使用了`await`等待的方法，则其调用方法又必须使用`async`修饰，这从而形成了一个循环，这就是**async传染** 换句话说就是哪里调用了`async`修饰的方法则`async`就会传染到哪！ 可以有的时候我们并不想要我们的方法变为`async`修饰的方法，所以需要避免`async`传染 避免的主要方法就是使用**延续任务**来避免，你想一想之前在Task类中，使用延续任务时，主要就是避免使用`await`等待！ [参考：C# 5.0中同步执行异步方法](https://www.kechuang.org/t/79529) 2. 之前我们说了：主函数Main()不能使用`async`修饰符，因为Main函数不能够是异步方法，这也就意味着一切的异步方法最终的调用方法一定是同步方法，而调用异步方法的那个同步方法，称之为**病源隔断方法**，因为在这里开始，不再会发生async传染。 #### 1.6 简单示例 示例1：定义一个异步方法,并调用它 ```cs static void Main(string[] args) { Task t = SumAsync(1, 2); t.ContinueWith(t => Console.WriteLine( "异步操作结果为：" + t.Result)); for (int i = 0; i < 10; i++) { Thread.Sleep(1000); Console.WriteLine($"循环次数{i}"); } Console.ReadKey(); } private static async Task SumAsync(int num1, int num2) { int sum = await Task.Run(() => { Thread.Sleep(3000); return num1 + num2; }); return sum; } ``` **示例说明** ： 1. 异步方法SumAsync()函数体中返回的是整型sum，即返回的是一个整型,但是在声明函数时，返回值需写为：`Task` 反过来说：**若是异步方法的返回值类型为`Task`,则在方法中只需要返回`T`类型的数据**。 这一点就是和Task.Run()的返回值的书写方式一样，即若`Task.Run()`参数是有返回值的委托`Func`,则`Task.Run()`返回值是`Task`泛型 2. 异步方法的命名默认是在最后加"Async",即"XXXAsync"。 3. 调用异步方法的方法称之为**调用方法**（在这里就是主函数Main()）,**调用方法和被调用的异步方法，不一定在不同的线程中**。 4. 其实你看上面示例的代码也会发现，单独把异步操作封装为一个异步方法，这样可以为异步操作传参！ 你可以还记得的在[.net异步程序设计之任务并行库](https://www.cnblogs.com/shanzhiming/p/12315548.html#task%E7%B1%BB%E7%AE%80%E4%BB%8B)中，多次说明Task.Run()的参数只能是无参委托。 5. 有一点在这里说明一下：关于异步匿名方法，或是异步Lambda表达式。 在为一个事件绑定事件处理程序的时候，对于一些简单的事件处理程序，我们可以使用Lambda表达式 但是我们想要异步操作Lambda表达式，则可以直接写为： ```cs Butten.Click+=async(sender,e)=>{...await...} ``` 详细可以参照《C#图解教程:20.5使用异步Lambda表达式》

---

## 2.异步方法的执行顺序 依旧是上面的示例，我们在每个操作中、操作前、操作后都打印其当前所处的线程，仔细的观察，异步方法的执行顺序。 再次强调，这里用async修饰的方法，称之为**异步方法**，这里调用该异步方法的方法，称之为**调用方法** 代码： ```cs //调用方法 static void Main(string[] args) { Console.WriteLine($"-1-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中调用异步方法之前的代码"); Task result = SumAsync(1, 2); Console.WriteLine($"-3-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中调用异步方法之后的代码"); result.ContinueWith(t => Console.WriteLine($"-8-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------这是延续任务的线程" + "-异步操作结果为：" + result.Result)); Console.WriteLine($"-4-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中延续任务之后的代码"); for (int i = 0; i < 5; i++) { Thread.Sleep(1000); Console.WriteLine($"正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}"+$"循环次数{i}--------------------------------------调用方法中延续任务之后的代码"); } Console.ReadKey(); } //异步方法 private static async Task SumAsync(int num1, int num2) { Console.WriteLine($"-2-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------异步方法中await表达式之前的代码"); int sum1 = await Task.Run(() => { Thread.Sleep(3000); Console.WriteLine($"-5-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------这是第一个await表达式的线程"); return num1 + num2; }); Console.WriteLine($"-6-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------异步方法中await表达式之后的代码"); int sum2=await Task.Run(() => { Thread.Sleep(3000); Console.WriteLine($"-7-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------这是第二个await表达式的线程"); return num1 + num2; }); return sum1+sum2; } ``` 运行结果：  **说明**： 注意运行顺序： 调用异步方法方法后，按照同步顺序执行异步方法中await表达式之前的代码， 当运行到第1个await表达式后，创建一个新的线程，后台执行该await表达式，实现异步。 第1个await表达式，未完成之前，继续执行**调用函数中**的异步方法之后的代码（**注意await表达式后台未完成之前，不是继续执行await表达式之后的代码，而是继续执行调用函数中的异步方法之后的代码**）， 当第1个await表达式在后台完成后，继续执行**异步方法中**第1个await表达式之后的代码， 当运行到第2个await表达式后，创建一个新的线程，后台运行该await表达式， 第2个await表达式，未完成之前，继续执行**调用函数中**被第1个await完成后打断的的代码 当第2个await表达式在后台运行完成后，继续执行**异步方法中**第2个await表达式之后的代码， 当异步方法运行到return后，则开始**调用方法中**的对该异步方法的延续任务 该延续任务和调用方法不在一个线程中，这里有可能和第2个await表达式在同一个线程中，也有可能和第1个await表达式在同一个线程中。

---

## 3.取消一个异步操作 具体可参考：[.net异步编程值任务并行库-3.6取消异步操作](https://www.cnblogs.com/shanzhiming/p/12315548.html#%E5%8F%96%E6%B6%88%E5%BC%82%E6%AD%A5%E6%93%8D%E4%BD%9C) 原理是一样的，都是使用`CancellationToken`和`CancellationTokenSource`两个类实现取消异步操作 看一个简单的示例： ```cs static void Main(string[] args) { CancellationTokenSource cts = new CancellationTokenSource();//生成一个CancellationTokenSource对象， CancellationToken ct = cts.Token;//该对象可以创建CancellationToken对象，即一个令牌（token) Task result = DoAsync(ct, 50); for (int i = 0; i <= 5; i++)//主线程中的循环（模拟在异步方法声明之后的工作） { Thread.Sleep(1000); Console.WriteLine("主线程中的循环次数：" + i); } cts.Cancel();//注意在主线程中的循环结束后（5s左右），运行到此处， //则此时CancellationTokenSource对象中的token.IsCancellationRequested==true //则在异步操作DoAsync()中根据此判断，则取消异步操作 Console.ReadKey(); CancellTask(); CancellTask2(); } //异步方法：取消异步操作的令牌通过参数传入 static async Task DoAsync(CancellationToken ct, int Max) { await Task.Run(() => { for (int i = 0; i <= Max; i++) { if (ct.IsCancellationRequested)//一旦CancellationToken对象的源CancellationTokenSource运行了Cancel();此时CancellationToken.IsCancellationRequested==ture { return; } Thread.Sleep(1000); Console.WriteLine("次线程中的循环次数：" + i); } }/*,ct*/);//这里取消令牌可以作为Task.Run()的第二个参数，也可以不写！ } ```

---

## 4.同步和异步等待任务 #### 4.1 在调用方法中同步等待任务 “调用方法可以调用任意多个异步方法并接收它们返回的Task对象。然后你的代码会继续执行其他任务，但在某个点上可能会需要等待某个特殊Task对象完成，然后再继续。为此，Task类提供了一个实例方法wait，可以在Task对象上调用该方法。”--《C#图解教程》 [使用`task.Wait();`等待异步任务task完成](https://www.cnblogs.com/shanzhiming/p/12315548.html#%E5%88%9B%E5%BB%BA%E6%97%A0%E8%BF%94%E5%9B%9E%E5%80%BC%E7%9A%84task%E4%BB%BB%E5%8A%A1): `Wait`方法用于单一Task的对象。若是想要等待多个Task，可以使用Task类中的两个静态方法,其中`WaitAll`等待所有任务都结束，`WaitAny`等待任一任务结束。 示例：使用Task.WaitAll()和Task.WaitAny() ```cs static void Main(string[] args) { Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:Task之前..."); Task t1 = DoAsync(2000); Task t2 = DoAsync(6000); //Task.WaitAll(t1, t2);//等待t1和t2都完毕后才进行后续的代码（即阻塞了主线程） //Task.WaitAny(t1, t2);//等待t1和t2中有任一个完成（调试的时候，你就会发现当t1完成后就开始执行后续的循代码） for (int i = 0; i < 10; i++) { Thread.Sleep(1000); Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2}:循环中"); } Console.ReadKey(); } private static async Task DoAsync(int num) { int result = await Task.Run(() => { Thread.Sleep(num); Console.WriteLine($"当前线程ID{Thread.CurrentThread.ManagedThreadId,2}:异步操作之等待：{num}s"); return num; }); return result; } ``` **说明1** : 对代码中注释掉的代码分别调试，则可以发现其中的不同。 `Task.WaitAll(params Task[] tasks)`:表示停止当前主线程，等待Task类型数组tasks中的所有Task操作结束，即会发生阻塞 Task.WaitAll()调试结果：  **说明2**: `Task.WaitAny(params Task[] tasks)`:表示停止当前主线程，等待Task类型数组tasks中的任一个Task操作结束，也是会发生阻塞，单是阻塞主线程在任一个Task操作结束，之后主线程会继续，其他的Task在后台继续 Task.WaitAny()调试结果： 
#### 4.2 在调用方法中异步等待任务 #### 4.2.1使用await等待异步任务 其实在一个方法中调用多个异步方法时候，当某个异步方法依赖于另外一个异步方法的结果的时候，我们一般是在每一个调用的异步方法处使用`await`关键字等待该异步操作的结果，但是这样就会出现`async`传染。 `await`不同于`Wait()`,`await`等待是异步的，不会阻塞线程，而`Wait()`会阻塞线程 注意如无必用，或是不存在对某个异步操作的等待，尽量不要使用`await`,直接把异步操作的返回值给`Task`类型的变量，可以使程序运行的更快！ 其实你也注意到了：不使用`await`等待异步操作，则异步操作的返回值就是定义的返回值`Task`，但是使用`await`等待则异步操作的返回值就是具体的简单类型，比如int类型等。 换言之：**异步方法的返回值是`Task`,则使用`await`等待可以直接获取异步方法的`T`类型的返回值** 示例： ```cs static void Main(string[] args) { ReferencingMethodAsync(); } //该调用函数也要使用async关键字修饰（即async传染），因为使用了await等待， private static async void ReferencingMethodAsync() { int result1 = await SumAsync(1, 2);//这里使用了await 关键字则，调用方法MultipleMethod2()必须使用async修饰（即async传染性） int result2 = await SumAsync(1, result1); Console.WriteLine(result2); } private static async Task SumAsync(int num1, int num2) { int sum = await Task.Run(() => { Thread.Sleep(3000); return num1 + num2; }); return sum; } ``` #### 4.2.2使用WhenAll()和WhenAny() **`Task.WhenAll()`和`Task.WhenAny()`是`Task.WaitAll()`和`Task.WaitAny()`的异步版本，即异步等待Task完成** 示例:使用Task.WhenAll()和Task.WhenAny() ```cs static void Main(string[] args) { Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:Task之前..."); Task t1 = DoAsync(2000); Task t2 = DoAsync(6000); //Task.WhenAll(t1, t2);//异步等待t1和t2两个完成（调试的时候你会发现任务t1和t2都在新的线程中执行，主线继续执行后续的循环代码） //Task.WhenAny(t1, t2);//异步等待t1和t2中任一个完成（调试的时候你就会发现两个任务分别在新线程中执行，线程继续执行后续的循环代码，当t1完成后，继续后续的循环代码） for (int i = 0; i < 10; i++) { Thread.Sleep(1000); Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2}:循环中"); } Console.ReadKey(); } private static async Task DoAsync(int num) { int result = await Task.Run(() => { Thread.Sleep(num); Console.WriteLine($"当前线程ID{Thread.CurrentThread.ManagedThreadId,2}:异步操作之等待：{num}s"); return num; }); return result; } ``` **说明1**： 在示例中看到Task.WhenAll和Task.WhenAny的使用，但是在实际中有什么作用呢？ 首先，如前所所述，Task.WhenAll()和Task.WhenAny()是Task.WaitAll()和Task.WaitAny()的异步版本，但是呢，Task.WaitAll()和Task.WaitAny()是没有返回值的，`Task.WhenAll()`和`Task.WhenAny()`是有返回值，返回值类型是一个Task对象，所以你可以给其一个延续任务，即在异步等待的Task完成后，指定继续执行的Task。 所以当调用的异步方法没有相互的依赖的时候，一般还是使用WhenAll(),来等待异步方法，同时也可以给所有的异步方法结束后添加一个延续任务！ 示例：为异步等待后添加延续工作 ```cs static void Main(string[] args) { Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:Task之前..."); Task t1 = DoAsync(2000); Task t2 = DoAsync(6000); //Task.WhenAll(t1, t2).ContinueWith(t => Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:延续任务，两个异步操作返回值是一个int[],其中元素分别是{t.Result[0]}、{t.Result[1]}")); //Task.WhenAny(t1, t2).ContinueWith(t => Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:延续任务，第一个完成的异步操作返回值是{t.Result.Result}")); for (int i = 0; i < 8; i++) { Thread.Sleep(1000); Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2}:循环中"); } Console.ReadKey(); } private static async Task DoAsync(int num) { int result = await Task.Run(() => { Thread.Sleep(num); Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2}:异步操作之等待：{num}s"); return num; }); return result; } ``` **说明1**： 若是`Task.WhenAll()`后的延续工作，则注意`Task.WhenAll()`的返回的`Task`的`Result`是`TResult[]`类型 即多个Task的返回值，存放在一个数组中 运行结果：  **说明2**: 若是`Task.WhenAny()`后的延续工作，则注意`Task.WhenAny()`的返回的是`Task`类型，即其`Result`是`Task`类型，所以为了获取第一结束的Task的返回值，需要：`t.Result.Result`。 运行结果：  **说明3**： `Task.WhenAll(Task[] tasks).ContinueWith(Action)` 等价于`Task.Factory.ContinueWhenAll(Task[] tasks, Action) ` `Task.WhenAny(Task[] tasks).ContinueWith(Action)` 等价于`Task.Factory.ContinueWhenAny(Task[] tasks, Action)`

---

## 5.异步操作中的异常处理 #### 5.1 异常处理 一般程序中对异常的处理使用`try{……} catch{……}` 首先看一个捕获异常失败的示例： 在Main()中调用`ThrowEx(2000,"这是异常信息")`,第一个参数是ThrowEx中的Tast延迟的时间，第二个参数是ThrowEx中的抛出异常的信息。 ```cs static void Main(string[] args) { try { ThrowEx(2000, "这是异常信息"); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); } private async static Task ThrowEx(int ms, string message)//注意这里的返回值类型为Task，若是写成void也是无法在catch语句中捕获异常，但是运行vs会报错(见：说明2) { await Task.Delay(ms).ContinueWith(t => Console.WriteLine("hello word")); throw new Exception(message); } ``` **说明1：** 多打断点,就可以发现为何捕捉不到异常了。 因为当调用`ThrowEx(2000, "异常信息")`，开始异步方法中的await表达式， 即创建一个新的线程，在后台执行await表达式，而主线程中此时会继续执行`ThrowEx(2000, "异常信息"); `后的代码:`catch (Exception ex)`， 此时，异步方法中还在等待await表达式的执行，还没有抛出我们自己定义的异常,所以此时压根就没有异常抛出，所以catch语句也就捕获不到异常， 而当异步方法抛出异常，此时主线程中catch语句已经执行完毕了！ **说明2：** 在**1.基本语法-返回值类型**中我们说道：在编写异步方法的时候，有时后没有返回值，也不需要查看异步操作的状态，我们设置返回值类型为`void`，而且称之为“调用并忘记”。然而这种异步代码编写方式,并不值得提倡。 为什么呢？若是没有返回值，异步方法中抛出的异常就无法传递到主线程，在主线程中的`catch`语句就无法捕获拍异常！所以**异步方法最好返回一个Task类型**。 异步方法有返回值的时候，抛出的在异常会置于Task对象中，可以通过task.IsFlauted属性查看是否有异常，在主线程的调用方法中，使用`catch`语句可以捕获异常！
正确示例：只需要给调用的异步方法，添加一个`await`。 ```cs static void Main(string[] args) { try { await ThrowEx(2000, "这是异常信息"); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); } private async static Task ThrowEx(int ms, string message) { await Task.Delay(ms).ContinueWith(t => Console.WriteLine("hello word")); throw new Exception(message); } ``` #### 5.2 多个异步方法的异常处理 使用`Task.WhenAll()`处理多个异步方法中抛出异常 当有多个异步操作，使用WhenAll异步等待，其返回值是一个Task类型对象，该对象的异常为`AggregateException`类型的异常，每一个的子任务（即WhenAll所等待的所有任务）抛出的异常都是包装在这一个AggregateException中，若是需要打印其中的异常，则需要遍历`AggregateException.InnerExceptions` ```cs static void Main(string[] args) { Task taskResult = null;//注意因为在catch语句中需要使用这个WhenAll的返回值，所以定义在try语句之外。 try { Console.WriteLine($"当前的线程Id：{Thread.CurrentThread.ManagedThreadId,2}:do something before task"); Task t1 = ThrowEx($"这是第一个抛出的异常信息:异常所在线程ID：{Thread.CurrentThread.ManagedThreadId,2}", 3000); Task t2 = ThrowEx($"这是第二个抛出的异常信息:异常所在线程ID：{Thread.CurrentThread.ManagedThreadId,2}", 5000); await (taskResult = Task.WhenAll(t1, t2)); } catch (Exception)//注意这里捕获的异常只是WhenAll()等待的异步任务中第一抛出的异常 { foreach (var item in taskResult.Exception.InnerExceptions)//通过WhenAll()的返回对象的Exception属性来查阅所有的异常信息 { Console.WriteLine($"当前的线程Id：{Thread.CurrentThread.ManagedThreadId,2}:{item.Message}"); } } } private async static Task ThrowEx(int ms, string message) { await Task.Delay(ms).ContinueWith(t => Console.WriteLine("hello word")); throw new Exception(message); } ``` 运行结果：  **说明** ： `Task.WhenAll()`返回的Task对象中的Exception属性是`AggregateException`类型的异常. 注意，该访问该异常`InnerExcption`属性则只包含第一个异常，该异常的`InnerExcptions`属性，则包含所有子任务异常. #### 5.3 AggregateException中的方法 首先多个异步操作的异常会包装在一个AggregateException异常中，被包装的异常可以也是AggregateException类型的异常，所以若是需要打印异常信息可能需要循环嵌套，比较麻烦。 故可以使用 `AggregateException.Flatten()`打破异常的嵌套。 **注意，凡是使用`await`等待的异步操作，它抛出的异常无法使用`catch(AggregateException)`捕获！** 只能使用`catch (Exception)`对异常捕获，在通过使用Task的返回值的Exception属性对异性进行操作。 当然你要是想使用`catch(AggregateException)`捕获到异常，则可以使用task.Wait()方法等待异步任务，则抛出的异常为AggregateException类型的异常 示例：（[完整Demo](https://github.com/shanzm/AsynchronousProgramming/blob/master/009AggregateException%E4%B8%AD%E6%96%B9%E6%B3%95/Program.cs)） ```cs catch (AggregateException ae)//AggregateException类型异常的错误信息是“发生一个或多个异常” { foreach (var exception in ae.Flatten().InnerExceptions) //使用AggregateException的Flatten()方法，除去异常的嵌套,这里你也可以测试不使用Flatten(),抛出的信息为“有一个或多个异常” { if (exception is TestException) { Console.WriteLine(exception.Message); } else { throw; } } } ``` 若是需要针对`AggregateException`中某个或是某种异常进行处理，可以使用`Handle()`方法 `Handel()`的参数是一个有返回值的委托：`Func predicate` 示例：（[完整Demo](https://github.com/shanzm/AsynchronousProgramming/blob/8c36d6a90954c5a14d93d29b7f68b4c6d47af6f5/009AggregateException%E4%B8%AD%E6%96%B9%E6%B3%95/Program.cs#L95)） ```cs catch (Exception) { t.Exception.Handle(e => { if (e is TestException)//如果是TestException类型的异常 { Console.WriteLine(e.Message); } return e is TestException; }); } ```

---

## 6.多线程和异步的区分 不要把**多线程**和**异步**两个概念混为一谈！**异步是最终目的,多线程只是我们实现异步的一种手段！** 首先，使用异步和多线程都可以避免线程的阻塞，但是原理是不一样的。 多线程：当前线程中创建一个新的线程，当前线程线程则不会被锁定了，但是锁定新的线程执行某个操作。换句话说就是换一条线程用来代替原本会被锁定的主线程！优点就是，线程中的处理程序的运行顺序还是从上往下的，方便理解，但是线程间的共享变量可能造成死锁的出现。 异步：异步概念是与同步的概念相对的，**简单的说就是：调用者发送一个调用请求后，调用者不需要等待被被调用者返回结果而可以继续做其他的事情**。实现异步一般是通过多线程，但是还可以通过多进程实现异步！ 多线程和异步可以解决不同的问题 但是首先我们要区分当前需要长时间操作的任务是:CPU密集型还是IO密集型，具体可参考[长时间的复杂任务又分为两种](https://www.cnblogs.com/shanzhiming/p/12292710.html#%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B) CPU Bound：使用多线程 IO Bound：使用异步

---

## 7. 在 .NET MVC中异步编程 现在的 ASP .NET MVC项目中，若使用的.net中的方法有异步版本的就尽量使用异步的方法。 在MVC项目中异步编程可以大大的提高网站服务器的吞吐量，即可以可以大大的提高网站的同时受理的请求数量 据传，MVC网站若是异步编程则可以提高网站的同时访问量的2.6倍。 注意是提高网站的同时访问量，而不是提高网站的访问速度！ 在MVC项目异步编程的的方式和在控制台中一样，使用async和await，基于任务的异步编程模式 简单的示例：同步和异步两种方式分别读取桌面1.txt文件 ```cs //同步操作 public ActionResult Index() { string msg = ""; using (StreamReader sr = new StreamReader(@"C:\Users\shanzm\Desktop\1.txt", Encoding.Default)) { while (!sr.EndOfStream) { msg = sr.ReadToEnd(); } } return Content(msg); } //异步操作 public async Task Index2() { string msg = ""; using (StreamReader sr = new StreamReader(@"C:\Users\shanzm\Desktop\1.txt", Encoding.Default)) { while (!sr.EndOfStream) { msg = await sr.ReadToEndAsync();//使用异步版本的方法 } } return Content(msg); } ```

---

## 8. 参考及示例源码 [源码：点击下载](https://github.com/shanzm/AsynchronousProgramming) [书籍：C#高级编程]() [书籍：精通C#]() [微软：基于任务的异步编程](https:/https://img.qb5200.com/download-x/docs.microsoft.com/zh-cnhttps://img.qb5200.com/download-x/dotnet/standard/parallel-programming/task-based-asynchronous-programming) [微软：异常处理（任务并行库）](https:/https://img.qb5200.com/download-x/docs.microsoft.com/zh-cnhttps://img.qb5200.com/download-x/dotnet/standard/parallel-programming/exception-handling-task-parallel-library#using-the-handle-method-to-filter-inner-exceptions)