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

zoukankan html css js c++ java

.NET异步程序设计——async&await
目录
0.背景引入
1.async和await基本语法
1.1 简介
1.2 具体使用方法
1.3 返回值类型
1.4 其他细节
1.5 async传染性
1.6 简单示例
2.异步方法的执行顺序
3.取消一个异步操作
4.同步和异步等待任务
4.1 在调用方法中同步等待任务
4.2 在调用方法中异步等待任务
4.2.1使用await等待异步任务
4.2.2使用WhenAll()和WhenAny()
5.异步操作中的异常处理
5.1 异常处理
5.2 多个异步方法的异常处理
5.3 AggregateException中的方法
6.多线程和异步的区分
7. 在 .NET MVC中异步编程
8. 参考及示例源码
shanzm-2020年3月7日 23:12:53

0.背景引入

现在的.net异步编程中，一般都是使用 基于任务异步模式(Task-based Asynchronous Pattern，TAP)实现异步编程

可参考微软文档：使用基于任务的异步模式

基于任务的异步模式，是使用 System.Threading.Tasks 命名空间中的 System.Threading.Tasks.Task<TResult> 和 System.Threading.Tasks .Task类型实现异步编程，

配合着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异步程序设计之任务并行库)

1.2 具体使用方法
1. async:用于异步方法的函数名前做修饰符，处于返回类型左侧。async只是一个标识符，只是说明该方法中有一个或多个await表达式，async本身并不创建异步操作。
2. await:用于异步方法内部，用于指明需要异步执行的操作（称之为await表达式），注意一个异步方法中可以有多个await表达式，而且应该至少有一个（若是没有的话编译的时候会警告，但还是可以构建和执行，只不过就相当于同步方法而已）。
  
  其实这里你有没有想起Task类中为了实现延续任务而使用的等待者，比如:使用task.GetAwaiter()方法为task类创建一个等待者（可以参考；3.3.2使用Awaiter）。await关键字就是基于 .net 4.5中的awaiter对象实现的。
3. 总而言之，若是有await表达式则函数一定要用async修饰，若是使用了async修饰的方法中没有await表达式，编译的时候会警告！
1.3 返回值类型
1. 使用async和await定义的异步方法的返回值只有三种：Task<T>、Task、void
2. 异步方法中有return语句，则返回值类型为Task<T>,其中T是return语句返回对象的类型。（编译器帮我们把T类型数据转换为Task<T>类型）。所以不要使用return返回一个Task<T>类型的对象，而是只需要返回一个T类型数据即可
3. 异步方法中没有return语句，但是你需要查看异步方法的状态或是要对Task对象操作（比如task.Wait()），则可定义返回值类型为Task。
4. 异步方法中没有return语句且不需要查看异步方法的状态，则可认为是返回值是void类型。此时称之为“调用并忘记”（fire and forget），其实这并不是一个很好的用法（具体的分析可以看：异步方法的异常处理）！
5. 若是真的需要返回一个Task<T>类型的数据 (比如在非async修饰的方法中，定义返回值类型就是一个Task<T>类型)，则：
  
  return Task.Run(()=>{……})
  
  将T类型转换为Task<T>类型:return Task.FromResult(T data)
  
  将IAsyncResult类型对象转换为Task类型：return Task.Factory.FromTask(IAsyncResult data)
1.4 其他细节
1. async修饰符只能用于返回Task、Task<T>和viod的方法,或者Lambda表达式中。
2. ~~async不能用于程序的入口点，即Main()不能使用async修饰符。~~ 谢谢@coredx提醒:C#7.1中应用程序的入口点可以具有async修饰符,参考：What's new in C# 7.1
1.5 async传染性
1. 简单的说：函数体中含有await表达式的函数，必须使用async 修饰！
  
  而一个使用了async修饰的方法，在调用它的时候如有必要则必须使用await等待！
  
  使用了await等待的方法，则其调用方法又必须使用async修饰，这从而形成了一个循环，这就是async传染
  
  换句话说就是哪里调用了async修饰的方法则async就会传染到哪！
  
  可以有的时候我们并不想要我们的方法变为async修饰的方法，所以需要避免async传染
  
  避免的主要方法就是使用延续任务来避免，你想一想之前在Task类中，使用延续任务时，主要就是避免使用await等待！
  
  参考：C# 5.0中同步执行异步方法
2. 之前我们说了：~~主函数Main()不能使用async修饰符，因为Main函数不能够是异步方法，这也就意味着一切的异步方法最终的调用方法一定是同步方法~~（C#7.1Main可以是异步的），而调用异步方法的那个同步方法，称之为病源隔断方法，因为在这里开始，不再会发生async传染。
1.6 简单示例

示例1：定义一个异步方法,并调用它
```
static void Main(string[] args)
{   
    Task<int> 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<int> SumAsync(int num1, int num2)
{
    int sum = await Task.Run(() => { Thread.Sleep(3000); return num1 + num2; });
    return sum;
}
```
示例说明 ：
1. 异步方法SumAsync()函数体中返回的是整型sum，即返回的是一个整型,但是在声明函数时，返回值需写为：Task<int>
  
  反过来说：若是异步方法的返回值类型为Task<T>,则在方法中只需要返回T类型的数据。
  
  这一点就是和Task.Run()的返回值的书写方式一样，即若Task.Run()参数是有返回值的委托Func<TResult>,则Task.Run()返回值是Task<TResult>泛型
2. 异步方法的命名默认是在最后加"Async",即"XXXAsync"。
3. 调用异步方法的方法称之为调用方法（在这里就是主函数Main()）,调用方法和被调用的异步方法，不一定在不同的线程中。
4. 其实你看上面示例的代码也会发现，单独把异步操作封装为一个异步方法，这样可以为异步操作传参！
  你可以还记得的在.net异步程序设计之任务并行库中，多次说明Task.Run()的参数只能是无参委托。
5. 有一点在这里说明一下：关于异步匿名方法，或是异步Lambda表达式。
  在为一个事件绑定事件处理程序的时候，对于一些简单的事件处理程序，我们可以使用Lambda表达式
  但是我们想要异步操作Lambda表达式，则可以直接写为：
```
    Butten.Click+=async(sender,e)=>{...await...}
```
详细可以参照《C#图解教程:20.5使用异步Lambda表达式》

2.异步方法的执行顺序

依旧是上面的示例，我们在每个操作中、操作前、操作后都打印其当前所处的线程，仔细的观察，异步方法的执行顺序。

再次强调，这里用async修饰的方法，称之为异步方法，这里调用该异步方法的方法，称之为调用方法

代码：
```
//调用方法
static void Main(string[] args)
{
    Console.WriteLine($"-1-.正在执行的线程，线程ID：{Thread.CurrentThread.ManagedThreadId,2}------------------调用方法中调用异步方法之前的代码");
    Task<int> 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<int> 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取消异步操作

原理是一样的，都是使用CancellationToken和CancellationTokenSource两个类实现取消异步操作

看一个简单的示例：
```
        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完成:

Wait方法用于单一Task的对象。若是想要等待多个Task，可以使用Task类中的两个静态方法,其中WaitAll等待所有任务都结束，WaitAny等待任一任务结束。

示例：使用Task.WaitAll()和Task.WaitAny()
```
static void Main(string[] args)
{
    Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:Task之前...");
    Task<int> t1 = DoAsync(2000);
    Task<int> 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<int> 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<T>类型的变量，可以使程序运行的更快！

其实你也注意到了：不使用await等待异步操作，则异步操作的返回值就是定义的返回值Task<T>，但是使用await等待则异步操作的返回值就是具体的简单类型，比如int类型等。
换言之：异步方法的返回值是Task<T>,则使用await等待可以直接获取异步方法的T类型的返回值

示例：
```
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<int> 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()
```
static void Main(string[] args)
{
    Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:Task之前...");
    Task<int> t1 = DoAsync(2000);
    Task<int> 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<int> 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(),来等待异步方法，同时也可以给所有的异步方法结束后添加一个延续任务！

示例：为异步等待后添加延续工作
```
static void Main(string[] args)
{
    Console.WriteLine($"当前线程ID：{Thread.CurrentThread.ManagedThreadId,2 }:Task之前...");
    Task<int> t1 = DoAsync(2000);
    Task<int> 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<int> 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<TResult>的Result是TResult[]类型
即多个Task的返回值，存放在一个数组中

运行结果：

说明2:

若是Task.WhenAny()后的延续工作，则注意Task.WhenAny()的返回的是Task<Task>类型，即其Result是Task<TResutl>类型，所以为了获取第一结束的Task的返回值，需要：t.Result.Result。

运行结果：

说明3：

Task.WhenAll(Task[] tasks).ContinueWith(Action<Task>)
等价于Task.Factory.ContinueWhenAll(Task[] tasks, Action<Tast>)

Task.WhenAny(Task[] tasks).ContinueWith(Action<Task>)
等价于Task.Factory.ContinueWhenAny(Task[] tasks, Action<Tast>)

5.异步操作中的异常处理

5.1 异常处理

一般程序中对异常的处理使用try{……} catch{……}

首先看一个捕获异常失败的示例：

在Main()中调用ThrowEx(2000,"这是异常信息"),第一个参数是ThrowEx中的Tast延迟的时间，第二个参数是ThrowEx中的抛出异常的信息。
```
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。
```
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
```
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）
```
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<Exception,bool> predicate

示例：（完整Demo）
```
catch (Exception)
{
    t.Exception.Handle(e =>
    {
        if (e is TestException)//如果是TestException类型的异常
        {
            Console.WriteLine(e.Message);
        }
        return e is TestException;
    });
}
```
6.多线程和异步的区分

不要把多线程和异步两个概念混为一谈！异步是最终目的,多线程只是我们实现异步的一种手段！

首先，使用异步和多线程都可以避免线程的阻塞，但是原理是不一样的。

多线程：当前线程中创建一个新的线程，当前线程线程则不会被锁定了，但是锁定新的线程执行某个操作。换句话说就是换一条线程用来代替原本会被锁定的主线程！优点就是，线程中的处理程序的运行顺序还是从上往下的，方便理解，但是线程间的共享变量可能造成死锁的出现。

异步：异步概念是与同步的概念相对的，简单的说就是：调用者发送一个调用请求后，调用者不需要等待被被调用者返回结果而可以继续做其他的事情。实现异步一般是通过多线程，但是还可以通过多进程实现异步！

多线程和异步可以解决不同的问题

但是首先我们要区分当前需要长时间操作的任务是:CPU密集型还是IO密集型，具体可参考长时间的复杂任务又分为两种

CPU Bound：使用多线程

IO Bound：使用异步

7. 在 .NET MVC中异步编程

现在的 ASP .NET MVC项目中，若使用的.net中的方法有异步版本的就尽量使用异步的方法。

在MVC项目中异步编程可以大大的提高网站服务器的吞吐量，即可以可以大大的提高网站的同时受理的请求数量

据传，MVC网站若是异步编程则可以提高网站的同时访问量的2.6倍。

注意是提高网站的同时访问量，而不是提高网站的访问速度！

在MVC项目异步编程的的方式和在控制台中一样，使用async和await，基于任务的异步编程模式

简单的示例：同步和异步两种方式分别读取桌面1.txt文件
```
//同步操作
public ActionResult Index()
{
    string msg = "";
    using (StreamReader sr = new StreamReader(@"C:UsersshanzmDesktop1.txt", Encoding.Default))
    {
        while (!sr.EndOfStream)
        {
            msg = sr.ReadToEnd();
        }
    }
    return Content(msg);
}


//异步操作
public async Task<ActionResult> Index2()
{
    string msg = "";
    using (StreamReader sr = new StreamReader(@"C:UsersshanzmDesktop1.txt", Encoding.Default))
    {
        while (!sr.EndOfStream)
        {
            msg = await sr.ReadToEndAsync();//使用异步版本的方法
        }
    }
    return Content(msg);
}
```
8. 参考及示例源码

源码：点击下载

书籍：C#高级编程

书籍：精通C#

微软：基于任务的异步编程

微软：异常处理（任务并行库）
查看全文

相关阅读:
mac下配置adb环境变量
 Flutter——多行文字展开收起
 sourceTree报错：Updates were rejected because the tag already exists in the remote.
股市赚钱就是这么简单
 鸿蒙手机版JNI实战（JNI开发、SO库生成、SO库使用）
Mybatis、Mybatis Generator、Mybatis-Plus、Mybatis Plus Generator
鸿蒙运行报错：Failure[INSTALL_PARSE_FAILED_USESDK_ERROR] Error while Deploying HAP
MAC 下Android ROM 提取文件
 IDAPython 插件开发
 Android ollvm 集成

原文地址：https://www.cnblogs.com/shanzhiming/p/12439214.html

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

0.背景引入

1.async和await基本语法

1.1 简介

1.2 具体使用方法

1.3 返回值类型

1.4 其他细节

1.5 async传染性

1.6 简单示例

2.异步方法的执行顺序

3.取消一个异步操作

4.同步和异步等待任务

4.1 在调用方法中同步等待任务

4.2 在调用方法中异步等待任务

4.2.1使用await等待异步任务

4.2.2使用WhenAll()和WhenAny()

5.异步操作中的异常处理

5.1 异常处理

5.2 多个异步方法的异常处理

5.3 AggregateException中的方法

6.多线程和异步的区分

7. 在 .NET MVC中异步编程

8. 参考及示例源码