C# 异步编程基础 async/await
序
这是学习异步编程的入门篇。html
涉及 C# 5.0 引入的 async/await，但在控制台输出示例时常常会采用 C# 6.0 的 $"" 来拼接字符串，至关于string.Format() 方法。数据库
目录
1、What's 异步？
启动程序时，系统会在内存中建立一个新的进程。进程是构成运行程序资源的集合。编程
在进程内部，有称为线程的内核对象，它表明的是真正的执行程序。系统会在 Main 方法的第一行语句就开始线程的执行。服务器
线程：网络
①默认状况，一个进程只包含一个线程，从程序的开始到执行结束；dom
②线程能够派生自其它线程，因此一个进程能够包含不一样状态的多个线程，来执行程序的不一样部分；异步
③一个进程中的多个线程，将共享该进程的资源；async
④系统为处理器执行所规划的单元是线程，而非进程。异步编程
通常来讲咱们写的控制台程序都只使用了一个线程，从第一条语句按顺序执行到最后一条。但在不少的状况下，这种简单的模型会在性能或用户体验上很差。性能
例如：服务器要同时处理来自多个客户端程序的请求，又要等待数据库和其它设备的响应，这将严重影响性能。程序不该该将时间浪费在响应上，而要在等待的同时执行其它任务！
如今咱们开始进入异步编程。在异步程序中，代码不须要按照编写时的顺序执行。这时咱们须要用到 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> 对象取结果，若是尚未结果的话，将阻塞，直有结果返回为止。
2、async/await 结构
先解析一下专业名词：
同步方法：一个程序调用某个方法，等到其执行完成以后才进行下一步操做。这也是默认的形式。
异步方法：一个程序调用某个方法，在处理完成以前就返回该方法。经过 async/await 咱们就能够实现这种类型的方法。
async/await 结构可分红三部分：
（1）调用方法：该方法调用异步方法，而后在异步方法执行其任务的时候继续执行；
（2）异步方法：该方法异步执行工做，而后马上返回到调用方法；
（3）await 表达式：用于异步方法内部，指出须要异步执行的任务。一个异步方法能够包含多个 await 表达式（不存在 await 表达式的话 IDE 会发出警告）。
如今咱们来分析一下示例。
图2-1
3、What’s 异步方法
异步方法：在执行完成前当即返回调用方法，在调用方法继续执行的过程当中完成任务。
语法分析：
（1）关键字：方法头使用 async 修饰。
（2）要求：包含 N（N>0） 个 await 表达式（不存在 await 表达式的话 IDE 会发出警告），表示须要异步执行的任务。
（3）返回类型：只能返回 3 种类型（void、Task 和 Task<T>）。Task 和 Task<T> 标识返回的对象会在未来完成工做，表示调用方法和异步方法能够继续执行。
（4）参数：数量不限，但不能使用 out 和 ref 关键字。
（5）命名约定：方法后缀名应以 Async 结尾。
（6）其它：匿名方法和 Lambda 表达式也能够做为异步对象；async 是一个上下文关键字；关键字 async 必须在返回类型前。
图3-1 异步方法的简单结构图
小结
1.解析了进程和线程的概念
2.异步的简单用法
3.async/await 结构体
4.异步方法语法结构
走进异步编程的世界 - 剖析异步方法（上）
序
这是上篇《走进异步编程的世界 - 开始接触 async/await 异步编程》（入门）的第二章内容，主要是与你们共同深刻探讨下异步方法。
本文要求了解委托的使用。
目录
介绍异步方法
异步方法：在执行完成前当即返回调用方法，在调用方法继续执行的过程当中完成任务。
语法分析：
（1）关键字：方法头使用 async 修饰。
（2）要求：包含 N（N>0） 个 await 表达式（不存在 await 表达式的话 IDE 会发出警告），表示须要异步执行的任务。【备注】感谢 czcz1024 的修正与补充：没有的话，就和普通方法同样执行了。
（3）返回类型：只能返回 3 种类型（void、Task 和 Task<T>）。Task 和 Task<T> 标识返回的对象会在未来完成工做，表示调用方法和异步方法能够继续执行。
（4）参数：数量不限。但不能使用 out 和 ref 关键字。
（5）命名约定：方法后缀名应以 Async 结尾。
（6）其它：匿名方法和 Lambda 表达式也能够做为异步对象；async 是一个上下文关键字；关键字 async 必须在返回类型前。
图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 }
Program.cs
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 }
View Code
图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 }
Program.cs
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 }
View Code
图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 }
Program.cs
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 }
Calculator.cs
图6
图7
1、控制流
异步方法的结构可拆分红三个不一样的区域：
（1）表达式以前的部分：从方法头到第一个 await 表达式之间的全部代码。
（2）await 表达式：将被异步执行的代码。
（3）表达式以后的部分：await 表达式的后续部分。
图1-1
该异步方法执行流程：从await表达式以前的地方开始，同步执行到第一个 await，标识着第一部分执行结束，通常来讲此时 await 工做还没完成。当await 任务完成后，该方法将继续同步执行后续部分。在执行的后续部分中，若是依然存在 await，就重复上述过程。
当到达 await 表达式时，线程将从异步方法返回到调用方法。若是异步方法的返回类型为 Task 或 Task<T>，会建立一个 Task 对象，标识须要异步完成的任务，而后将 Task 返回来调用方法。
图1-2
异步方法的控制流：
①异步执行 await 表达式的空闲任务。
②await 表达式执行完成，继续执行后续部分。如再遇到 await 表达式，按相同状况进行处理。
③到达末尾或遇到 return 语句时，根据返回类型能够分三种状况：
a.void：退出控制流。
b.Task：设置 Task 的属性并退出。
c.Task<T>：设置 Task 的属性和返回值（Result 属性）并退出。
④同时，调用方法将继续执行，从异步方法获取 Task 对象。须要值的时候，会暂停等到 Task 对象的 Result 属性被赋值才会继续执行。
【难点】
①第一次遇到 await 所返回对象的类型。这个返回类型就是同步方法头的返回类型，跟 await 表达式的返回值没有关系。
②到达异步方法的末尾或遇到 return 语句，它并无真正的返回一个值，而是退出了该方法。
2、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 }
View Code
图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 }
View Code
图2-3 Task.Run() 方法的重载
3、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 }
View Code
图3-1
图3-2 注释两行代码
图3-3：图3-1和图3-2的执行结果（注释两行代码）
上图是不调用 Cancel() 方法的结果图，不会取消任务的执行。
下图在 3 秒后调用 Cancel() 方法取消任务的执行：
图3-4：去掉注释
图3-5：图3-1和图3-4的执行结果（去掉注释）
小结
- 介绍异步方法的语法、三种不一样的返回值类型（void、Task 和 Task<T>）和控制流程等。
- 简单经常使用的异步执行方式：Task.Run()。【注意】它是在不一样的线程上执行方法。
- 如何取消异步操做。
走进异步编程的世界 - 剖析异步方法（下）
序
感谢你们的支持，这是昨天发布《走进异步编程的世界 - 剖析异步方法（上）》的补充篇。
目录
1、异常处理
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） 呢？由于：任务没有被取消，而且异常都已经处理完成！
2、在调用方法中同步等待任务
调用方法可能在某个时间点上须要等待某个特殊的 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 （完成） 就继续执行
3、在异步方法中异步等待任务
上节说的是如何使用 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() 方法
4、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 }
图4-1
- 1. C#异步编程总结
- 2. C#异步编程 C#异步编程
- 3. 异步编程基础
- 4. 异步编程-基础篇
- 5. c#异步编程一
- 6. c#-异步编程-异步编程基(15.3)
- 7. C#并发编程-异步编程基础-报告进度
- 8. C#异步编程
- 9. C# 异步编程
- 10. c# 异步编程
- 更多相关文章...
- • R 语言基础 - R 语言教程
- • Kotlin 基础语法 - Kotlin 教程
- • C# 中 foreach 遍历的用法
- • Kotlin学习（二）基本类型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. C#异步编程总结
- 2. C#异步编程 C#异步编程
- 3. 异步编程基础
- 4. 异步编程-基础篇
- 5. c#异步编程一
- 6. c#-异步编程-异步编程基(15.3)
- 7. C#并发编程-异步编程基础-报告进度
- 8. C#异步编程
- 9. C# 异步编程
- 10. c# 异步编程