.NET異步操做學習之一：Async/Await中異常的處理

時間  2019-11-18
標籤 異步 學習 之一 async await 異常 處理 欄目 Java 简体版
原文   原文鏈接

之前的異常處理，習慣了過程式的把出現的異常所有捕捉一遍，而後再進行處理。Async/Await關鍵字出來以後的確簡化了異步編程，但也帶來了一些問題。接下來本身將對這對關鍵字進行學習。而後把研究結果放在這裏。編程

本篇中採用MSDN中的一個列子進行學習，連接以下：數組

http://msdn.microsoft.com/zh-cn/library/jj619227.aspx異步

如今正式開始，首先嚐試一個過程式捕捉異步操做中錯誤的例子：async

class Program
    {
        static async Task ThrowAfter(int timeout, Exception ex)
        {
            await Task.Delay(timeout);
            throw ex;
        }

        static void PrintException(Exception ex)
        {
            Console.WriteLine("時間：{0}\n{1}\n======", stopWatch.Elapsed, ex);
        }

        private static readonly Stopwatch stopWatch = new Stopwatch();
        static async Task MissHandling()
        {
            var taskOne = ThrowAfter(1000, new NotSupportedException("Error 1"));
            var taskTwo = ThrowAfter(2000, new NotImplementedException("Error 2"));
            try
            {
                await taskOne;
            }
            catch (NotSupportedException ex)
            {
                PrintException(ex);
            }
            catch (NotImplementedException ex)
            {
                PrintException(ex);
            }
        }
        static void Main(string[] args)
        {
            stopWatch.Start();
            MissHandling();
            Console.ReadLine();
        }
    }

如下是運行結果：異步編程

image_thumb[2]

從運行結果中能夠看出，運行並無捕捉到全部的錯誤，Error 2去哪裏了？Error 1在1s時即運行並捕捉到了，第二個返回呢？函數

C#的async/await功能基於TPL的Task對象，每一個await操做符都是「等待」一個Task完成。在以前（或者說現在）的TPL中，Task對象的析構函數會查看它的Exception對象有沒有被「訪問」過，若是沒有，且Task對象出現了異常，則會拋出這個異常，最終致使的結果每每即是進程退出。所以，咱們必須當心翼翼地處理每個Task對象的錯誤，不得遺漏。在.NET 4.5中這個行爲被改變了，對於任何沒有被檢查過的異常，便會觸發TaskSchedular.UnobservedTaskException事件——若是您不監聽這個事件，未捕獲的異常也就這麼無影無蹤了。性能

按照上面所述，咱們對Main()作2個改造：學習

一、響應TaskSchedular.UnobservedTaskException：當出錯的任務的未觀察到的異常將要觸發異常升級策略時發生，默認狀況下，這將終止進程。spa

二、不斷地觸發垃圾回收，以便Finalizer線程調用析構函數。pwa

static void Main(string[] args)
        {
            TaskScheduler.UnobservedTaskException += (s, ev) => PrintException(ev.Exception);
            stopWatch.Start();
            MissHandling();
            
            while (true)
            {
                Thread.Sleep(1000);
                GC.Collect();
            }
        }

運行結果中增長了一些信息，以下：

image_thumb[9]

從上面的信息中能夠看出，UnobservedTaskException事件並不是在「拋出」異常後便當即觸發，而是在某次垃圾收集過程，從Finalizer線程裏觸發並執行。從中也不可貴出這樣的結論：即是該事件的響應方法不能過於耗時，更加不能阻塞，不然便會對程序性能形成災難性的影響。

那麼，咱們如何處理taskOne與taskTwo中出現的2個錯誤呢？此時，Task.WhenAll登場了。

增長一個方法：

static async Task BothHandled()
        {
            var taskOne = ThrowAfter(1000,new NotSupportedException("Error 1"));
            var taskTwo = ThrowAfter(2000,new NotImplementedException("Error 2"));
            try
            {
                await Task.WhenAll(taskOne, taskTwo);
            }
            catch (NotSupportedException ex)
            {
                PrintException(ex);
            }
        }

輸出結果：

image_thumb[12]

若是您執行這段代碼，會發現其輸出與第一段代碼相同，但其實不一樣的是，第一段代碼中t2的異常被「遺漏」了，而目前這段代碼t1和t2的異常都被捕獲了，只不過await語句僅僅「拋出」了「其中一個」異常而已。

WhenAll是一個輔助方法，它的輸入是n個Task對象，輸出則是個返回它們的結果數組的Task對象。新的Task對象會在全部輸入所有「結束」後才完成。在這裏「結束」的意思包括成功和失敗（取消也是失敗的一種，即拋出了OperationCanceledException）。換句話說，假如這n個輸入中的某個Task對象很快便失敗了，也必須等待其餘全部輸入對象成功或是失敗以後，新的Task對象纔算完成。而新的Task對象完成後又可能會有兩種表現：

全部輸入Task對象都成功了：則返回它們的結果數組。
至少一個輸入Task對象失敗了：則拋出「其中一個」異常。

所有成功的狀況自沒必要說，那麼在失敗的狀況下，什麼叫作拋出「其中一個」異常？若是咱們要處理全部拋出的異常該怎麼辦？接着咱們來詳細討論await操做在異常分派時的相關行爲。

Await拋出異常時的行爲

要理解await的行爲，仍是從理解Task對象的異常表現開始。Task對象有一個Exception屬性，類型爲AggregateException，在執行成功的狀況下該屬性返回null，不然便包含了「全部」出錯的對象。既然是AggregateException，則意爲着可能包含多個子異常，這種狀況每每會在任務的父子關係中出現，具體狀況能夠參考MSDN中的相關說明。在許多狀況下一個Task內部只會出現一個異常，此時這個AggregateException的InnerExceptions屬性天然也就只一個元素。

Task對象自己還有一個Wait方法，它會阻塞當前執行代碼，直到任務完成。在出現異常的時候，它會將自身的AggregateException拋出：

try
{
    t.Wait();
}
catch (AggregateException ex)
{
    ...
}

Wait方法是「真阻塞」，而await操做則是使用阻塞語義的代碼實現非阻塞的效果，這個區別必定要分清。與Wait方法不一樣的是，await操做符效果並不是是「拋出」Task對象上的Exception屬性，而只是拋出這個AggregateException對象上的「其中一個」元素。我向C#開發組詢問這麼作的設計考慮，他們回答道，這個決策在內部也經歷了激烈的爭論，最終的選擇這種方式而不是直接拋出Task對象上的AggregateException是爲了不編寫出冗餘的代碼，並讓代碼與傳統同步編程習慣更爲接近。

他們舉了一個簡單的示例，假如一個Task對象t可能拋出兩種異常，如今的錯誤捕獲方式爲：

try
{
    await t1;
}
catch (NotSupportedException ex)
{
    ...
}
catch (NotImplementedException ex)
{
    ...
}
catch (Exception ex)
{
    ...
}

顯然前者更貼近傳統的同步編程習慣。可是問題在於，若是這個Task中包含了多個異常怎麼辦？以前的描述是拋出「其中一個」異常，對於開發者來講，「其中一個」這種模糊的說法天然沒法使人滿意，但事實的確如此。從內部郵件列表中的討論來看，C#開發團隊提到他們「故意」不提供文檔說明究竟會拋出哪一個異常，由於他們並不想作出這方面的約束，由於這部分行爲一旦寫入文檔，便成爲一個規定和限制，爲了類庫的兼容性從此也沒法對此作出修改。

他們也提到，若是單論目前的實現，await操做會從Task.Exception.InnerExceptions集合中挑出第一個異常，並對外「拋出」，這是System.Runtime.CompilerServices.TaskAwaiter類中定義的行爲。可是既然這並不是是「文檔化」的固定行爲，開發人員也儘可能不要依賴這點。

WhenAll的異常彙總方式

其實這個話題跟async/await的行爲沒有任何聯繫，WhenAll返回的是普通的Task對象，TaskAwaiter也絲絕不關心當前等待的Task對象是否來自於WhenAll，不過既然WhenAll是最經常使用的輔助方法之一，也順便將其講清楚吧。

WhenAll獲得Task對象，其結果是用數組存放的全部子Task的結果，而在出現異常時，其Exception屬性返回的AggregateException集合會包含全部子Task中拋出的異常。請注意，每一個子Task中拋出的異常將會存放在它自身的AggregateException集合中，WhenAll返回的Task對象將會「按順序」收集各個AggregateException集合中的元素，而並不是收集每一個AggregateException對象。

咱們使用一個簡單的例子來理解這點：

Task all = null;
try
{
    await (all = Task.WhenAll(
        Task.WhenAll(
            ThrowAfter(3000, new Exception("Ex3")),
            ThrowAfter(1000, new Exception("Ex1"))),
        ThrowAfter(2000, new Exception("Ex2"))));
}
catch (Exception ex)
{
    ...
}

這段代碼使用了嵌套的WhenAll方法，總共會出現三個異常，按其拋出的時機排序，其順序爲Ex1，Ex2及Ex3。那麼請問：

  • catch語句捕獲的異常是哪一個？
  • all.Exception這個AggregateException集合中異常按順序是哪些？

結果以下：

  • catch語句捕獲的異常是Ex3，由於它是all.Exception這個AggregateException集合中的第一個元素，但仍是請牢記這點，這只是當前TaskAwaiter所實現的行爲，而並不是是由文檔規定的結果。
  • all.Exception這個AggregateException集合中異常有三個，按順序是Ex3，Ex1和Ex2。WhenAll獲得的Task對象，是根據輸入的Task對象順序來決定自身AggreagteException集合中異常對象的存放順序。這個順序跟異常的拋出時機沒有任何關係。

這裏咱們也順即可以得知，若是您不想捕獲AggregateException集合中的「其中一個」異常，而是想處理全部異常的話，也能夠寫這樣的代碼：

Task all = null;
try
{
    await (all = Task.WhenAll(
        ThrowAfter(1000, new Exception("Ex1")),
        ThrowAfter(2000, new Exception("Ex2"))));
}
catch
{
    foreach (var ex in all.Exception.InnerExceptions)
    {
        ...
    }
}

固然，這裏使用Task.WhenAll做爲示例，是由於這個Task對象能夠明確包含多個異常，但並不是只有Task.WhenAll返回的Task對象纔可能包含多個異常，例如Task對象在建立時指定了父子關係，也會讓父任務裏包含各個子任務裏出現的異常。

假如異常未被捕獲

最後再來看一個簡單的問題，咱們一直在關注一個async方法中「捕獲」異常的行爲，假如異常沒有成功捕獲，直接對外拋出的時候，對任務自己的有什麼影響呢？且看這個示例：

static async Task SomeTask()
{
    try
    {
        await Task.WhenAll(
            ThrowAfter(2000, new NotSupportedException("Ex1")),
            ThrowAfter(1000, new NotImplementedException("Ex2")));
    }
    catch (NotImplementedException) { }
}

static void Main(string[] args)
{
    _watch.Start();

    SomeTask().ContinueWith(t => PrintException(t.Exception));

    Console.ReadLine();
}

本例運行結果以下：

image_thumb[15]

AggregateException的打印內容不那麼容易讀，咱們能夠關注它Inner Exception #0這樣的信息。從時間上說，Ex2先於Ex1拋出，而catch的目標是NotImplementedException。但從以前的描述咱們能夠知道，WhenAll返回的Task內部的異常集合，與各異常拋出的時機沒有關係，所以await操做符拋出的是Ex1，是NotSupportedException，而它不會被catch到，所以SomeTask返回的Task對象也會包含這個異常——也僅僅是拋出這個異常，而Ex2對於外部就不可見了。

若是您想在外部處理全部的異常，則能夠這樣：

Task all = null;
try
{
    await (all = Task.WhenAll(
        ThrowAfter(2000, new NotSupportedException("Ex1")),
        ThrowAfter(1000, new NotImplementedException("Ex2"))));
}
catch
{
    throw all.Exception;
}

此時打印的結果即是一個AggregateException包含着另外一個AggregateException，其中包含了Ex1和Ex2。爲了「解開」這種嵌套關係，AggregateException也提供了一個Flatten方法，能夠將這種嵌套徹底「鋪平」，例如：

SomeTask().ContinueWith(t => PrintException(t.Exception.Flatten()));

此時打印的結果便直接是一個AggregateException包含着Ex1與Ex2了。

本例全部代碼以下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Threading;
namespace AsyncAwaitTest
{
    class Program
    {
        static async Task ThrowAfter(int timeout, Exception ex)
        {
            await Task.Delay(timeout);
            throw ex;
        }

        static void PrintException(Exception ex)
        {
            Console.WriteLine("時間：{0}\n{1}\n======", stopWatch.Elapsed, ex);
        }

        private static readonly Stopwatch stopWatch = new Stopwatch();
        static async Task MissHandling()
        {
            var taskOne = ThrowAfter(1000, new NotSupportedException("Error 1"));
            var taskTwo = ThrowAfter(2000, new NotImplementedException("Error 2"));
            try
            {
                await taskOne;
            }
            catch (NotSupportedException ex)
            {
                PrintException(ex);
            }
            catch (NotImplementedException ex)
            {
                PrintException(ex);
            }
        }
        static async Task BothHandled()
        {
            var taskOne = ThrowAfter(1000,new NotSupportedException("Error 1"));
            var taskTwo = ThrowAfter(2000,new NotImplementedException("Error 2"));
            try
            {
                await Task.WhenAll(taskOne, taskTwo);
            }
            catch (NotSupportedException ex)
            {
                PrintException(ex);
            }
        }
        static async Task SomeTask()
        {
            Task all = null;
            try
            {
                await
                    (all=Task.WhenAll(ThrowAfter(1000, new NotSupportedException("Error 1")),
                                 ThrowAfter(2000, new NotImplementedException("Error 2"))));
                
            }
            catch
            {
                throw all.Exception;
            }
        }
        static void Main(string[] args)
        {
            
            stopWatch.Start();
            SomeTask().ContinueWith(t => PrintException(t.Exception.Flatten()));

            Console.ReadLine();

        }
    }
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程