Globalnie łapiesz wyjątki w aplikacji WPF?

AppDomain.UnhandledException Event

To zdarzenie dostarcza powiadomienia o nieprzewidzianych wyjątkach. Pozwala na aplikacja do logowania informacji o wyjątku przed systemem domyślna obsługa zgłasza wyjątek użytkownikowi i kończy podanie.

   public App()
   {
      AppDomain currentDomain = AppDomain.CurrentDomain;
      currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyHandler);    
   }

   static void MyHandler(object sender, UnhandledExceptionEventArgs args) 
   {
      Exception e = (Exception) args.ExceptionObject;
      Console.WriteLine("MyHandler caught : " + e.Message);
      Console.WriteLine("Runtime terminating: {0}", args.IsTerminating);
   }

Jeśli zdarzenie UnhandledException jest obsługiwane w domyślnej aplikacji domeny, jest tam podniesiona dla każdego nieobsługiwanego wyjątku w dowolnym wątku, bez względu na wszystko domena aplikacji, w której rozpoczął się wątek. Jeśli wątek uruchomiony w domenie aplikacji, która ma obsługę zdarzeń dla UnhandledException, zdarzenie jest wywoływane w tej domenie aplikacji. Jeśli ta domena aplikacji nie jest domeną domyślną aplikacji, oraz istnieje również obsługa zdarzeń w domyślnej domenie aplikacji, zdarzenie jest wywoływane w obu domenach aplikacji.

Na przykład, załóżmy, że wątek rozpoczyna się w domenie aplikacji " AD1", wywołuje metodę w aplikacji domeny "AD2", a stamtąd wywołuje metoda w domenie aplikacji "AD3", gdzie rzuca wyjątek. Na pierwsza domena aplikacji, w której Zdarzenie UnhandledException może być podniesiony jest "AD1". Jeśli ta domena aplikacji nie jest domyślna domeny aplikacji, zdarzenie może być również wywołane w domyślnej domena aplikacji.

Oprócz tego, co inni tu wspominali, zauważ, że łączenie Application.DispatcherUnhandledException (i jego podobieństw ) z

<configuration>
  <runtime>  
    <legacyUnhandledExceptionPolicy enabled="1" />
  </runtime>
</configuration>

W app.config zapobiegnie wyłączeniu aplikacji przez dodatkowy wyjątek wątków.

Przykładowy kod wykorzystujący NLog, który wychwytuje wyjątki wyrzucane z wszystkich wątków w AppDomain , z UI dispatcher thread oraz z async functions :

App.xaml.cs:

public partial class App : Application
{
    private static Logger _logger = LogManager.GetCurrentClassLogger();

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        SetupExceptionHandling();
    }

    private void SetupExceptionHandling()
    {
        AppDomain.CurrentDomain.UnhandledException += (s, e) =>
            LogUnhandledException((Exception)e.ExceptionObject, "AppDomain.CurrentDomain.UnhandledException");

        DispatcherUnhandledException += (s, e) =>
            LogUnhandledException(e.Exception, "Application.Current.DispatcherUnhandledException");

        TaskScheduler.UnobservedTaskException += (s, e) =>
            LogUnhandledException(e.Exception, "TaskScheduler.UnobservedTaskException");
    }

    private void LogUnhandledException(Exception exception, string source)
    {
        string message = $"Unhandled exception ({source})";
        try
        {
            System.Reflection.AssemblyName assemblyName = System.Reflection.Assembly.GetExecutingAssembly().GetName();
            message = string.Format("Unhandled exception in {0} v{1}", assemblyName.Name, assemblyName.Version);
        }
        catch (Exception ex)
        {
            _logger.Error(ex, "Exception in LogUnhandledException");
        }
        finally
        {
            _logger.Error(exception, message);
        }
    }

Oto kompletny przykład użycia NLog

using NLog;
using System;
using System.Windows;

namespace MyApp
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private static Logger logger = LogManager.GetCurrentClassLogger();

        public App()
        {
            var currentDomain = AppDomain.CurrentDomain;
            currentDomain.UnhandledException += CurrentDomain_UnhandledException;
        }

        private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            var ex = (Exception)e.ExceptionObject;
            logger.Error("UnhandledException caught : " + ex.Message);
            logger.Error("UnhandledException StackTrace : " + ex.StackTrace);
            logger.Fatal("Runtime terminating: {0}", e.IsTerminating);
        }        
    }


}

Jak " VB ' s On Error Resume Next?"To brzmi trochę przerażająco. Pierwsza rekomendacja to nie rób tego. Druga rekomendacja to nie rób tego i nie myśl o tym. Musisz lepiej wyizolować swoje wady. Jeśli chodzi o podejście do tego problemu, zależy to od struktury kodu. Jeśli używasz wzorca takiego jak MVC lub tym podobne, to nie powinno to być zbyt trudne i na pewno nie wymagałoby globalnego wyjątku. Po drugie, poszukaj dobrej biblioteki logowania, takiej jak log4net lub użyj namierzam. Musimy wiedzieć więcej szczegółów, takich jak rodzaje WYJĄTKÓW, o których mówisz i jakie części aplikacji mogą skutkować wyrzuceniem WYJĄTKÓW.