WPF全局异常处理程序[重复]

Question

有时，在不可重现的情况下，我的 WPF 应用程序在没有任何消息的情况下崩溃。应用程序会立即关闭。

哪里是实现全局 Try/Catch 块的最佳位置。至少我必须实现一个消息框：“抱歉给您带来不便......”

Answer 1

你可以处理AppDomain.UnhandledException事件

编辑：实际上，这个事件可能更合适：Application.DispatcherUnhandledException

Answer 2

您可以在不同级别捕获未处理的异常：

1. AppDomain.CurrentDomain.UnhandledException 来自 AppDomain 中的所有线程。
2. Dispatcher.UnhandledException 来自单个特定的 UI 调度程序线程。
3. Application.Current.DispatcherUnhandledException 来自 WPF 应用程序中的 main UI 调度程序线程。
4. TaskScheduler.UnobservedTaskException 来自每个使用任务调度程序进行异步操作的 AppDomain。

您应该考虑需要在什么级别捕获未处理的异常。

在#2 和#3 之间做出决定取决于您是否使用多个 WPF 线程。这是一个非常奇特的情况，如果您不确定自己是否是，那么您很可能不是。

Answer 3

为了补充 Thomas 的回答，Application 类还具有您可以处理的 DispatcherUnhandledException 事件。

Answer 4

Application.Dispatcher.UnhandledException 的代码示例：

public App() {
    this.Dispatcher.UnhandledException += OnDispatcherUnhandledException;
}

void OnDispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) {
    string errorMessage = string.Format("An unhandled exception occurred: {0}", e.Exception.Message);
    MessageBox.Show(errorMessage, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
    // OR whatever you want like logging etc. MessageBox it's just example
    // for quick debugging etc.
    e.Handled = true;
}

我在 App.xaml.cs 中添加了这段代码

Answer 5

每当发生未处理的异常时，我在我的 WPF 应用程序中使用以下代码来显示“抱歉给您带来的不便”对话框。它显示异常消息，并询问用户是要关闭应用程序还是忽略异常并继续（后一种情况在发生非致命异常并且用户仍然可以正常继续使用应用程序时很方便）。

在 App.xaml 中添加 Startup 事件处理程序：

<Application .... Startup="Application_Startup">

在 App.xaml.cs 代码中添加将注册全局应用程序事件处理程序的 Startup 事件处理程序函数：

using System.Windows.Threading;

private void Application_Startup(object sender, StartupEventArgs e)
{
    // Global exception handling  
    Application.Current.DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(AppDispatcherUnhandledException);    
}

void AppDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
{    
    \#if DEBUG   // In debug mode do not custom-handle the exception, let Visual Studio handle it

    e.Handled = false;

    \#else

    ShowUnhandledException(e);    

    \#endif     
}

void ShowUnhandledException(DispatcherUnhandledExceptionEventArgs e)
{
    e.Handled = true;

    string errorMessage = string.Format("An application error occurred.\nPlease check whether your data is correct and repeat the action. If this error occurs again there seems to be a more serious malfunction in the application, and you better close it.\n\nError: {0}\n\nDo you want to continue?\n(if you click Yes you will continue with your work, if you click No the application will close)",

    e.Exception.Message + (e.Exception.InnerException != null ? "\n" + 
    e.Exception.InnerException.Message : null));

    if (MessageBox.Show(errorMessage, "Application Error", MessageBoxButton.YesNoCancel, MessageBoxImage.Error) == MessageBoxResult.No)   {
        if (MessageBox.Show("WARNING: The application will close. Any changes will not be saved!\nDo you really want to close it?", "Close the application!", MessageBoxButton.YesNoCancel, MessageBoxImage.Warning) == MessageBoxResult.Yes)
    {
        Application.Current.Shutdown();
    } 
}

Answer 6

除了上面的帖子：

Application.Current.DispatcherUnhandledException

不会捕获从主线程以外的线程抛出的异常。您必须在抛出它们的同一线程上捕获这些异常。但是如果你想在你的全局异常处理程序上处理它们，你可以将它传递给主线程：

 System.Threading.Thread t = new System.Threading.Thread(() =>
    {
        try
        {
            ...
            //this exception will not be catched by 
            //Application.DispatcherUnhandledException
            throw new Exception("huh..");
            ...
        }
        catch (Exception ex)
        {
            //But we can handle it in the throwing thread
            //and pass it to the main thread wehre Application.
            //DispatcherUnhandledException can handle it
            System.Windows.Application.Current.Dispatcher.Invoke(
                System.Windows.Threading.DispatcherPriority.Normal,
                new Action<Exception>((exc) =>
                    {
                      throw new Exception("Exception from another Thread", exc);
                    }), ex);
        }
    });

Answer 7

如上所述

Application.Current.DispatcherUnhandledException 不会捕获 从另一个线程然后是主线程抛出的异常。

这实际上取决于线程是如何创建的

Application.Current.DispatcherUnhandledException 未处理的一种情况是 System.Windows.Forms.Timer，Application.ThreadException 可用于处理这些情况 如果您在主线程以外的其他线程上运行 Forms，则需要从每个此类线程设置 Application.ThreadException

Answer 8

完整的解决方案是here

用示例代码很好地解释了它。但是，请注意它不会关闭应用程序。添加该行 Application.Current.Shutdown(); 优雅地关闭应用程序。

Answer 9

最佳答案可能是https://stackoverflow.com/a/1472562/601990。

这里有一些代码说明如何使用它：

App.xaml.cs

public sealed partial class App
{
    protected override void OnStartup(StartupEventArgs e)
    {
        // setting up the Dependency Injection container
        var resolver = ResolverFactory.Get();

        // getting the ILogger or ILog interface
        var logger = resolver.Resolve<ILogger>();
        RegisterGlobalExceptionHandling(logger);

        // Bootstrapping Dependency Injection 
        // injects ViewModel into MainWindow.xaml
        // remember to remove the StartupUri attribute in App.xaml
        var mainWindow = resolver.Resolve<Pages.MainWindow>();
        mainWindow.Show();
    }

    private void RegisterGlobalExceptionHandling(ILogger log)
    {
        // this is the line you really want 
        AppDomain.CurrentDomain.UnhandledException += 
            (sender, args) => CurrentDomainOnUnhandledException(args, log);

        // optional: hooking up some more handlers
        // remember that you need to hook up additional handlers when 
        // logging from other dispatchers, shedulers, or applications

        Application.Dispatcher.UnhandledException += 
            (sender, args) => DispatcherOnUnhandledException(args, log);

        Application.Current.DispatcherUnhandledException +=
            (sender, args) => CurrentOnDispatcherUnhandledException(args, log);

        TaskScheduler.UnobservedTaskException += 
            (sender, args) => TaskSchedulerOnUnobservedTaskException(args, log);
    }

    private static void TaskSchedulerOnUnobservedTaskException(UnobservedTaskExceptionEventArgs args, ILogger log)
    {
        log.Error(args.Exception, args.Exception.Message);
        args.SetObserved();
    }

    private static void CurrentOnDispatcherUnhandledException(DispatcherUnhandledExceptionEventArgs args, ILogger log)
    {
        log.Error(args.Exception, args.Exception.Message);
        // args.Handled = true;
    }

    private static void DispatcherOnUnhandledException(DispatcherUnhandledExceptionEventArgs args, ILogger log)
    {
        log.Error(args.Exception, args.Exception.Message);
        // args.Handled = true;
    }

    private static void CurrentDomainOnUnhandledException(UnhandledExceptionEventArgs args, ILogger log)
    {
        var exception = args.ExceptionObject as Exception;
        var terminatingMessage = args.IsTerminating ? " The application is terminating." : string.Empty;
        var exceptionMessage = exception?.Message ?? "An unmanaged exception occured.";
        var message = string.Concat(exceptionMessage, terminatingMessage);
        log.Error(exception, message);
    }
}