如何捕获/观察从Task抛出的未处理异常

时间:2013-10-03 16:36:50

标签: c# .net wpf exception-handling task-parallel-library

我正在尝试在我的应用中记录/报告所有未处理的异常(错误报告解决方案)。我遇到了一个总是未处理的情景。我想知道如何以未处理的方式捕获此错误。请注意,我今天早上做了很多研究并尝试了很多东西..是的,我见过thisthis等等。我只是在寻找一种通用的解决方案来记录未处理的异常。

我在控制台测试应用程序主要方法中有以下代码:

Task.Factory.StartNew(TryExecute);

Task.Run((Action)TryExecute);

以及以下方法:

private static void TryExecute() {
   throw new Exception("I'm never caught");
}

我已经尝试在我的应用程序中连接到以下内容,但它们永远不会被调用。

AppDomain.CurrentDomain.UnhandledException
TaskScheduler.UnobservedTaskException

在我最初发现此错误的Wpf应用程序中,我也连接到这些事件,但从未调用过。

Dispatcher.UnhandledException
Application.Current.DispatcherUnhandledException
System.Windows.Forms.Application.ThreadException

唯一被称为的处理程序是:

AppDomain.CurrentDomain.FirstChanceException

但这不是一个有效的解决方案,因为我只想报告未捕获的异常(并非每个异常,因为在执行/解析任何catch块之前调用FirstChanceException。

2 个答案:

答案 0 :(得分:20)

如上所述,TaskScheduler.UnobservedTaskException事件应该可以为您提供所需内容。是什么让你觉得它没有被解雇?

在特定情况下,该任务会捕获异常,然后重新抛出,但不会立即重新抛出。任务中的异常会以多种方式重新抛出(在我的脑海中,可能还有更多)。

  1. 当您尝试访问结果(Task.Result
  2. 在任务上调用Wait()Task.WaitOne()Task.WaitAll()或其他相关Wait方法。
  3. 当您尝试在不明确查看或处理异常的情况下处置任务时
  4. 如果您执行上述任何操作,则会在运行代码的任何线程上重新抛出异常,并且不会调用该事件,因为您将观察例外。如果您没有try {} catch {}内的代码,则会触发AppDomain.CurrentDomain.UnhandledException,这听起来就像可能发生的那样。

    重新抛出异常的另一种方式是:

    • 当您不执行上述任何操作时,任务仍然会将异常视为未观察到,并且任务即将完成。它是最后的努力,让你知道有一个你没有看到的例外。

    如果是这种情况,并且由于终结器是非确定性的,您是否正在等待GC发生,以便将那些具有未观察到的异常的任务放入终结器队列中,然后再等待它们最终确定?< / p>

    编辑:This article谈谈这个问题。 And this article讨论了事件存在的原因,这可能会让您深入了解如何正确使用该事件。

答案 1 :(得分:1)

我使用MSDN中的LimitedTaskScheduler来捕获所有异常,包括使用TPL的其他线程:


public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
{
    /// Whether the current thread is processing work items.
    [ThreadStatic]
    private static bool currentThreadIsProcessingItems;

    /// The list of tasks to be executed.
    private readonly LinkedList tasks = new LinkedList(); // protected by lock(tasks)

    private readonly ILogger logger;

    /// The maximum concurrency level allowed by this scheduler.
    private readonly int maxDegreeOfParallelism;

    /// Whether the scheduler is currently processing work items.
    private int delegatesQueuedOrRunning; // protected by lock(tasks)

    public LimitedConcurrencyLevelTaskScheduler(ILogger logger) : this(logger, Environment.ProcessorCount)
    {
    }

    public LimitedConcurrencyLevelTaskScheduler(ILogger logger, int maxDegreeOfParallelism)
    {
        this.logger = logger;

        if (maxDegreeOfParallelism Gets the maximum concurrency level supported by this scheduler.
    public override sealed int MaximumConcurrencyLevel
    {
        get { return maxDegreeOfParallelism; }
    }

    /// Queues a task to the scheduler.
    /// The task to be queued.
    protected sealed override void QueueTask(Task task)
    {
        // Add the task to the list of tasks to be processed.  If there aren't enough
        // delegates currently queued or running to process tasks, schedule another.
        lock (tasks)
        {
            tasks.AddLast(task);

            if (delegatesQueuedOrRunning >= maxDegreeOfParallelism)
            {
                return;
            }

            ++delegatesQueuedOrRunning;

            NotifyThreadPoolOfPendingWork();
        }
    }

    /// Attempts to execute the specified task on the current thread.
    /// The task to be executed.
    /// 
    /// Whether the task could be executed on the current thread.
    protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        // If this thread isn't already processing a task, we don't support inlining
        if (!currentThreadIsProcessingItems)
        {
            return false;
        }

        // If the task was previously queued, remove it from the queue
        if (taskWasPreviouslyQueued)
        {
            TryDequeue(task);
        }

        // Try to run the task.
        return TryExecuteTask(task);
    }

    /// Attempts to remove a previously scheduled task from the scheduler.
    /// The task to be removed.
    /// Whether the task could be found and removed.
    protected sealed override bool TryDequeue(Task task)
    {
        lock (tasks)
        {
            return tasks.Remove(task);
        }
    }

    /// Gets an enumerable of the tasks currently scheduled on this scheduler.
    /// An enumerable of the tasks currently scheduled.
    protected sealed override IEnumerable GetScheduledTasks()
    {
        var lockTaken = false;

        try
        {
            Monitor.TryEnter(tasks, ref lockTaken);

            if (lockTaken)
            {
                return tasks.ToArray();
            }
            else
            {
                throw new NotSupportedException();
            }
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(tasks);
            }
        }
    }

    protected virtual void OnTaskFault(AggregateException exception)
    {
        logger.Error(exception);
    }

    /// 
    /// Informs the ThreadPool that there's work to be executed for this scheduler.
    /// 
    private void NotifyThreadPoolOfPendingWork()
    {
        ThreadPool.UnsafeQueueUserWorkItem(ExcuteTask, null);
    }

    private void ExcuteTask(object state)
    {
        // Note that the current thread is now processing work items.
        // This is necessary to enable inlining of tasks into this thread.
        currentThreadIsProcessingItems = true;

        try
        {
            // Process all available items in the queue.
            while (true)
            {
                Task item;
                lock (tasks)
                {
                    // When there are no more items to be processed,
                    // note that we're done processing, and get out.
                    if (tasks.Count == 0)
                    {
                        --delegatesQueuedOrRunning;
                        break;
                    }

                    // Get the next item from the queue
                    item = tasks.First.Value;
                    tasks.RemoveFirst();
                }

                // Execute the task we pulled out of the queue
                TryExecuteTask(item);

                if (!item.IsFaulted)
                {
                    continue;
                }

                OnTaskFault(item.Exception);
            }
        }
        finally
        {
            // We're done processing items on the current thread
            currentThreadIsProcessingItems = false;
        }
    }
}

而不是使用Reflection:

将TaskScheduler的“注册”作为默认值

public static class TaskLogging
{
    private const BindingFlags StaticBinding = BindingFlags.Static | BindingFlags.NonPublic;

    public static void SetScheduler(TaskScheduler taskScheduler)
    {
        var field = typeof(TaskScheduler).GetField("s_defaultTaskScheduler", StaticBinding);
        field.SetValue(null, taskScheduler);

        SetOnTaskFactory(new TaskFactory(taskScheduler));
    }

    private static void SetOnTaskFactory(TaskFactory taskFactory)
    {
        var field = typeof(Task).GetField("s_factory", StaticBinding);
        field.SetValue(null, taskFactory);
    }
}