Task类在.NET4.5中,做了一些改进,比如新增了方法ConfigureAwait,Delay,Run等方法。其中一个重要修改,就是对于异常的处理。

在.NET4.0中,Task中抛出的异常,如果没有去捕获,在Task被垃圾回收的时候,析构函数检测到该Task对象还有未被处理过的异常,会抛出这个异常,并且导致进程终结,进程终结的时间是由垃圾回收器和析构方法决定的。(可以通过注册TaskSchedular.UnobservedTaskException事件处理未捕获的异常。)

ThrowUnobservedTaskExceptions节点

在.NET4.5中,微软改变了策略,对于task中未处理的异常,默认情况下不会导致杀死进程。这个可以通过配置ThrowUnobservedTaskExceptions节点实现。

默认情况下,ThrowUnobservedTaskExceptions这个节点的enabled=false。如下配置。

<configuration><runtime><ThrowUnobservedTaskExceptionsenabled="false"/></runtime></configuration>

这种情况下,在.NET4.5中,GC回收对象的时候,是不会导致程序崩溃的,未捕获的异常就这样消失了。比如下面的代码:

staticvoidMain(string[]args){for(inti=0;i<10;i++){vart=Task.Factory.StartNew<int>(()=>{thrownewException("xxxxxx");return1;},CancellationToken.None,TaskCreationOptions.None,TaskScheduler.Default);}while(true){GC.Collect();Thread.Sleep(1000);}Console.ReadKey();}

但是如果设置<ThrowUnobservedTaskExceptions enabled="true"/>,那么程序就会崩溃,这和在.NET4.0中的结局一样。

当然,对于所有的异常,都是建议捕获并且处理的。.NET4.0和4.5都提供了TaskScheduler.UnobservedTaskException事件,通过监听这个事件,也可以捕获到这个异常。

代码如下:

TaskScheduler.UnobservedTaskException+=(o,ev)=>{Console.WriteLine(ev.Exception);ev.SetObserved();Console.WriteLine("---------");};

注意:ev.SetObserved();方法必须要调用,这样才能阻止进程崩溃。

.NET4.0中Task的异常

还有一处改进是对于异常的捕获上。对于Task中抛出的异常,外部的try catch是无法捕获的。例如:

staticTask<int>f(){try{vart=Task.Factory.StartNew<int>(()=>{thrownewException("xxxxxx");return1;});returnt;}catch{Console.WriteLine("error");}returnnull;}

无论是在.net4.0还是.net4.5,上述代码都是不会走到catch中的。只有当运行Task.Wait或者读取Task.Result的时候(这些方法都会引起阻塞),才会抛出异常,由于运行的Task可能是包含了多个子Task,或者在WaitAll多个Task,那么异常可能会出现多个。Task类会把这些异常包成AggregateException异常。要获得异常的正真信息,需要访问AggregateException.InnerExceptions属性。如下代码:

Task<int>t1=Task.Factory.StartNew<int>(()=>{thrownewException("error1");});Task<int>t2=Task.Factory.StartNew<int>(()=>{thrownewException("error2");});Task<int>t3=Task.Factory.StartNew<int>(()=>{thrownewException("error3");});try{Task.WaitAll(t1,t2,t3);}catch(AggregateExceptionex){Console.WriteLine("ExceptionType:{0}",ex.GetType());Console.WriteLine("ExceptionMessage:{0}",ex.Message);Console.WriteLine("ExceptionStackTrace:{0}",ex.StackTrace);Console.WriteLine("ExceptionInnerException.Message:{0}",ex.InnerException.Message);foreach(varinnerExinex.InnerExceptions){Console.WriteLine("InnerExceptions.Message:{0}",innerEx.Message);}}

Task.WaitAll三个Task,捕获异常的时候,类型为AggregateException,并且可以通过InnerExceptions,遍历出每一个异常。这里值得注意的是,如果AggregateException的InnerExceptions有3个异常的话,AggregateException的InnerException会抛出哪个异常?根据老赵的说法,C#开发团队“故意”不提供文档说明究竟会抛出哪个异常。因为他们并不想做出这方面的约束,因为这部分行为一旦写入文档,便成为一个规定和限制,为了类库的兼容性今后也无法对此做出修改。

上面代码的输出如下:

async/await

在.net 4.5中,c#5.0的语法支持了async/await的写法,这种写法下,可以按照同步的思路写异步方法。而且,异常处理也变得可以直接捕获,在await的时候,代码可以直接捕获异常,例如下面的代码。

staticvoidMain(string[]args){vart=f();Console.ReadKey();}asyncstaticTask<int>f(){intval=0;try{val=awaitTask.Factory.StartNew<int>(()=>{thrownewNotSupportedException("xxxxxx");return1;});}catch(Exceptionex){Console.WriteLine("ExceptionType:{0}",ex.GetType());Console.WriteLine("ExceptionMessage:{0}",ex.Message);Console.WriteLine("ExceptionStackTrace:{0}",ex.StackTrace);}returnval;}

输出如下:

注意,可以看到错误的堆栈信息。从System.Threading.Tasks.Task类切换到了 System.Runtime.CompilerServices.TaskAwaiter。

C# 使用了SynchronizationContext类完成了这个切换。当await一个Task的时候,当前的 SynchronizationContext对象被存储下来。当方法继续向下运行的时候,await关键字的结构使用Post方法,在之前保存的SynchronizationContext类的基础上,继续运行该方法。更多细节不在这里描述。因此只要await关键字的方法上出现了异常,就可以捕获掉,并且捕获的异常类型,就可以不把异常往上层抛,还有一个不同点是await方法捕获的异常类型就是直接的类型,而不是System.AggregateException。

但是如果在await等待是多个Task,并且这多个Task都抛出了异常,那么,最终捕获的异常也会是System.AggregateException类型。并且也可以遍历出所有的异常。和之前的处理同步情况下是一样的。

staticvoidMain(string[]args){vart=f();Console.WriteLine(t.Result);Console.ReadKey();}asyncstaticTask<int>f(){intval=0;Task<int[]>all=null;try{Task<int>t1=Task.Factory.StartNew<int>(()=>{thrownewNotImplementedException("error1");return1;});Task<int>t2=Task.Factory.StartNew<int>(()=>{thrownewNotImplementedException("error2");return2;});Task<int>t3=Task.Factory.StartNew<int>(()=>{thrownewNotImplementedException("error3");return3;});await(all=Task.WhenAll(t1,t2,t3));val=all.Result.Sum();}catch(Exceptionex){Console.WriteLine("ExceptionType:{0}",ex.GetType());Console.WriteLine("ExceptionMessage:{0}",ex.Message);Console.WriteLine("ExceptionStackTrace:{0}",ex.StackTrace);foreach(varinnerExinall.Exception.InnerExceptions){Console.WriteLine("InnerExceptions.Message:{0}",innerEx.Message);}}returnval;}

输出如下:

上述代码中,使用了WhenAll方法,返回的是一个Task类。由于t1,t2,t3中都包含了异常,因此返回的Task中有3个异常,但await关键字只会允许抛出一个具体的异常,因此,此处抛出了第一个异常。通过对all变量的遍历,可以得到所有的异常。


WhenAll 方法

WhenAll方法是.NET4.5中新增的方法。它的返回值是一个Task,仅当所有的Task都完成的时候,返回的这个Task才算完成,并且返回值可以是各个task返回值的一个数组。

因此可以把WhenAll方法看成是一组Task的合并。WhenAll和WaitAll有点类似,但本质上很多不同。

1.调用Task.WaitAll的时候,会阻塞当前线程,直到所有的Task都完成了。而Task.WhenAll方法不会阻塞当前线程,而是直接返回了一个Task,只有在读取这个Task的Result的时候,才会引起阻塞。

2.WaitAll的各类重载方法,它们的返回值是void或者bool,而WhenAll的返回值是Task。因此WhenAll方法更好的支持async/await异步写法。

下面代码演示WhenAll方法:

staticvoidMain(string[]args){Task<int>t1=Task.Factory.StartNew<int>(()=>{Thread.Sleep(1000);return1;});Task<int>t2=Task.Factory.StartNew<int>(()=>{Thread.Sleep(2000);return2;});Task<int>t3=Task.Factory.StartNew<int>(()=>{Thread.Sleep(3000);return3;});varall=Task.WhenAll(t1,t2,t3);while(true){Console.WriteLine("{0}IsCompleted:{1}",DateTime.Now.ToString("HH:mm:ssfff"),all.IsCompleted);Thread.Sleep(200);if(all.IsCompleted)break;}varc=all.Result;Console.WriteLine(c.Sum());}

输出的结果为:

ConfigureAwait方法

ConfigureAwait方法的作用是指定代码在执行await操作的时候,是否捕获上下文,捕获上下文会带来性能开销。不捕获上下文,在ASP.NET或者GUI程序时,可能带来问题。更多的细节可以参考Stephen Cleary 的异步编程中的最佳做法

总之,.NET4.5中的Task的一些改进,都是为了迎合异步async/await的写法而做出的改进。更多参考资料:

http://msdn.microsoft.com/zh-cn/magazine/jj991977.aspx

http://msdn.microsoft.com/zh-cn/magazine/gg598924.aspx

以及Stephen Cleary的blog:http://blog.stephencleary.com/