以前的异常处理,习惯了过程式的把出现的异常全部捕捉一遍,然后再进行处理。Async/Await关键字出来之后的确简化了异步编程,但也带来了一些问题。接下来自己将对这对关键字进行学习。然后把研究结果放在这里。

本篇中采用MSDN中的一个列子进行学习,链接如下:

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

现在正式开始,首先尝试一个过程式捕捉异步操作中错误的例子:

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(, new NotSupportedException("Error 1"));
var taskTwo = ThrowAfter(, 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();
}
}

以下是运行结果:

从运行结果中可以看出,运行并没有捕捉到所有的错误,Error 2去哪里了?Error 1在1s时即运行并捕捉到了,第二个返回呢?

C#的async/await功能基于TPL的Task对象,每个await操作符都是“等待”一个Task完成。在之前(或者说如今)的TPL中,Task对象的析构函数会查看它的Exception对象有没有被“访问”过,如果没有,且Task对象出现了异常,则会抛出这个异常,最终导致的结果往往便是进程退出。因此,我们必须小心翼翼地处理每一个Task对象的错误,不得遗漏。在.NET 4.5中这个行为被改变了,对于任何没有被检查过的异常,便会触发TaskSchedular.UnobservedTaskException事件——如果您不监听这个事件,未捕获的异常也就这么无影无踪了。

按照上面所述,我们对Main()做2个改造:

1、响应TaskSchedular.UnobservedTaskException:当出错的任务的未观察到的异常将要触发异常升级策略时发生,默认情况下,这将终止进程。

2、不断地触发垃圾回收,以便Finalizer线程调用析构函数。

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

运行结果中增加了一些信息,如下:

从上面的信息中可以看出,UnobservedTaskException事件并非在“抛出”异常后便立即触发,而是在某次垃圾收集过程,从Finalizer线程里触发并执行。从中也不难得出这样的结论:便是该事件的响应方法不能过于耗时,更加不能阻塞,否则便会对程序性能造成灾难性的影响。

那么,我们如何处理taskOne与taskTwo中出现的2个错误呢?此时,Task.WhenAll登场了。

增加一个方法:

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

输出结果:

如果您执行这段代码,会发现其输出与第一段代码相同,但其实不同的是,第一段代码中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(, new Exception("Ex3")),
ThrowAfter(, new Exception("Ex1"))),
ThrowAfter(, 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(, new Exception("Ex1")),
ThrowAfter(, 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(, new NotSupportedException("Ex1")),
ThrowAfter(, new NotImplementedException("Ex2")));
}
catch (NotImplementedException) { }
} static void Main(string[] args)
{
_watch.Start(); SomeTask().ContinueWith(t => PrintException(t.Exception)); Console.ReadLine();
}

本例运行结果如下:

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(, new NotSupportedException("Ex1")),
ThrowAfter(, 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(, new NotSupportedException("Error 1"));
var taskTwo = ThrowAfter(, new NotImplementedException("Error 2"));
try
{
await taskOne;
}
catch (NotSupportedException ex)
{
PrintException(ex);
}
catch (NotImplementedException ex)
{
PrintException(ex);
}
}
static async Task BothHandled()
{
var taskOne = ThrowAfter(,new NotSupportedException("Error 1"));
var taskTwo = ThrowAfter(,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(, new NotSupportedException("Error 1")),
ThrowAfter(, new NotImplementedException("Error 2")))); }
catch
{
throw all.Exception;
}
}
static void Main(string[] args)
{ stopWatch.Start();
SomeTask().ContinueWith(t => PrintException(t.Exception.Flatten())); Console.ReadLine(); }
}
}

.NET异步操作学习之一:Async/Await中异常的处理的更多相关文章

  1. .NET Core学习笔记(3)——async/await中的Exception处理

    在写了很多年.NET程序之后,年长的猿类在面对异步编程时,仍不时会犯下致命错误,乃至被拖出去杀了祭天.本篇就async/await中的Exception处理进行讨论,为种族的繁衍生息做出贡献……处理a ...

  2. [译]async/await中阻塞死锁

    这篇博文主要是讲解在async/await中使用阻塞式代码导致死锁的问题,以及如何避免出现这种死锁.内容主要是从作者Stephen Cleary的两篇博文中翻译过来. 原文1:Don'tBlock o ...

  3. 关于C#中async/await中的异常处理(下)-(转载)

    上一篇文章里我们讨论了某些async/await的用法中出现遗漏异常的情况,并且谈到该如何使用WhenAll辅助方法来避免这种情况.WhenAll辅助方法将会汇总一系列的任务对象,一旦其中某个出错,则 ...

  4. 关于C#中async/await中的异常处理(上)-(转载)

    在同步编程中,一旦出现错误就会抛出异常,我们可以使用try…catch来捕捉异常,而未被捕获的异常则会不断向上传递,形成一个简单而统一的错误处理机制.不过对于异步编程来说,异常处理一直是件麻烦的事情, ...

  5. 关于C#中async/await中的异常处理(上)

    关于C#中async/await中的异常处理(上) 2012-04-11 09:15 by 老赵, 17919 visits 在同步编程中,一旦出现错误就会抛出异常,我们可以使用try…catch来捕 ...

  6. 微信小程序捕获async/await函数异常实践

    背景 我们的小程序项目的构建是与web项目保持一致的,完全使用webpack的生态来构建,没有使用小程序自带的构建功能,那么就需要我们配置代码转换的babel插件如Promise.Proxy等:另外, ...

  7. 如何优雅地处理Async/Await的异常?

    译者按: 使用.catch()来捕获所有的异常 原文: Async Await Error Handling in JavaScript 译者: Fundebug 本文采用意译,版权归原作者所有 as ...

  8. js异步回调Async/Await与Promise区别 新学习使用Async/Await

    Promise,我们了解到promise是ES6为解决异步回调而生,避免出现这种回调地狱,那么为何又需要Async/Await呢?你是不是和我一样对Async/Await感兴趣以及想知道如何使用,下面 ...

  9. [译]async/await中使用阻塞式代码导致死锁 百万数据排序:优化的选择排序(堆排序)

    [译]async/await中使用阻塞式代码导致死锁 这篇博文主要是讲解在async/await中使用阻塞式代码导致死锁的问题,以及如何避免出现这种死锁.内容主要是从作者Stephen Cleary的 ...

随机推荐

  1. spring websocket Converters must not be empty

    此文件    WebSocketConfig.java public class WebSocketConfig implements WebSocketMessageBrokerConfigurer ...

  2. Oracle Outline总结

    一.基本概述 Oracle Outline,中文也称为存储大纲,是最早的基于提示来控制SQL运行计划的机制.也是9i以及之前版本号唯一能够用来稳定和控制SQL运行计划的工具. outline是一个hi ...

  3. PagerSlidingTabStrip

    https://github.com/jpardogo/PagerSlidingTabStrip     

  4. 通用块层、IO调度层以及设备驱动层的数据结构

    http://blog.chinaunix.net/uid-28897358-id-3775640.html

  5. overflow: hidden用法,不仅仅是隐藏溢出

    overflow:hidden是大家常用到的CSS样式,但是大多数人对这个样式的理解仅仅局限于隐藏溢出,而对于清除浮动这个含义不是很了解. <!DOCTYPE html> <html ...

  6. Android开发JDBC连接mysql数据库导入驱动方法

    在使用JDBC编程时需要连接数据库,导入JAR包是必须的,导入其它的jar包方法同样如此,导入的方法是 打开eclipse 1.右击要导入jar包的项目,点properties 2.左边选择java ...

  7. 利用QT制作我们自己的一个计算器

    有了前面的经验就比较容易创建一个 属于我们自己的计算器了. 一些简单的拖拽就可以实现了. 界面设计部分: 转到槽之后的代码部分: #include "widget.h" #incl ...

  8. 【排障】每次打开word都提示要安装配置

    为什么每次打开word都提示要安装配置?很多人在打开word时,总是提示要安装配置一遍,花去不少时间,这是由于电脑里有两个不同版本的office软件,产生的原因可能是原来的卸载了没卸载干净,或是安装了 ...

  9. 构建本地yum源之rpmbuild问题汇总

    - check-rpaths的问题 今天在编译varnish的时候,遇到几个问题,其中一个就是出现如下错误: ...+ /usr/lib/rpm/check-rpaths /usr/lib/rpm/c ...

  10. linux 软连接方式实现上传文件存储目录的无缝迁移

    背景: 由于前期的磁盘空间规划与后期的业务要求不符合.原先/home被用于用户上传文件的存储目录,但是由于上传文件的逐渐增多,而原来的/home目录的空间不足,需要给/home目录进行扩容.同时各个应 ...