建議非同步返回Task或Task<T>

當在.NET Core中寫爬蟲用到非同步去下載資源後接下來進行處理，對於處理完成結果我返回void，想到這裡不僅僅一愣，這麼到底行不行，翻一翻寫的第一篇部落格，只是提醒了我下不要用void，至於為何不用也沒去探討，接下來我們來探討下返回值為Task和void，至於Task<T>這個和Task類似。我們直接看程式碼，首先演示void，如下：

        private static async void ThrowExceptionAsync()
        {
            await Task.Delay(TimeSpan.FromSeconds(1
 
));
            throw new InvalidOperationException();
        }
        private static void AsyncVoidExceptions_CannotBeCaughtByCatch()
        {
            try
            {
                ThrowExceptionAsync();
            }
            catch (Exception ex)
            {

                throw ex;
            }
        }
 

然後在控制檯中進行呼叫，如下：

        static void Main(string[] args)
        {
            AsyncVoidExceptions_CannotBeCaughtByCatch();
            Console.ReadKey();
        }

此時我們在非同步程式碼且返回值為void的方法中有一個異常，並且我們在呼叫該非同步方法中去捕捉異常，但是結果並未捕捉到。接下來我們將非同步方法返回值修改為Task如下再來看看：

        private static async Task ThrowExceptionAsync()
        {
            
 
await Task.Delay(TimeSpan.FromSeconds(1));
            throw new InvalidOperationException();
        }
        private static async Task AsyncVoidExceptions_CannotBeCaughtByCatch()
        {
            try
            {               
                await ThrowExceptionAsync();
            }
            catch (Exception ex)
            {

                throw ex;
            }
        }

此時發現返回值Task和void對於異常都無法捕捉到，這麼一來是不是返回值使用Task和void皆可以呢，我們注意到對於被呼叫的非同步方法且返回值為Task，我們試試將先接收其返回值，然後再await看看。此時我們對於第二個非同步方法修改成如下：

        private static async Task AsyncVoidExceptions_CannotBeCaughtByCatch()
        {
            Task task = ThrowExceptionAsync();
            try
            {
                await task;
            }
            catch (Exception ex)
            {

                throw ex;
            }
        }

通過事先接收其返回值Task然後再await，此時我們就能捕捉到異常，而為什麼void無法捕捉到異常呢？請看如下解釋

當在Task或者Task<T>中丟擲異常時，此時異常資訊將被捕捉到並被放到Task物件中，但是在void非同步方法啟動時SynchronizationContext將被啟用並且此時沒有Task物件，此時異常資訊將直接被儲存到非同步上下文中即（SynchronizationContext）。

對於捕捉void異常資訊其實沒有什麼根本上的解決辦法，如果是在控制檯中可以用下載 Nito.AsyncEx 程式包並將方法放在  AsyncContext.Run(()=>.....) 執行，還有其他等方法，返回值為void更多用在windows客戶端事件處理程式包中，例如如下：

private async void btn_Click(object sender, EventArgs e)
{
  await BtnClickAsync();
}
public async Task BtnClickAsync()
{
  // Do asynchronous work.
  await Task.Delay(1000);
}

在非同步操作中如果返回值為Task或者Task<T>，我們知道接下來給如何進行處理，但是返回值為void我們根本不知道它什麼時候完成，同時利用void來進行單元測試時也不會丟擲異常，所以我們對於非同步返回值大部分情況下必須使用Task或者Task<T>，除了基於事件處理而不得不返回void外，對於Task或者Task<T>有利於異常捕捉、暴露更多方法如（Task.WhenAll、Task.WhenAny）、方便單元測試等，基於此我們在此下一個基本結論：

雖然在非同步方法中提示返回值可以為Task、Task<T>或者void，但是我們強烈建議返回值只為Task或者Task<T>，除了基於事件處理程式外，因為返回值為void無法捕捉異常資訊且不方便單元測試，同時根本不知道非同步操作什麼時候完成。而對於Task異常資訊被儲存到Task物件中，所以在捕捉異常資訊時，首先返回非同步方法Task，然後進行await。

但是對於Task捕捉異常資訊還有一個問題我們並未探討，請往下看。

        public static Task<int> First()
        {
            return Task<int>.Factory.StartNew(() =>
            {
                throw new Exception(" Exception From First!");
            });
        }
        public static Task<int> Second()
        {
            return Task<int>.Factory.StartNew(() =>
            {
                throw new Exception(" Exception From Second!");
            });
        }

上述定義兩個非同步方法，並且都丟擲異常，接下來我們再來定義一個方法呼叫上述兩個方法，如下：

        public static async Task<int> Caclulate()
        {
            return await First() + await Second();
        } 

上述情況下理論上呼叫兩個方法應該丟擲兩個異常資訊才對，但是結果只對一個First非同步方法丟擲異常，而對於第二個非同步方法Second則忽略了，什麼情況，還沒看懂，我們進一步進行如下改造。

        static void Main(string[] args)
        {
            try
            {
                Caclulate().Wait(1000);
            }
            catch (AggregateException ex)
            {

                throw ex;
            }
            Console.ReadKey();
         }

我們通過聚合異常類 AggregateException 來接收異常資訊，結果只丟擲一個異常資訊，並且是第一個。 我們再利用返回Task來接收並await來看看是否有不同。

        public static async Task Test()
        {
            var task = Caclulate();
            try
            {
                await task;
            }
            catch (Exception ex)
            {

                throw ex;
            }
        }

此時也將僅僅丟擲第一個異常資訊，所以通過這裡演示我們可以下個結論：當在非同步程式碼中呼叫多個非同步方法時，若出現異常，此時則不會丟擲聚合異常而僅僅只是丟擲第一個異常。

建議非同步感染

在非同步操作中如果非同步程式碼又被其他非同步程式碼呼叫時，將同步程式碼轉換為非同步程式碼能夠更有效執行，在非同步程式碼中沒有感染的概念，為什麼我提出“感染”這一概念呢，想必正確使用過非同步方法的童鞋深有體會，當一個非同步方法被另外一個方法呼叫時，此時另外一個方法若是同步方法，此時會提示將該方法非同步，所以通過該傳播行為從最底層非同步方法到最高層呼叫者都將是非同步方法（類似殭屍屍毒），這也是我們所推薦的，一旦用了非同步程式碼則總是用非同步程式碼，不要將同步程式碼和非同步程式碼混合使用，很容易導致阻塞情況特別是呼叫Task.Wait或者Task.Result。這一點我有切身感受，在爬蟲中利用同步方法中呼叫非同步程式碼，最終獲取該非同步方法中的結果通過Task.Rsult，結果利用Windows窗體測試時發現已經被阻塞，一直顯示Task.Result處於計算中。不信，你看如下程式碼。所以我們強烈建議：一旦使用非同步程式碼且總是使用非同步程式碼讓非同步程式碼自然過渡層層傳遞，大部分情況下千萬別調用Task.Wait或者Task.Result很容易導致阻塞。

    public static class DeadlockDemo
    {
        private static async Task DelayAsync()
        {
            await Task.Delay(1000);
        }
      
        public static void Test()
        {    
            var delayTask = DelayAsync();
            delayTask.Wait();
        }
    }

        private void btn_click(object sender, EventArgs e)
        {
            DeadlockDemo.Test();
            MessageBox.Show("非同步死鎖");
        }

將上述程式碼在windows form或者ASP.NET程式中執行你會發現上述呼叫Wait後會導致死鎖，但在控制檯中將不會出現這種死鎖情況。按照我們對非同步的理解，預設情況下，當一個未被完成的任務被await時，此時將捕捉到當前上下文，直到任務被完成喚醒該方法，如果當前上下文為空，那麼此時當前上下文則為SynchronizationContext。對於如winddows form中的GUI或者ASP.NET應用程式，此時任務排程器的上下文則是SynchronizationContext且只允許一塊程式碼執行一次，當任務完成時，將試圖在捕捉的當前上下文去執行非同步方法中的其他方法，但是此時已經有一個執行緒當前上下文存在，造成同步方法去等待完成非同步方法，結果引起非同步方法喚醒當前方法繼續執行，但是當前同步方法也在等待非同步方法完成，彼此等待，造成死鎖。

建議非同步配置上下文（分情況）

什麼時候應該配置上下文，當我們需要等待結果完成時可以配置上下文，如下：

        async Task ConfigureContext()
        {           
            await Task.Delay(1000);
          
            await Task.Delay(1000).ConfigureAwait(
              continueOnCapturedContext: false);
            
        }

當進行如上配置後在 await Task.Delay(1000); 之前毫無疑問將在原始上下文中執行，  await Task.Delay(1000).ConfigureAwait( continueOnCapturedContext: false); 此時在此之後因為不捕捉上下文，此時將線上程池中執行。我們在此之前演示了一個造成死鎖的例子，通過配置上下文就可以解決。

        private static async Task DelayAsync()
        {
            await Task.Delay(1000).ConfigureAwait(
    continueOnCapturedContext: false);
        }

        public static void Test()
        {
            var delayTask = DelayAsync();
            delayTask.Wait();
        }

我們知道預設情況下當await一個未完成的任務時，此時將捕獲上下文來喚醒非同步方法來執行其餘的方法，但是此時我們配置上下文為false，告訴它不需要捕獲我們根本不耗費時間，我們馬上就能完成，此時將解決死鎖的問題。在非同步中配置 ConfigureAwait( continueOnCapturedContext: false); 的作用在於：將同步方法轉換為非同步方法和防止死鎖。

那麼問題來了什麼時候不應該配置上下文呢？請繼續看如下例子：

        private async void btn_click(object sender, EventArgs e)
        {
            Enabled = false;
            try
            {
                await Task.Delay(1000).ConfigureAwait(
    continueOnCapturedContext: false);
            }
            finally
            {

                Enabled = true;
            }

        }

當點選按鈕時我們禁用按鈕，同時關閉了其捕獲當前上下文，但是最後我們又需要用到當前上下文，所以此時導致取不到一樣的執行緒，此時類似跨執行緒，出現執行緒不一致的情況。每個非同步方法都有其上下文並且每個方法的上下文是獨立開來的。什麼意思呢，由於上述我們直接在點選事件裡面關閉了捕獲上下文，如果我們定義一個方法，在此方法裡面來關閉捕獲上下文，此時再來在點選事件裡呼叫該非同步方法，此時點選事件和該非同步方法獨立互不影響，千萬別以為呼叫了該非同步方法就說明是在點選事件裡關閉了上下文，如下：

        private async void btn_click(object sender, EventArgs e)
        {
            Enabled = false;
            try
            {
                await DisableBtnAsync();
            }
            finally
            {

                Enabled = true;
            }

        }

        private async Task DisableBtnAsync()
        {
           
            await Task.Delay(1000).ConfigureAwait(continueOnCapturedContext: 
                false);
        }

由上已經證明了這點，好了本節我們到此結束。