NET(C#)：await返回Task的async方法
一.??FrameWork 4.0之前的線程世界?
? 在.NET FrameWork 4.0之前，如果我們使用線程。一般有以下幾種方式：
- 使用System.Threading.Thread 類，調用實例方法Start()開啟一個新線程，調用Abort()方法來提前終止線程。
- 使用System.Threading.ThreadPool類，調用靜態方法QueueUserWorkItem()，將方法放入線程池隊列，線程池來控制調用。
- 使用BeginInvoke,EndInvoke,BeginRead,EnRead,BeginWrite,EndWrite等一系列的異步方法。
- 使用System.ComponentModel.BackgroundWorker控件，調用實例方法RunWorkerAsync()，開啟一個新線程。
二.??.Net 傳統異步編程概述?
- 異步編程模型 (APM)，在該模型中異步操作由一對 Begin/End 方法（如 FileStream.BeginRead 和 Stream.EndRead）表示。
- 基于事件的異步模式 (EAP)，在該模式中異步操作由名為“操作名稱Async”和“操作名稱Completed”的方法/事件對（例如 WebClient.DownloadStringAsync 和 WebClient.DownloadStringCompleted）表示。 （EAP 是在 .NET Framework 2.0 版中引入的,在silverlight或者wpf變成中經常用到）。
三.??Task 的優點以及功能???
- 在任務啟動后，可以隨時以任務延續的形式注冊回調。
- 通過使用 ContinueWhenAll 和 ContinueWhenAny 方法或者 WaitAll 方法或 WaitAny 方法，協調多個為了響應 Begin_ 方法而執行的操作。
- 在同一 Task 對象中封裝異步 I/O 綁定和計算綁定操作。
- 監視 Task 對象的狀態。
- 使用 TaskCompletionSource 將操作的狀態封送到 Task 對象。
?
眾所周知，async方法只可以返回void，Task和Task<T>。
?
對于返回void的async方法，它并不是awaitable，所以其他方法不能用await方法來調用它，而返回Task的async方法則可以。
?
那么當async方法返回Task后，接著await，那被await的Task是一個什么概念？是async方法中第一個被await的Task？不，它代表目標async方法的全部執行，其中包括被await分割的連接Task，但是不包括非await造成的多線程執行。
?
如下代碼，在doo是一個返回Task的async方法，然后在另一個方法test中await調用doo，然后在Main方法中調用test（由于Main方法不允許加async，所以需要另外加一個async方法來使用await）
static void Main(string[] args)
{
??? test();
??? log("Main：調用test后");
??? Thread.Sleep(Timeout.Infinite);
}
?
//Main方法不允許加async，所以我們用這個方法使用await
static async void test()
{
??? log("test: await之前");
??? await doo();
??? log("test: await之后");
}
?
//返回Task的async方法
static async Task doo()
{
??? log("doo: Task結果：" + await Task.Run(() => { Thread.Sleep(1000); log("Task"); return 1; }));
??? log("doo: Task結果：" + await Task.Run(() => { Thread.Sleep(1000); log("Task"); return 2; }));
??? log("doo: Task結果：" + await Task.Run(() => { Thread.Sleep(1000); log("Task"); return 3; }));
??? Thread.Sleep(1000);
??? Console.WriteLine("doo中在Task外的Thread.Sleep執行完畢");
}
?
//輸出方法：顯示當前線程的ManagedThreadId
static void log(string msg)
{
??? Console.WriteLine("{0}: {1}", Thread.CurrentThread.ManagedThreadId, msg);
}
?
上面代碼會輸出：
1: test: await之前
1: Main：調用test后
3: Task
3: doo: Task結果：1
4: Task
4: doo: Task結果：2
3: Task
3: doo: Task結果：3
doo中在Task外的Thread.Sleep執行完畢
3: test: await之后
?
前兩句簡單，調用test方法，await后的內容會被加在目標Task的后面，然后test馬上返回，于是輸出“Main：調用test后”，同時他們都是在主線程中執行的，所以ManagedThreadId都是1。
?
接著后面就是另一個Task的執行（當然在另一個線程，也是test方法中await的目標Task）。這個所謂的Task就是doo方法的全部執行。所以doo中三個順序執行的Task（通過await一個一個連接）依次執行，所以Task輸出結果1，2，3。第一個Task的ManagedThreadId是3，第二個是4，第三個又是3，原因是Task的內部執行使用了CLR的線程池，所以線程得到了重復利用。
?
接著doo方法還沒有完，最后一個await造成doo方法后面的代碼在這個await針對的Task執行后繼續執行，于是輸出：doo中Task外的Thread.Sleep執行完畢。
?
最后當doo徹底執行完test的await才結束，所以最后一行輸出：test：await之后。
?
?
上面我說過：被await的async方法返回的Task代表“目標async方法的全部執行，其中包括被await分割的連接Task，但是不包括非await造成的多線程執行”。
所以如果把返回Task的async方法（也就是上例中的doo方法）改成這樣：
//返回Task的async方法
static async Task doo()
{
??? log("doo: Task結果：" + await Task.Run(() => { Thread.Sleep(1000); log("Task"); return 1; }));
??? log("doo: Task結果：" + await Task.Run(() => { Thread.Sleep(1000); log("Task"); return 2; }));
??? log("doo: Task結果：" + await Task.Run(() => { Thread.Sleep(1000); log("Task"); return 3; }));
?
??? //不使用await：線程池多線程
??? ThreadPool.QueueUserWorkItem(_ =>
??????? {
??????????? Thread.Sleep(1000);
??????????? Console.WriteLine("ThreadPool.QueueUserWorkItem");
??????? });
?
??? //不使用await：Task多線程
??? Task.Run(() =>
??????? {
??????????? Thread.Sleep(1000);
??????????? Console.WriteLine("Task.Run");
??????? });
}
?
我們加入了不用await的多線程執行，分別使用ThreadPool和Task，整個程序會輸出這樣的結果：
1: test: await之前
1: Main：調用test后
3: Task
3: doo: Task結果：1
4: Task
4: doo: Task結果：2
3: Task
3: doo: Task結果：3
3: test: await之后
Task.Run
ThreadPool.QueueUserWorkItem
?
不使用await的多線程完全脫離了test方法中await的Task，是運行在test的await之后的。
?
另外Visual Studio會對Task.Run代碼做如下警告：
id="iframe_0.5044486353473234" frameborder="0" scrolling="no" style="border-style:none;width:47px;">
?
提示：Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the ‘await’ operator to the result of the call.
就是說，如果不加await，當前方法會繼續執行直到結束，不用管他，因為我們現在就是在做在async方法中不用await的測試，呵呵。
?
?
或許你會問，為什么要用這樣的方式去await另一個async方法返回的Task呢？我們一直在討論返回Task的async方法，我認為看一個返回Task<T>的async方法可以更好地解釋這個問題。
?
下面我們把上面的代碼改成相似的返回Task<int>的async方法執行，那么doo方法返回Task<T>，他把自己方法內3個awaited Task的結果統一相加，最后返回結果并作為自己返回的Task的結果。然后在test方法中輸出doo返回的結果。
?
完整代碼：
static void Main(string[] args)
{
??? test();
??? log("Main：調用test后");
??? Thread.Sleep(Timeout.Infinite);
}
?
//Main方法不允許加async，所以我們用這個方法使用await
static async void test()
{
??? log("test: await之前");
??? Console.WriteLine("doo結果：{0}", await doo());
??? log("test: await之后");
}
?
//返回Task的async方法
static async Task<int> doo()
{
??? var res1 = await Task.Run(() => { Thread.Sleep(1000); log("awaited Task1執行"); return
??? var res2 = await Task.Run(() => { Thread.Sleep(1000); log("awaited Task2執行"); return
??? var res3 = await Task.Run(() => { Thread.Sleep(1000); log("awaited Task3執行"); return
?
??? //不使用await：線程池多線程
??? ThreadPool.QueueUserWorkItem(_ =>
??????? {
??????????? Thread.Sleep(1000);
??????????? Console.WriteLine("ThreadPool.QueueUserWorkItem");
??????? });
?
??? //不使用await：Task多線程
??? Task.Run(() =>
??????? {
??????????? Thread.Sleep(1000);
??????????? Console.WriteLine("Task.Run");
??????? });
?
??? return res1 + res2 + res3;
}
?
//輸出方法：顯示當前線程的ManagedThreadId
static void log(string msg)
{
??? Console.WriteLine("{0}: {1}", Thread.CurrentThread.ManagedThreadId, msg);
}
?
先看結果：
1: test: await之前
1: Main：調用test后
3: awaited Task1執行
4: awaited Task2執行
4: awaited Task3執行
doo結果：6
4: test: await之后
ThreadPool.QueueUserWorkItem
Task.Run
?
?
和上一個返回Task的例子一樣，當在test方法中await doo方法返回的Task，doo內awaited Task都被先等了，而沒有awaited的線程都并沒有被等，這是為什么呢（也就是上面留下的那個問題）？下面用這個返回Task<int>的例子解釋一下：
在test中await doo返回的Task，那么此時我們需要他的結果，而他的結果是需要自己方法內所包含的其他awaited結果，可以理解成被等的子結果。所以自己的結果需要其他的結果，那么等這個結果必須需要等那些被依賴的結果也出來。所以test方法await doo方法的結果會同樣等待所有doo內的await，不會管其他doo內非await的多線程執行（當然從技術角度講，也是不可能的，因為async/await可以這樣全靠的是編譯器）。
轉載于:https://www.cnblogs.com/Jeely/p/10997338.html
總結
以上是生活随笔為你收集整理的NET(C#)：await返回Task的async方法的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 《C#与.net高级编程》——第一支柱：
- 下一篇： 雷林鹏分享：C# 多态性