c# - system.threading.task - 为什么不发生 TaskScheduler.UnobservedTaskException 事件？我可以解决这个问题吗？

Question

我见过的一个常见问题是管理任务中未处理的异常。它们不会导致崩溃，它们会悄无声息地发生，当任务失败时我什至无法触发事件!我看到用户规定了自定义类和东西来处理这个问题，我的问题是，是否有一种“标准”的 Microsoft 方法来处理这个问题？

为了举例，我制作了这个简单的控制台应用程序 (.NET 4.5.1) 来演示问题。是否可以修改为异步执行这些任务，但遇到未处理的异常时调用“处理程序”？或者至少崩溃？我认为这正是 UnobservedTaskException 应该做的。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication4
{
class Program
{
    static void Main(string[] args)
    {
        TaskScheduler.UnobservedTaskException += Handler;
        AppDomain.CurrentDomain.UnhandledException += Handler;
        Task.Run(() => { throw new ApplicationException("I'll throw an unhandled exception"); });
        Task.Factory.StartNew(() => { throw new ApplicationException("I'll throw an unhandled exception too"); });
        System.Threading.Thread.Sleep(2000);
        Console.WriteLine("I think everything is just peachy!");
        System.Threading.Thread.Sleep(10000);
    }
    private static void Handler(Object sender, EventArgs e)
    {
        Console.WriteLine("I'm so lonely, won't anyone call me?");
    }
}
}

输出:

I think everything is just peachy!

期望的输出:

I'm so lonely, won't anyone call me?
I'm so lonely, won't anyone call me?
I think everything is just peachy!

和/或只是崩溃，即使这样也会比异步任务静默失败带来巨大的改进!

编辑:根据这篇 MSDN 文章 http://msdn.microsoft.com/en-us/library/jj160346%28v=vs.110%29.aspx 将其添加到 app.config ，但没有变化:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <runtime>
    <ThrowUnobservedTaskExceptions enabled="true"/>
  </runtime>
</configuration>

Answer 1

来自评论:

I can see that there is a reason for everything, but I can't deny being flabbergasted by the idea that there's a good reason that this should not happen by design. What if I don't want to await a Task, should I just never use the Task class in that case? What's the drawback to this having an event that can be subscribed to? I'm going to write an extension method, and by all means, tell me why it shouldn't be this way

Task 对象的本质是它是在未来完成的事情。任务的结果或异常也有望在未来被观察到，很可能在不同的堆栈框架甚至不同的线程上。这就是为什么框架(或编译器生成的代码，用于 async Task 方法)将异常存储在任务中并且不会立即抛出它。

您不会在此处观察任务的结果，甚至不会在任何地方存储对任务对象的引用。本质上，您是在进行即发即弃的调用。编译器对此发出警告(告诉任务未等待)，但它并没有消除托管 Task 对象仍然被创建并一直存在直到被垃圾收集的事实。届时，将触发 TaskScheduler.UnobservedTaskException 事件。

... there's a good reason that should not happen by design

如果上述方法是一个糟糕的设计，那么什么才是好的呢？如果立即抛出异常，下面的方法怎么可能起作用:

var task = Task.Run(() => {
    throw new ApplicationException("I'll throw an unhanded exception"); });
Thread.Sleep(1000);
if (task.IsFaulted)
  Console.WriteLine(task.Exception.InnerException.Message);

它根本做不到。 Sleep 之后的代码将没有机会按照自己的方式处理异常。因此，当前的行为是经过深思熟虑的，非常有道理。

如果您仍然希望在发生即发即弃任务时立即观察到异常，请使用帮助程序 async void 方法:

public static class TaskExt
{
    public static async void Observe(
        this Task @this,
        bool continueOnCapturedContext = true)
    {
        await @this.ConfigureAwait(continueOnCapturedContext);
    } 
}

static void Main(string[] args)
{
    TaskScheduler.UnobservedTaskException += Handler;
    AppDomain.CurrentDomain.UnhandledException += Handler;

    Task.Run(() => { throw new ApplicationException("I'll throw an unhanded exception"); })
        .Observe();

    Task.Factory.StartNew(() => { throw new ApplicationException("I'll throw an unhanded exception too"); })
        .Observe();

    System.Threading.Thread.Sleep(2000);
    Console.WriteLine("I think everything is just peachy!");
    System.Threading.Thread.Sleep(10000);
}

您还可以使用 async void lambda 进行即发即弃调用:

Action fireAndForget = async () => 
{ 
    try 
    {
        await Task.Run(...); 
    }
    catch(e) { /* handle errors */ };
};
fireAndForget();

我描述了async void 方法的异常传播行为 in more details here .

OK, I get what you're saying. By design, are tasks meant to be never used with a fire and forget pattern? Just dispatch the work to an anonymous thread some other way?

我并不是说任务不适用于即发即弃模式。我实际上认为他们非常适合这样做。有一些选项可以通过任务实现这种模式，我在上面展示了一个，另一个是 Task.ContinueWith，或者您可以查看 this question。更多想法。

一个不同的问题是，我很难想象一个有用的场景，我不会不想观察任务的完成状态，即使是像上面那样的即发即弃调用。这样的任务会做什么工作？即使是日志记录，我仍然想确保日志条目已成功写入。另外，如果父进程在任务完成之前就结束了怎么办？根据我的经验，我总是使用类似 QueueAsync 的东西。跟踪被解雇的任务。