进阶系列（12）—— C#异步编程
一、What's 异步？
启动程序时，系统会在内存中创建一个新的进程。进程是构成运行程序资源的集合。
在进程内部，有称为线程的内核对象，它代表的是真正的执行程序。系统会在 Main 方法的第一行语句就开始线程的执行。
线程：
①默认情况，一个进程只包含一个线程，从程序的开始到执行结束；
②线程可以派生自其它线程，所以一个进程可以包含不同状态的多个线程，来执行程序的不同部分；
③一个进程中的多个线程，将共享该进程的资源；
④系统为处理器执行所规划的单元是线程，而非进程。
一般来说我们写的控制台程序都只使用了一个线程，从第一条语句按顺序执行到最后一条。但在很多的情况下，这种简单的模型会在性能或用户体验上不好。
例如：服务器要同时处理来自多个客户端程序的请求，又要等待数据库和其它设备的响应，这将严重影响性能。程序不应该将时间浪费在响应上，而要在等待的同时执行其它任务！
现在我们开始进入异步编程。在异步程序中，代码不需要按照编写时的顺序执行。这时我们需要用到 C# 5.0 引入的 async/await 来构建异步方法。
我们先看一下不用异步的示例：
1 class Program
2 {
3 //创建计时器
4 private static readonly Stopwatch Watch = new Stopwatch();
5
6 private static void Main(string[] args)
7 {
8 //启动计时器
9 Watch.Start();
10
11 const string url1 = "http://www.cnblogs.com/";
12 const string url2 = "http://www.cnblogs.com/liqingwen/";
13
14 //两次调用 CountCharacters 方法（下载某网站内容，并统计字符的个数）
15 var result1 = CountCharacters(1, url1);
16 var result2 = CountCharacters(2, url2);
17
18 //三次调用 ExtraOperation 方法（主要是通过拼接字符串达到耗时操作）
19 for (var i = 0; i < 3; i++)
20 {
21 ExtraOperation(i + 1);
22 }
23
24 //控制台输出
25 Console.WriteLine($"{url1} 的字符个数：{result1}");
26 Console.WriteLine($"{url2} 的字符个数：{result2}");
27
28 Console.Read();
29 }
30
31 /// <summary>
32 /// 统计字符个数
33 /// </summary>
34 /// <param name="id"></param>
35 /// <param name="address"></param>
36 /// <returns></returns>
37 private static int CountCharacters(int id, string address)
38 {
39 var wc = new WebClient();
40 Console.WriteLine($"开始调用 id = {id}：{Watch.ElapsedMilliseconds} ms");
41
42 var result = wc.DownloadString(address);
43 Console.WriteLine($"调用完成 id = {id}：{Watch.ElapsedMilliseconds} ms");
44
45 return result.Length;
46 }
47
48 /// <summary>
49 /// 额外操作
50 /// </summary>
51 /// <param name="id"></param>
52 private static void ExtraOperation(int id)
53 {
54 //这里是通过拼接字符串进行一些相对耗时的操作
55 var s = "";
56
57 for (var i = 0; i < 6000; i++)
58 {
59 s += i;
60 }
61
62 Console.WriteLine($"id = {id} 的 ExtraOperation 方法完成：{Watch.ElapsedMilliseconds} ms");
63 }
64 }
图1-1 运行的效果图，以毫秒（ms）为单位
【备注】一般来说，直接拼接字符串是一种比较耗性能的手段，如果对字符串拼接有性能要求的话应该使用 StringBuilder。
【注意】每次运行的结果可能不同。不管哪次调试，绝大部分时间都浪费前两次调用（CountCharacters 方法），即在等待网站的响应上。
图1-2 根据执行结果所画的时间轴
有人曾幻想着这样提高性能的方法：在调用 A 方法时，不等它执行完，直接执行 B 方法，然后等 A 方法执行完成再处理。
C# 的 async/await 就可以允许我们这么弄。
1 class Program
2 {
3 //创建计时器
4 private static readonly Stopwatch Watch = new Stopwatch();
5
6 private static void Main(string[] args)
7 {
8 //启动计时器
9 Watch.Start();
10
11 const string url1 = "http://www.cnblogs.com/";
12 const string url2 = "http://www.cnblogs.com/liqingwen/";
13
14 //两次调用 CountCharactersAsync 方法（异步下载某网站内容，并统计字符的个数）
15 Task<int> t1 = CountCharactersAsync(1, url1);
16 Task<int> t2 = CountCharactersAsync(2, url2);
17
18 //三次调用 ExtraOperation 方法（主要是通过拼接字符串达到耗时操作）
19 for (var i = 0; i < 3; i++)
20 {
21 ExtraOperation(i + 1);
22 }
23
24 //控制台输出
25 Console.WriteLine($"{url1} 的字符个数：{t1.Result}");
26 Console.WriteLine($"{url2} 的字符个数：{t2.Result}");
27
28 Console.Read();
29 }
30
31 /// <summary>
32 /// 统计字符个数
33 /// </summary>
34 /// <param name="id"></param>
35 /// <param name="address"></param>
36 /// <returns></returns>
37 private static async Task<int> CountCharactersAsync(int id, string address)
38 {
39 var wc = new WebClient();
40 Console.WriteLine($"开始调用 id = {id}：{Watch.ElapsedMilliseconds} ms");
41
42 var result = await wc.DownloadStringTaskAsync(address);
43 Console.WriteLine($"调用完成 id = {id}：{Watch.ElapsedMilliseconds} ms");
44
45 return result.Length;
46 }
47
48 /// <summary>
49 /// 额外操作
50 /// </summary>
51 /// <param name="id"></param>
52 private static void ExtraOperation(int id)
53 {
54 //这里是通过拼接字符串进行一些相对耗时的操作
55 var s = "";
56
57 for (var i = 0; i < 6000; i++)
58 {
59 s += i;
60 }
61
62 Console.WriteLine($"id = {id} 的 ExtraOperation 方法完成：{Watch.ElapsedMilliseconds} ms");
63 }
64 }
图1-3 修改后的执行结果图
图1-4 根据加入异步后的执行结果画的时间轴。
我们观察时间轴发现，新版代码比旧版快了不少（由于网络波动的原因，很可能会出现耗时比之前长的情况）。这是由于 ExtraOperation 方法的数次调用是在 CountCharactersAsync 方法调用时等待响应的过程中进行的。所有的工作都是在主线程中完成的，没有创建新的线程。
【改动分析】只改了几个细节的地方，直接展开代码的话可能看不出来，改动如下：
图1-5
图1-6
①从 Main 方法执行到 CountCharactersAsync(1, url1) 方法时，该方法会立即返回，然后才会调用它内部的方法开始下载内容。该方法返回的是一个 Task<int> 类型的占位符对象，表示计划进行的工作。这个占位符最终会返回 int 类型的值。
②这样就可以不必等 CountCharactersAsync(1, url1) 方法执行完成就可以继续进行下一步操作。到执行 CountCharactersAsync(2, url2) 方法时，跟 ① 一样返回 Task<int> 对象。
③然后，Main 方法继续执行三次 ExtraOperation 方法，同时两次 CountCharactersAsync 方法依然在持续工作 。
④t1.Result 和 t2.Result 是指从 CountCharactersAsync 方法调用的 Task<int> 对象取结果，如果还没有结果的话，将阻塞，直有结果返回为止。
二、async/await 结构
先解析一下专业名词：
同步方法：一个程序调用某个方法，等到其执行完成之后才进行下一步操作。这也是默认的形式。
异步方法：一个程序调用某个方法，在处理完成之前就返回该方法。通过 async/await 我们就可以实现这种类型的方法。
async/await 结构可分成三部分：
（1）调用方法：该方法调用异步方法，然后在异步方法执行其任务的时候继续执行；
（2）异步方法：该方法异步执行工作，然后立刻返回到调用方法；
（3）await 表达式：用于异步方法内部，指出需要异步执行的任务。一个异步方法可以包含多个 await 表达式（不存在 await 表达式的话 IDE 会发出警告）。
现在我们来分析一下示例。
图2-1
三、What’s 异步方法
图3-1 异步方法的简单结构图
（一）介绍异步方法
关于 async 关键字：
①在返回类型之前包含 async 关键字
②它只是标识该方法包含一个或多个 await 表达式，即，它本身不创建异步操作。
③它是上下文关键字，即可作为变量名。
现在先来简单分析一下这三种返回值类型：void、Task 和 Task<T>
（1）Task<T>：调用方法要从调用中获取一个 T 类型的值，异步方法的返回类型就必须是Task<T>。调用方法从 Task 的 Result 属性获取的就是 T 类型的值。
1 private static void Main(string[] args)
2 {
3 Task<int> t = Calculator.AddAsync(1, 2);
4
5 //一直在干活
6
7 Console.WriteLine($"result: {t.Result}");
8
9 Console.Read();
10 }
1 internal class Calculator
2 {
3 private static int Add(int n, int m)
4 {
5 return n + m;
6 }
7
8 public static async Task<int> AddAsync(int n, int m)
9 {
10 int val = await Task.Run(() => Add(n, m));
11
12 return val;
13 }
14 }
图2
图3
（2）Task：调用方法不需要从异步方法中取返回值，但是希望检查异步方法的状态，那么可以选择可以返回 Task 类型的对象。不过，就算异步方法中包含 return 语句，也不会返回任何东西。
1 private static void Main(string[] args)
2 {
3 Task t = Calculator.AddAsync(1, 2);
4
5 //一直在干活
6
7 t.Wait();
8 Console.WriteLine("AddAsync 方法执行完成");
9
10 Console.Read();
11 }
1 internal class Calculator
2 {
3 private static int Add(int n, int m)
4 {
5 return n + m;
6 }
7
8 public static async Task AddAsync(int n, int m)
9 {
10 int val = await Task.Run(() => Add(n, m));
11 Console.WriteLine($"Result: {val}");
12 }
13 }
图4
图5
（3）void：调用方法执行异步方法，但又不需要做进一步的交互。
1 private static void Main(string[] args)
2 {
3 Calculator.AddAsync(1, 2);
4
5 //一直在干活
6
7 Thread.Sleep(1000); //挂起1秒钟
8 Console.WriteLine("AddAsync 方法执行完成");
9
10 Console.Read();
11 }
1 internal class Calculator
2 {
3 private static int Add(int n, int m)
4 {
5 return n + m;
6 }
7
8 public static async void AddAsync(int n, int m)
9 {
10 int val = await Task.Run(() => Add(n, m));
11 Console.WriteLine($"Result: {val}");
12 }
13 }
图6
图7
四、控制流
五、await 表达式
await 表达式指定了一个异步执行的任务。默认情况，该任务在当前线程异步执行。
每一个任务就是一个 awaitable 类的实例。awaitable 类型指包含 GetAwaiter() 方法的类型。
实际上，你并不需要构建自己的 awaitable，一般只需要使用 Task 类，它就是 awaitable。
最简单的方式是在方法中使用 Task.Run() 来创建一个 Task。【注意】它是在不同的线程上执行方法。
让我们一起来看看示例。
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 var t = Do.GetGuidAsync();
6 t.Wait();
7
8 Console.Read();
9 }
10
11
12 private class Do
13 {
14 /// <summary>
15 /// 获取 Guid
16 /// </summary>
17 /// <returns></returns>
18 private static Guid GetGuid() //与Func<Guid> 兼容
19 {
20 return Guid.NewGuid();
21 }
22
23 /// <summary>
24 /// 异步获取 Guid
25 /// </summary>
26 /// <returns></returns>
27 public static async Task GetGuidAsync()
28 {
29 var myFunc = new Func<Guid>(GetGuid);
30 var t1 = await Task.Run(myFunc);
31
32 var t2 = await Task.Run(new Func<Guid>(GetGuid));
33
34 var t3 = await Task.Run(() => GetGuid());
35
36 var t4 = await Task.Run(() => Guid.NewGuid());
37
38 Console.WriteLine($"t1: {t1}");
39 Console.WriteLine($"t2: {t2}");
40 Console.WriteLine($"t3: {t3}");
41 Console.WriteLine($"t4: {t4}");
42 }
43 }
44 }
图2-1
图2-2
上面 4 个 Task.Run() 都是采用了 Task Run(Func<TReturn> func) 形式来直接或间接调用 Guid.NewGuid()。
Task.Run() 支持 4 中不同的委托类型所表示的方法：Action、Func<TResult>、Func<Task> 和 Func<Task<TResult>>
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 var t = Do.GetGuidAsync();
6 t.Wait();
7
8 Console.Read();
9 }
10
11 private class Do
12 {
13 public static async Task GetGuidAsync()
14 {
15 await Task.Run(() => { Console.WriteLine(Guid.NewGuid()); }); //Action
16
17 Console.WriteLine(await Task.Run(() => Guid.NewGuid())); //Func<TResult>
18
19 await Task.Run(() => Task.Run(() => { Console.WriteLine(Guid.NewGuid()); })); //Func<Task>
20
21 Console.WriteLine(await Task.Run(() => Task.Run(() => Guid.NewGuid()))); //Func<Task<TResult>>
22 }
23 }
24 }
图2-3 Task.Run() 方法的重载
六、How 取消异步操作
CancellationToken 和 CancellationTokenSource 这两个类允许你终止执行异步方法。
（1）CancellationToken 对象包含任务是否被取消的信息；如果该对象的属性 IsCancellationRequested 为 true，任务需停止操作并返回；该对象操作是不可逆的，且只能使用（修改）一次，即该对象内的 IsCancellationRequested 属性被设置后，就不能改动。
（2）CancellationTokenSource 可创建 CancellationToken 对象，调用 CancellationTokenSource 对象的 Cancel 方法，会使该对象的 CancellationToken 属性 IsCancellationRequested 设置为 true。
【注意】调用 CancellationTokenSource 对象的 Cancel 方法，并不会执行取消操作，而是会将该对象的 CancellationToken 属性 IsCancellationRequested 设置为 true。
示例
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 CancellationTokenSource source = new CancellationTokenSource();
6 CancellationToken token = source.Token;
7
8 var t = Do.ExecuteAsync(token);
9
10 //Thread.Sleep(3000); //挂起 3 秒
11 //source.Cancel(); //传达取消请求
12
13 t.Wait(token); //等待任务执行完成
14 Console.WriteLine($"{nameof(token.IsCancellationRequested)}: {token.IsCancellationRequested}");
15
16 Console.Read();
17 }
18
19
20 }
21
22 internal class Do
23 {
24 /// <summary>
25 /// 异步执行
26 /// </summary>
27 /// <param name="token"></param>
28 /// <returns></returns>
29 public static async Task ExecuteAsync(CancellationToken token)
30 {
31 if (token.IsCancellationRequested)
32 {
33 return;
34 }
35
36 await Task.Run(() => CircleOutput(token), token);
37 }
38
39 /// <summary>
40 /// 循环输出
41 /// </summary>
42 /// <param name="token"></param>
43 private static void CircleOutput(CancellationToken token)
44 {
45 Console.WriteLine($"{nameof(CircleOutput)} 方法开始调用：");
46
47 const int num = 5;
48 for (var i = 0; i < num; i++)
49 {
50 if (token.IsCancellationRequested) //监控 CancellationToken
51 {
52 return;
53 }
54
55 Console.WriteLine($"{i + 1}/{num} 完成");
56 Thread.Sleep(1000);
57 }
58 }
59 }
图3-1
图3-2 注释两行代码
图3-3：图3-1和图3-2的执行结果（注释两行代码）
上图是不调用 Cancel() 方法的结果图，不会取消任务的执行。
下图在 3 秒后调用 Cancel() 方法取消任务的执行：
图3-4：去掉注释
图3-5：图3-1和图3-4的执行结果（去掉注释）
七、异常处理
await 表达式也可以使用 try...catch...finally 结构。
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 var t = DoExceptionAsync();
6 t.Wait();
7
8 Console.WriteLine($"{nameof(t.Status)}: {t.Status}"); //任务状态
9 Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}"); //任务完成状态标识
10 Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}"); //任务是否有未处理的异常标识
11
12 Console.Read();
13 }
14
15 /// <summary>
16 /// 异常操作
17 /// </summary>
18 /// <returns></returns>
19 private static async Task DoExceptionAsync()
20 {
21 try
22 {
23 await Task.Run(() => { throw new Exception(); });
24 }
25 catch (Exception)
26 {
27 Console.WriteLine($"{nameof(DoExceptionAsync)} 出现异常！");
28 }
29 }
30 }
图1-1
【分析】await 表达式位于 try 块中，按普通的方式处理异常。但是，为什么图中的状态（Status）、是否完成标识（IsCompleted）和是否失败标识（IsFaulted）分别显示：运行完成（RanToCompletion） 、已完成（True） 和 未失败（False） 呢？因为：任务没有被取消，并且异常都已经处理完成！
八、在调用方法中同步等待任务
调用方法可能在某个时间点上需要等待某个特殊的 Task 对象完成，才执行后面的代码。此时，可以采用实例方法 Wait 。
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 var t = CountCharactersAsync("http://www.cnblogs.com/liqingwen/");
6
7 t.Wait(); //等待任务结束
8 Console.WriteLine($"Result is {t.Result}");
9
10 Console.Read();
11 }
12
13 /// <summary>
14 /// 统计字符数量
15 /// </summary>
16 /// <param name="address"></param>
17 /// <returns></returns>
18 private static async Task<int> CountCharactersAsync(string address)
19 {
20 var result = await Task.Run(() => new WebClient().DownloadStringTaskAsync(address));
21 return result.Length;
22 }
23 }
图2-1
Wait() 适合用于单一 Task 对象，如果想操作一组对象，可采用 Task 的两个静态方法 WaitAll() 和 WaitAny() 。
1 internal class Program
2 {
3 private static int time = 0;
4 private static void Main(string[] args)
5 {
6 var t1 = GetRandomAsync(1);
7 var t2 = GetRandomAsync(2);
8
9 //IsCompleted 任务完成标识
10 Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
11 Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
12
13 Console.Read();
14 }
15
16 /// <summary>
17 /// 获取一个随机数
18 /// </summary>
19 /// <param name="id"></param>
20 /// <returns></returns>
21 private static async Task<int> GetRandomAsync(int id)
22 {
23 var num = await Task.Run(() =>
24 {
25 time++;
26 Thread.Sleep(time * 100);
27 return new Random().Next();
28 });
29
30 Console.WriteLine($"{id} 已经调用完成");
31 return num;
32 }
33 }
图2-2 两个任务的 IsCompleted 属性都显示未完成
现在，在 Main() 方法中新增两行代码（6 和 7 两行），尝试调用 WaitAll() 方法。
1 private static void Main(string[] args)
2 {
3 var t1 = GetRandomAsync(1);
4 var t2 = GetRandomAsync(2);
5
6 Task<int>[] tasks = new Task<int>[] { t1, t2 };
7 Task.WaitAll(tasks); //等待任务全部完成，才继续执行
8
9 //IsCompleted 任务完成标识
10 Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
11 Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
12
13 Console.Read();
14 }
图2-3 两个任务的 IsCompleted 属性都显示 True
现在，再次将第 7 行改动一下，调用 WaitAny() 方法试试。
1 private static void Main(string[] args)
2 {
3 var t1 = GetRandomAsync(1);
4 var t2 = GetRandomAsync(2);
5
6 Task<int>[] tasks = new Task<int>[] { t1, t2 };
7 Task.WaitAny(tasks); //等待任一 Task 完成，才继续执行
8
9 //IsCompleted 任务完成标识
10 Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
11 Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
12
13 Console.Read();
14 }
图2-4 有一个任务的 IsCompleted 属性显示 True （完成） 就继续执行
九、在异步方法中异步等待任务
上节说的是如何使用 WaitAll() 和 WaitAny() 同步地等待 Task 完成。这次我们使用 Task.WhenAll() 和 Task.WhenAny() 在异步方法中异步等待任务。
1 internal class Program
2 {
3 private static int time = 0;
4
5 private static void Main(string[] args)
6 {
7 var t = GetRandomAsync();
8
9 Console.WriteLine($"t.{nameof(t.IsCompleted)}: {t.IsCompleted}");
10 Console.WriteLine($"Result: {t.Result}");
11
12 Console.Read();
13 }
14
15 /// <summary>
16 /// 获取一个随机数
17 /// </summary>
18 /// <param name="id"></param>
19 /// <returns></returns>
20 private static async Task<int> GetRandomAsync()
21 {
22 time++;
23 var t1 = Task.Run(() =>
24 {
25 Thread.Sleep(time * 100);
26 return new Random().Next();
27 });
28
29 time++;
30 var t2 = Task.Run(() =>
31 {
32 Thread.Sleep(time * 100);
33 return new Random().Next();
34 });
35
36 //异步等待集合内的 Task 都完成，才进行下一步操作
37 await Task.WhenAll(new List<Task<int>>() { t1, t2 });
38
39 Console.WriteLine($" t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
40 Console.WriteLine($" t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
41
42 return t1.Result + t2.Result;
43 }
44 }
图3-1 调用 WhenAll() 方法
【注意】WhenAll() 异步等待集合内的 Task 都完成，不会占用主线程的时间。
现在，我们把 GetRandomAsync() 方法内的 WhenAll() 方法替换成 WhenAny()，并且增大一下线程挂起时间，最终改动如下：
1 private static async Task<int> GetRandomAsync()
2 {
3 time++;
4 var t1 = Task.Run(() =>
5 {
6 Thread.Sleep(time * 100);
7 return new Random().Next();
8 });
9
10 time++;
11 var t2 = Task.Run(() =>
12 {
13 Thread.Sleep(time * 500); //这里由 100 改为 500，不然看不到效果
14 return new Random().Next();
15 });
16
17 //异步等待集合内的 Task 都完成，才进行下一步操作
18 //await Task.WhenAll(new List<Task<int>>() { t1, t2 });
19 await Task.WhenAny(new List<Task<int>>() { t1, t2 });
20
21 Console.WriteLine($" t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
22 Console.WriteLine($" t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
23
24 return t1.Result + t2.Result;
25 }
图3-2 调用 WhenAny() 方法
十、Task.Delay() 暂停执行
Task.Delay() 方法会创建一个 Task 对象，该对象将暂停其在线程中的处理，并在一定时间之后完成。和 Thread.Sleep 不同的是，它不会阻塞线程，意味着线程可以继续处理其它工作。
1 internal class Program
2 {
3 private static void Main(string[] args)
4 {
5 Console.WriteLine($"{nameof(Main)} - start.");
6 DoAsync();
7 Console.WriteLine($"{nameof(Main)} - end.");
8
9 Console.Read();
10 }
11
12 private static async void DoAsync()
13 {
14 Console.WriteLine($" {nameof(DoAsync)} - start.");
15
16 await Task.Delay(500);
17
18 Console.WriteLine($" {nameof(DoAsync)} - end.");
19 }
20 }
