Gestore di eccezioni globali WPF

Question

A volte, in circostanze non riproducibili, l'applicazione WPF si arresta in modo anomalo senza alcun messaggio. L'applicazione si chiude semplicemente all'istante.

Dove è il posto migliore per implementare il blocco Try/Catch globale. Almeno ho implementare un messagebox con: "Ci scusiamo per l'inconveniente ..."

Answer 1

È possibile gestire l'evento AppDomain.UnhandledException

EDIT: In realtà, questo evento è probabilmente più adeguata: Application.DispatcherUnhandledException

Answer 2

È può intercettare le eccezioni non gestite a diversi livelli:

1. AppDomain.CurrentDomain.UnhandledException Da tutte le discussioni in AppDomain.
2. Dispatcher.UnhandledException Da una singola stringa del dispatcher dell'interfaccia utente specifica.
3. Application.Current.DispatcherUnhandledException Dal principale thread di dispacciamento UI nell'applicazione WPF.
4. TaskScheduler.UnobservedTaskException dall'interno di ogni AppDomain che utilizza uno schedulatore di attività per operazioni asincrone.

È necessario considerare il livello necessario per intercettare le eccezioni non gestite su.

La decisione tra 2 e 3 dipende dall'utilizzo di più thread WPF. Questa è una situazione piuttosto esotica e se non sei sicuro che lo sei o meno, allora è molto probabile che tu non lo sia.

Answer 3

Per completare la risposta di Thomas, la classe Application ha anche l'evento DispatcherUnhandledException che è possibile gestire.

Answer 4

un rapido esempio di codice per Application.Dispatcher.UnhandledException:

public App() :base() { 
     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); 
     e.Handled = true; 
    } 

ho aggiunto questo codice in App.xaml.cs

Answer 5

Io uso il seguente codice nel mio applicazioni WPF per mostrare una " Scusa per l'inconveniente "finestra di dialogo ogni volta che si verifica un'eccezione non gestita. Mostra il messaggio di eccezione e chiede all'utente se desidera chiudere l'app o ignorare l'eccezione e continuare (quest'ultimo caso è utile quando si verificano eccezioni non fatali e l'utente può continuare a utilizzare l'app).

Nel App.xaml aggiungere il gestore di eventi di avvio:

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

Nel codice App.xaml.cs aggiungere la funzione del gestore di eventi di avvio che registrerà il gestore di eventi di applicazione globale:

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

In Oltre ai post sopra:

Application.Current.DispatcherUnhandledException 

non rileverà eccezioni che vengono lanciate da un altro er thread quindi il thread principale. Devi gestire queste eccezioni sulla sua discussione effettiva.Ma se si desidera gestire sul vostro gestore eccezioni globale si può passare al thread principale:

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

Come accennato in precedenza

Application.Current.DispatcherUnhandledException non prenderà eccezioni generate da un altro thread quindi il thread principale.

Tale effettivo dipenderà da come il filo è stato creato

Un caso che non viene gestito dal Application.Current.DispatcherUnhandledException è System.Windows.Forms.Timer che Application.ThreadException può essere utilizzato per gestire questi se si esegue moduli su altri thread rispetto al filo principale sarà necessario impostare Application.ThreadException da ogni tale filo

Answer 8

Una soluzione completa è here

è spiegato molto bello con codice di esempio. Tuttavia, fai attenzione a non chiudere l'applicazione. Aggiungi la riga Application.Current.Shutdown(); per chiudere con garbo l'app.

Answer 9

La risposta migliore è probabilmente https://stackoverflow.com/a/1472562/601990.

Ecco alcuni codice che mostra come usarlo:

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