非同步程式設計（async&await）
前言
本來這篇文章上個月就該釋出了，但是因為忙 一直沒有時間整理，所以耽擱到今天，現在迴歸正軌。
C# 5.0 雖然只引入了2個新關鍵詞：async和await。然而它大大簡化了非同步方法的程式設計。
在 執行緒池（threadPool）大致介紹了微軟在不同時期使用的不同的非同步模式，有3種：
1.非同步模式
2.基於事件的非同步模式
3.基於任務的非同步模式（TAP）
而最後一種就是利用async和await關鍵字來實現的（TAP是現在微軟極力推崇的一種非同步程式設計方式）。
但請謹記，async和await關鍵字只是編譯器功能。編譯器會用Task類建立程式碼。如果不使用這兩個關鍵詞，用C#4.0的Task類同樣可以實現相同的功能，只是沒有那麼方便而已。
認識async和await
使用async和await關鍵詞編寫非同步程式碼，具有與同步程式碼相當的結構和簡單性，並且摒棄了非同步程式設計的複雜結構。
但是在理解上剛開始會很不習慣，而且會把一些情況想當然了，而真實情況會相去甚遠（我犯過這樣的錯誤）。所以根據幾個示例一步步理解更加的靠譜些。
1.一個簡單的同步方法
這是一個簡單的同步方法呼叫示例：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine($"頭部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 6 string result = SayHi("jack"); 7 Console.WriteLine(result); 8 Console.WriteLine($"尾部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 9 Console.ReadKey(); 10 } 11 staticstring SayHi(string name) 12 { 13 Task.Delay(2000).Wait();//非同步等待2s 14 Console.WriteLine($"SayHi執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 15 return $"Hello,{name}"; 16 } 17 }
執行結果如下，方法在主執行緒中執行，主執行緒被阻塞。
2.同步方法非同步化
示例將方法放到任務內執行：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine($"頭部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 6 string result = SayHiAsync("jack").Result; 7 Console.WriteLine(result); 8 Console.WriteLine($"尾部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 9 Console.ReadKey(); 10 } 11 static Task<string> SayHiAsync(string name) 12 { 13 return Task.Run<string>(() => { return SayHi(name); }); 14 } 15 static string SayHi(string name) 16 { 17 Task.Delay(2000).Wait();//非同步等待2s 18 Console.WriteLine($"SayHi執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 19 return $"Hello,{name}"; 20 } 21 }
執行結果如下，方法在另外一個執行緒中執行，因為主執行緒呼叫了Result，Result在任務沒有完成時內部會使用Wait，所以主執行緒還是會被阻塞。
3.延續任務
示例為了避免阻塞主執行緒使用任務延續的方式：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine($"頭部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 6 Task<string> task = SayHiAsync("jack"); 7 task.ContinueWith(t =>//延續任務，指定任務執行完成後延續的操作 8 { 9 Console.WriteLine($"延續執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 10 string result = t.Result; 11 Console.WriteLine(result); 12 }); 13 Console.WriteLine($"尾部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 14 Console.ReadKey(); 15 } 16 static Task<string> SayHiAsync(string name) 17 { 18 return Task.Run<string>(() => { return SayHi(name); }); 19 } 20 static string SayHi(string name) 21 { 22 Task.Delay(2000).Wait();//非同步等待2s 23 Console.WriteLine($"SayHi執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 24 return $"Hello,{name}"; 25 } 26 }
執行結果如下，方法在另外一個執行緒中執行，因為任務附加了延續，延續會在任務完成後處理返回值，而主執行緒不會被阻塞。這應該就是想要的效果了。
4.使用async和await構建非同步方法呼叫
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine($"頭部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 6 CallerWithAsync("jack"); 7 Console.WriteLine($"尾部已執行，當前主執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 8 Console.ReadKey(); 9 } 10 async static void CallerWithAsync(string name) 11 { 12 Console.WriteLine($"非同步呼叫頭部執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 13 string result = await SayHiAsync(name); 14 Console.WriteLine($"非同步呼叫尾部執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 15 Console.WriteLine(result); 16 } 17 static Task<string> SayHiAsync(string name) 18 { 19 return Task.Run<string>(() => { return SayHi(name); }); 20 } 21 static string SayHi(string name) 22 { 23 Task.Delay(2000).Wait();//非同步等待2s 24 Console.WriteLine($"SayHi執行，當前執行緒Id為：{Thread.CurrentThread.ManagedThreadId}"); 25 return $"Hello,{name}"; 26 } 27 }
執行結果如下，使用await關鍵字來呼叫返回任務的非同步方法SayHiAsync，而使用await需要有用async修飾符宣告的方法，在SayHiAsync方法為完成前，下面的方法不會繼續執行。但是主執行緒並沒有阻塞，且任務處理完成後await後的邏輯繼續執行。
本質：編譯器將await關鍵字後的所有程式碼放進了延續（ContinueWith）方法的程式碼塊中來轉換await關鍵詞。
解析async和await
1.非同步（async）
使用async修飾符標記的方法稱為非同步方法，非同步方法只可以具有以下返回型別：1.Task2.Task<TResult>3.void4.從C# 7.0開始，任何具有可訪問的GetAwaiter方法的型別。System.Threading.Tasks.ValueTask<TResult> 型別屬於此類實現（需向專案新增System.Threading.Tasks.Extensions NuGet 包）。
非同步方法通常包含 await 運算子的一個或多個例項，但缺少 await 表示式也不會導致生成編譯器錯誤。 如果非同步方法未使用 await 運算子標記暫停點，那麼非同步方法會作為同步方法執行，即使有 async 修飾符也不例外，編譯器將為此類方法釋出一個警告。
2.等待（await）
await 表示式只能在由 async 修飾符標記的封閉方法體、lambda 表示式或非同步方法中出現。在其他位置，它會解釋為識別符號。
使用await運算子的任務只可用於返回 Task、Task<TResult> 和 System.Threading.Tasks.ValueType<TResult> 物件的方法。
非同步方法同步執行，直至到達其第一個 await 表示式，此時await在方法的執行中插入掛起點，會將方法掛起直到所等待的任務完成，然後繼續執行await後面的程式碼區域。
await 表示式並不阻止正在執行它的執行緒。 而是使編譯器將剩下的非同步方法註冊為等待任務的延續任務。 控制權隨後會返回給非同步方法的呼叫方。 任務完成時，它會呼叫其延續任務，非同步方法的執行會在暫停的位置處恢復。
注意：
1.無法等待具有 void 返回型別的非同步方法，並且無效返回方法的呼叫方捕獲不到非同步方法丟擲的任何異常。
2.非同步方法無法宣告 in、ref 或 out 引數，但可以呼叫包含此類引數的方法。 同樣，非同步方法無法通過引用返回值，但可以呼叫包含 ref 返回值的方法。
非同步方法執行機理（控制流）
非同步程式設計中最需弄清的是控制流是如何從方法移動到方法的。
下列示例及說明引自（官方文件），個人認為已經很清晰了：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 var result = AccessTheWebAsync(); 6 Console.ReadKey(); 7 } 8 async static Task<int> AccessTheWebAsync() 9 { 10 HttpClient client = new HttpClient(); 11 // GetStringAsync返回一個任務。任務Result會得到一個字串(urlContents)。 12 Task<string> getStringTask = client.GetStringAsync("https://www.cnblogs.com/jonins/"); 13 //您可以在這裡完成不依賴於GetStringAsync的字串的工作。 14 DoIndependentWork(); 15 //等待的操作員暫停進入WebAsync。 16 //AccessTheWebAsync在getStringTask完成之前不能繼續。 17 //同時，控制權返回到AccessTheWebAsync的呼叫方。 18 //當getStringTask完成後，控制元件權將繼續在這裡工作。 然後，await運算子從getStringTask檢索字串結果。 19 string urlContents = await getStringTask; 20 //任務完成 21 Console.WriteLine(urlContents.Length); 22 //return語句指定一個整數結果。 23 return urlContents.Length; 24 } 25 static void DoIndependentWork() 26 { 27 Console.WriteLine("Working.........."); 28 } 29 }
多個非同步方法
在一個非同步方法裡，可以呼叫一個或多個非同步方法，如何編碼取決於非同步方法間結果是否相互依賴。
1.順序呼叫非同步方法
使用await關鍵詞可以呼叫每個非同步方法，如果一個非同步方法需要使用另一個非同步方法的結果，await關鍵詞就非常必要。
示例如下：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine("執行前....."); 6 GetResultAsync(); 7 Console.WriteLine("執行中....."); 8 Console.ReadKey(); 9 } 10 async static void GetResultAsync() 11 { 12 var number1 = await GetResult(10); 13 var number2 = GetResult(number1); 14 Console.WriteLine($"結果分別為：{number1}和{number2.Result}"); 15 } 16 static Task<int> GetResult(int number) 17 { 18 return Task.Run<int>(() => { Task.Delay(1000).Wait(); return number + 10; }); 19 } 20 }
2.使用組合器
如果非同步方法間相互不依賴，則每個非同步方法都不使用await，而是把每個非同步方法的結果賦值給Task變數，就會執行得更快。
示例如下：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Console.WriteLine("執行前....."); 6 GetResultAsync(); 7 Console.WriteLine("執行中....."); 8 Console.ReadKey(); 9 } 10 async static void GetResultAsync() 11 { 12 Task<int> task1 = GetResult(10); 13 Task<int> task2 = GetResult(20); 14 await Task.WhenAll(task1, task2); 15 Console.WriteLine($"結果分別為：{task1.Result}和{task2.Result}"); 16 } 17 static Task<int> GetResult(int number) 18 { 19 return Task.Run<int>(() => { Task.Delay(1000).Wait(); return number + 10; }); 20 } 21 }
Task類定於2個組合器分別為：WhenAll和WhenAny。
WhenAll是在所有傳入的任務都完成時才返回Task。
WhenAny是在傳入的任務其中一個完成就會返回Task。
非同步方法的異常處理
1.異常處理
以下示例一種是普通的錯誤的捕獲方式，另一種是非同步方法異常捕獲方式：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 6 DontHandle(); 7 HandleError(); 8 Console.ReadKey(); 9 } 10 //錯誤處理 11 static void DontHandle() 12 { 13 try 14 { 15 var task = ThrowAfter(0, "DontHandle Error"); 16 } 17 catch (Exception ex) 18 { 19 20 Console.WriteLine(ex.Message); 21 } 22 } 23 //非同步方法錯誤處理 24 static async void HandleError() 25 { 26 try 27 { 28 await ThrowAfter(2000, "HandleError Error"); 29 } 30 catch (Exception ex) 31 { 32 33 Console.WriteLine(ex.Message); 34 } 35 } 36 //在延遲後丟擲異常 37 static async Task ThrowAfter(int ms, string message) 38 { 39 await Task.Delay(ms); 40 throw new Exception(message); 41 } 42 }
執行結果如下：
呼叫非同步方法，如果只是簡單的放在try/catch塊中，將會捕獲不到異常。這是因為DontHandle方法在ThrowAfter丟擲異常之前已經執行完畢（返回void的非同步方法不會等待。這是因為從async void方法丟擲的異常無法捕獲。因此非同步方法最好返回一個Task型別）。
非同步方法的一個較好異常處理方式，是使用await關鍵字，將其放在try/catch中。
2.多個非同步方法異常處理
如果呼叫了多個非同步方法，在第一個非同步方法丟擲異常，後續的方法將不會被呼叫，catch塊內只會處理出現的第一個異常。
所以正確的做法是使用Task.WhenAll,不管任務是否丟擲異常都會等到所有任務完成。Task.WhenAll結束後，異常被catch語句捕獲到。如果只是捕獲Exception，我們只能看到WhenAll方法的第一個發生異常的任務資訊，不會丟擲後續的異常任務。
如果要捕獲所有任務的異常資訊，就是對任務宣告變數，在catch塊內可以訪問，再使用IsFaulted屬性檢查任務的狀態，以確認它們是否出現錯誤，然後再進行處理。示例如下：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 HandleError(); 6 Console.ReadKey(); 7 } 8 //正確的處理方式 9 static async void HandleError() 10 { 11 Task t1 = null; 12 Task t2 = null; 13 try 14 { 15 t1 = ThrowAfter(1000, "HandleError-One-Error"); 16 t2 = ThrowAfter(2000, "HandleError-Two-Error"); 17 await Task.WhenAll(t1, t2); 18 } 19 catch (Exception) 20 { 21 if (t1.IsFaulted) 22 Console.WriteLine(t1.Exception.InnerException.Message); 23 if (t2.IsFaulted) 24 Console.WriteLine(t2.Exception.InnerException.Message); 25 } 26 } 27 //在延遲後丟擲異常 28 static async Task ThrowAfter(int ms, string message) 29 { 30 await Task.Delay(ms); 31 throw new Exception(message); 32 } 33 }
3.使用AggregateException捕獲非同步方法異常
在 中介紹過AggregateException，它包含了等待中所有異常的列表，可輕鬆遍歷處理所有異常資訊。示例如下：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 HandleError(); 6 Console.ReadKey(); 7 } 8 //正確的處理方式 9 static async void HandleError() 10 { 11 Task taskResult = null; 12 try 13 { 14 Task t1 = ThrowAfter(1000, "HandleError-One-Error"); 15 Task t2 = ThrowAfter(2000, "HandleError-Two-Error"); 16 await (taskResult = Task.WhenAll(t1, t2)); 17 } 18 catch (Exception) 19 { 20 foreach (var ex in taskResult.Exception.InnerExceptions) 21 { 22 Console.WriteLine(ex.Message); 23 } 24 25 } 26 } 27 //在延遲後丟擲異常 28 static async Task ThrowAfter(int ms, string message) 29 { 30 await Task.Delay(ms); 31 throw new Exception(message); 32 } 33 }
重要的補充與建議
1.提高響應能力
.NET有很多非同步API我們都可以通過async/await構建呼叫提高響應能力，例如：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 Demo(); 6 Console.ReadKey(); 7 } 8 static async void Demo() 9 { 10 HttpClient httpClient = new HttpClient(); 11 var getTaskResult = await httpClient.GetStringAsync("https://www.cnblogs.com/jonins/"); 12 Console.WriteLine(getTaskResult); 13 } 14 }
這些API都有相同原則即以Async結尾。
2.重要建議
1.async方法需在其主體中具有await 關鍵字，否則它們將永不暫停。同時C# 編譯器將生成一個警告，此程式碼將會以類似普通方法的方式進行編譯和執行。 請注意這會導致效率低下，因為由 C# 編譯器為非同步方法生成的狀態機將不會完成任何任務。
2.應將“Async”作為字尾新增到所編寫的每個非同步方法名稱中。這是 .NET 中的慣例，以便更輕鬆區分同步和非同步方法。
3.async void 應僅用於事件處理程式。因為事件不具有返回型別（因此無法返回 Task 和 Task<T>）。 其他任何對 async void 的使用都不遵循 TAP 模型，且可能存在一定使用難度。
例如：async void 方法中引發的異常無法在該方法外部被捕獲或十分難以測試 async void 方法。
3.以非阻止方式處理等待任務
非同步程式設計準則
非同步程式設計的準則是確定所需執行的操作是I/O-Bound還是 CPU-Bound。因為這會極大影響程式碼效能，並可能導致某些構造的誤用。
考慮兩個問題：
1.你的程式碼是否會“等待”某些內容，例如資料庫中的資料或web資源等？如果答案為“是”，則你的工作是 I/O-Bound。
2.你的程式碼是否要執行開銷巨大的計算？如果答案為“是”，則你的工作是 CPU-Bound。
如果你的工作為 I/O-Bound，請使用 async 和 await（而不使用 Task.Run）。 不應使用任務並行庫。 如果你的工作為 CPU-Bound，並且你重視響應能力，請使用 async 和 await，並在另一個執行緒上使用 Task.Run 生成工作。 如果該工作同時適用於併發和並行，則應考慮使用任務並行庫。
結語
如果想要了解狀態機請戳：這裡 。
參考資料
C#高階程式設計（第10版） C# 6 & .NET Core 1.0 Christian Nagel
果殼中的C# C#5.0權威指南 Joseph Albahari
https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/async/index
https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/async
https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/await