您的位置: 首页  >  文章  >  Task类在.NET4.5中的一些改进

Task类在.NET4.5中的一些改进

分类: 文章 • 2025-02-03 21:31:34

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

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

ThrowUnobservedTaskExceptions节点

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

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

<configuration>
    <runtime>
      <ThrowUnobservedTaskExceptions enabled="false"/>
    </runtime>
</configuration>

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void Main(string[] args)
{
      for (int i = 0; i < 10; i++)
      {
           var t = Task.Factory.StartNew<int>(() => { throw new Exception("xxxxxx"); return 1; }
                        , CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }
      while (true)
     {
           GC.Collect();
           Thread.Sleep(1000);
      }
      Console.ReadKey();
}

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

Task类在.NET4.5中的一些改进

Task类在.NET4.5中的一些改进

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

代码如下：

1
2
3
4
5
6
TaskScheduler.UnobservedTaskException += (o, ev) =>
{
      Console.WriteLine(ev.Exception);
      ev.SetObserved();
      Console.WriteLine("---------");
};

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

 

.NET4.0中Task的异常

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

1
2
3
4
5
6
7
8
9
10
11
12
13
static Task<int> f()
{
try
{
  var t = Task.Factory.StartNew<int>(() => { throw new Exception("xxxxxx"); return 1; });
  return t;
}
catch
{
  Console.WriteLine("error");
}
return null;
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Task<int> t1 = Task.Factory.StartNew<int>(() =>
  {
   throw new Exception("error1");
  });
Task<int> t2 = Task.Factory.StartNew<int>(() =>
{
throw new Exception("error2");
});
Task<int> t3 = Task.Factory.StartNew<int>(() =>
{
throw new Exception("error3");
});
try
{
Task.WaitAll(t1,t2,t3);
}
catch (AggregateException ex)
{
Console.WriteLine("Exception Type:{0}", ex.GetType());
Console.WriteLine("Exception Message:{0}", ex.Message);
Console.WriteLine("Exception StackTrace:{0}", ex.StackTrace);
Console.WriteLine("Exception InnerException.Message:{0}", ex.InnerException.Message);
foreach (var innerEx in ex.InnerExceptions)
{
  Console.WriteLine("InnerExceptions.Message:{0}", innerEx.Message);
}
}

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

上面代码的输出如下：

Task类在.NET4.5中的一些改进Task类在.NET4.5中的一些改进

 

async/await

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static void Main(string[] args)
{
    var t = f();
    Console.ReadKey();
}
async static Task<int> f()
{
    int val = 0;
    try
    {
        val = await Task.Factory.StartNew<int>(() => { throw new NotSupportedException("xxxxxx"); return 1; });
    }
    catch (Exception ex)
    {
        Console.WriteLine("Exception Type:{0}", ex.GetType());
        Console.WriteLine("Exception Message:{0}", ex.Message);
        Console.WriteLine("Exception StackTrace:{0}", ex.StackTrace);
    }
    return val;
}

输出如下：

Task类在.NET4.5中的一些改进Task类在.NET4.5中的一些改进

注意，可以看到错误的堆栈信息。从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类型。并且也可以遍历出所有的异常。和之前的处理同步情况下是一样的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
static void Main(string[] args)
{
var t = f();
Console.WriteLine(t.Result);
Console.ReadKey();
}
async static Task<int> f()
{
int val = 0;
Task<int[]> all = null;
try
{
  Task<int> t1 = Task.Factory.StartNew<int>(() =>
  {
   throw new NotImplementedException("error1");
   return 1;
  });
  Task<int> t2 = Task.Factory.StartNew<int>(() =>
  {
   throw new NotImplementedException("error2");
   return 2;
  });
  Task<int> t3 = Task.Factory.StartNew<int>(() =>
  {
   throw new NotImplementedException("error3");
   return 3;
  });
await (all = Task.WhenAll(t1, t2, t3));
  val = all.Result.Sum();
}
catch (Exception ex)
{
  Console.WriteLine("Exception Type:{0}", ex.GetType());
  Console.WriteLine("Exception Message:{0}", ex.Message);
  Console.WriteLine("Exception StackTrace:{0}", ex.StackTrace);
  foreach (var innerEx in all.Exception.InnerExceptions)
  {
   Console.WriteLine("InnerExceptions.Message:{0}", innerEx.Message);
  }
}
return val;
}

输出如下：

Task类在.NET4.5中的一些改进Task类在.NET4.5中的一些改进

上述代码中，使用了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方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
static void Main(string[] args)
{
Task<int> t1 = Task.Factory.StartNew<int>(() =>
{
  Thread.Sleep(1000);
  return 1;
});
Task<int> t2 = Task.Factory.StartNew<int>(() =>
{
  Thread.Sleep(2000);
  return 2;
});
Task<int> t3 = Task.Factory.StartNew<int>(() =>
{
  Thread.Sleep(3000);
  return 3;
});
var all = Task.WhenAll(t1, t2, t3);
while (true)
{
  Console.WriteLine("{0} IsCompleted:{1}", DateTime.Now.ToString("HH:mm:ss fff"), all.IsCompleted);
  Thread.Sleep(200);
  if (all.IsCompleted)
   break;
}
var c = all.Result;
Console.WriteLine(c.Sum());
}

输出的结果为：

Task类在.NET4.5中的一些改进Task类在.NET4.5中的一些改进

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/


















本文转自cnn23711151CTO博客，原文链接：http://blog.51cto.com/cnn237111/1542703 ，如需转载请自行联系原作者






相关推荐