为什么AppDomain.CurrentDomain.UnhandledException无法捕获非UI线程的未处理异常？

Question

I've read some other threads and articles suggesting that there is a way to catch unhandled exceptions that originate on non-UI threads. For some reason, this is not working for me. Unhandled UI exceptions are being caught. CurrentDomainUnhandledException never executes even when I test by throwing an exception from within a non-UI thread.

What's weirder is that the exception on the non-UI thread doesn't shut down the application as I thought it would.

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        Application.Current.DispatcherUnhandledException += CurrentDispatcherUnhandledException;

        AppDomain.CurrentDomain.UnhandledException +=
               CurrentDomainUnhandledException;
    }

    void CurrentDispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
    {
        e.Handled = true;
        MessageBox.Show(e.Exception.Message, "Caught an unhandled exception!");
    }

    void CurrentDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
    {
        Exception ex = e.ExceptionObject as Exception;
        MessageBox.Show(ex.Message, "Uncaught Thread Exception",
                        MessageBoxButton.OK, MessageBoxImage.Error);
    }
}

I'm throwing from an event handler that handles devices being plugged in which is definitely not a UI thread. The debugger breaks and shows me a message that the exception is unhandled. However when I continue the application keeps running and appears to keep working. I'm baffled by that.

_devicePlugWatcher = new ManagementEventWatcher(pluggedQueryStr);
_devicePlugWatcher.EventArrived += (DevicePluggedEventReceived);

Answer 1

The AppDomain.CurrentDomain.UnhandledException event handler should be invoked if an exception is thrown on a non-thread pool thread (or non- Task ). Try this for example:

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException;

        Thread thread = new Thread(() => 
        {
            Thread.Sleep(5000);
            throw new Exception("test");
        });
        thread.Start();
    }

    void CurrentDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
    {
        Exception ex = e.ExceptionObject as Exception;
        MessageBox.Show(ex.Message, "Uncaught Thread Exception",
                        MessageBoxButton.OK, MessageBoxImage.Error);
    }
}

And compare it to this where the exception occurs inside a non-observed Task :

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;

        Task.Run(() =>
        {
            throw new Exception("test");
        });

        Loaded += (s, e) => 
        {
            //gc so the unobserved exception "bubbles" up
            GC.Collect(3, GCCollectionMode.Forced, true);
        };
    }

    private void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
    {
        Exception ex = e.Exception;
        MessageBox.Show(ex.Message, "Uncaught Thread Exception",
                        MessageBoxButton.OK, MessageBoxImage.Error);
    }
}

So you should also handle TaskScheduler.UnobservedTaskException .