Coder Perfect

[duplicate] WPF global exception handler


My WPF program will occasionally crash without warning under unusual conditions. The application simply shuts down.

Where should the global Try/Catch block be implemented? At the very least, I’ll have to include a messagebox that says “Sorry for the inconvenience…”

Asked by Scott Olson

Solution #1

You can trap unhandled exceptions at different levels:

You should think about the level at which you need to catch unhandled exceptions.

If you’re utilizing more than one WPF thread, you’ll have to choose between #2 and #3. This is a unique position, and if you’re not sure whether you’re in it or not, you probably aren’t.

Answered by Drew Noakes

Solution #2

You are in charge of the AppDomain. UnhandledException is an unhandled exception.

EDIT: This event is probably more appropriate: Application. DispatcherUnhandledException

Answered by Thomas Levesque

Solution #3

A simple code sample for 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;

I added this code in App.xaml.cs

Answered by Sergey

Solution #4

When an unhandled exception occurs in my WPF programs, I use the following code to display a “Sorry for the inconvenience” dialog box. It displays the exception message and asks the user whether they want to exit the app or continue despite the error (the latter case is convenient when a non-fatal exceptions occur and user can still normally continue to use the app).

Add the Startup event handler to App.xaml:

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

Add the Startup event handler function to the App.xaml.cs code to register the global application event handler:

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;




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)

Answered by jurev

Solution #5

Probably the best solution is

Here’s some code to demonstrate how to utilise it:


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>();

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

    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);

    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);

Answered by MovGP0

Post is based on