.NET Global Exception Handler in der Konsolenanwendung

Frage: Ich möchte einen globalen Ausnahmebehandler für nicht behandelte Ausnahmen in meiner Konsolenanwendung definieren. In asp.net kann man eine in global.asax definieren, und in Windows-Anwendungen / -Diensten kann man wie folgt definieren

AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyExceptionHandler);

Aber wie kann ich einen globalen Ausnahmebehandler für eine Konsolenanwendung definieren?
currentDomain scheint nicht zu funktionieren (.NET 2.0)?

Bearbeiten:

Argh, dummer Fehler.
In VB.NET muss das Schlüsselwort "AddHandler" vor currentDomain hinzugefügt werden, sonst wird das UnhandledException-Ereignis in IntelliSense nicht angezeigt. Dies liegt daran, dass die VB.NET-
und C # -Compiler die Ereignisbehandlung unterschiedlich behandeln.

Nein, das ist der richtige Weg. Dies hat genau so funktioniert, wie es sollte, woraus Sie vielleicht arbeiten können:

using System;

class Program {
    static void Main(string[] args) {
        System.AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
        throw new Exception("Kaboom");
    }

    static void UnhandledExceptionTrapper(object sender, UnhandledExceptionEventArgs e) {
        Console.WriteLine(e.ExceptionObject.ToString());
        Console.WriteLine("Press Enter to continue");
        Console.ReadLine();
        Environment.Exit(1);
    }
}

Beachten Sie, dass Sie auf diese Weise keine vom Jitter generierten Ausnahmen beim Laden von Typen und Dateien abfangen können. Sie treten auf, bevor Ihre Main () -Methode ausgeführt wird. Um diese abzufangen, muss der Jitter verzögert, der riskante Code in eine andere Methode verschoben und das Attribut [MethodImpl (MethodImplOptions.NoInlining)] darauf angewendet werden.

Wenn Sie eine Single-Threaded-Anwendung haben, können Sie einen einfachen Versuch / Fang in der Hauptfunktion verwenden. Dies gilt jedoch nicht für Ausnahmen, die außerhalb der Hauptfunktion ausgelöst werden können, z. B. in anderen Threads (wie in anderen angegeben) Bemerkungen). Dieser Code zeigt, wie eine Ausnahme dazu führen kann, dass die Anwendung beendet wird, obwohl Sie versucht haben, sie in Main zu behandeln (beachten Sie, wie das Programm ordnungsgemäß beendet wird, wenn Sie die Eingabetaste drücken und die Anwendung ordnungsgemäß beenden, bevor die Ausnahme auftritt, aber wenn Sie sie ausführen lassen , es endet ziemlich unglücklich):

static bool exiting = false;

static void Main(string[] args)
{
   try
   {
      System.Threading.Thread demo = new System.Threading.Thread(DemoThread);
      demo.Start();
      Console.ReadLine();
      exiting = true;
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception");
   }
}

static void DemoThread()
{
   for(int i = 5; i >= 0; i--)
   {
      Console.Write("24/{0} =", i);
      Console.Out.Flush();
      Console.WriteLine("{0}", 24 / i);
      System.Threading.Thread.Sleep(1000);
      if (exiting) return;
   }
}

Sie können eine Benachrichtigung erhalten, wenn ein anderer Thread eine Ausnahme auslöst, um eine Bereinigung durchzuführen, bevor die Anwendung beendet wird. Soweit ich jedoch feststellen kann, können Sie von einer Konsolenanwendung aus die Ausführung der Anwendung nicht erzwingen, wenn Sie die Ausnahme nicht behandeln auf dem Thread, von dem es geworfen wird, ohne einige obskure Kompatibilitätsoptionen zu verwenden, damit sich die Anwendung so verhält, wie es mit .NET 1.x der Fall wäre. Dieser Code zeigt, wie der Hauptthread über Ausnahmen von anderen Threads benachrichtigt werden kann, aber dennoch unglücklich beendet wird:

static bool exiting = false;

static void Main(string[] args)
{
   try
   {
      System.Threading.Thread demo = new System.Threading.Thread(DemoThread);
      AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
      demo.Start();
      Console.ReadLine();
      exiting = true;
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception");
   }
}

static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
   Console.WriteLine("Notified of a thread exception... application is terminating.");
}

static void DemoThread()
{
   for(int i = 5; i >= 0; i--)
   {
      Console.Write("24/{0} =", i);
      Console.Out.Flush();
      Console.WriteLine("{0}", 24 / i);
      System.Threading.Thread.Sleep(1000);
      if (exiting) return;
   }
}

Meiner Meinung nach besteht die sauberste Möglichkeit, in einer Konsolenanwendung damit umzugehen, darin, sicherzustellen, dass jeder Thread einen Ausnahmehandler auf Stammebene hat:

static bool exiting = false;

static void Main(string[] args)
{
   try
   {
      System.Threading.Thread demo = new System.Threading.Thread(DemoThread);
      demo.Start();
      Console.ReadLine();
      exiting = true;
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception");
   }
}

static void DemoThread()
{
   try
   {
      for (int i = 5; i >= 0; i--)
      {
         Console.Write("24/{0} =", i);
         Console.Out.Flush();
         Console.WriteLine("{0}", 24 / i);
         System.Threading.Thread.Sleep(1000);
         if (exiting) return;
      }
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception on the other thread");
   }
}

Sie müssen auch Ausnahmen von Threads behandeln:

static void Main(string[] args) {
Application.ThreadException += MYThreadHandler;
}

private void MYThreadHandler(object sender, Threading.ThreadExceptionEventArgs e)
{
    Console.WriteLine(e.Exception.StackTrace);
}

Tut mir leid, das war für Winforms, für alle Threads, die Sie in einer Konsolenanwendung verwenden, müssen Sie einen Try / Catch-Block einschließen. Hintergrundthreads, bei denen nicht behandelte Ausnahmen auftreten, führen nicht zum Beenden der Anwendung.

Ich habe gerade eine alte VB.NET-Konsolenanwendung geerbt und musste einen Global Exception Handler einrichten. Da diese Frage VB.NET einige Male erwähnt und mit VB.NET markiert ist, aber alle anderen Antworten hier in C # sind, dachte ich, ich würde die genaue Syntax auch für eine VB.NET-Anwendung hinzufügen.

Public Sub Main()
    REM Set up Global Unhandled Exception Handler.
    AddHandler System.AppDomain.CurrentDomain.UnhandledException, AddressOf MyUnhandledExceptionEvent

    REM Do other stuff
End Sub

Public Sub MyUnhandledExceptionEvent(ByVal sender As Object, ByVal e As UnhandledExceptionEventArgs)
    REM Log Exception here and do whatever else is needed
End Sub

Ich habe hier den REMKommentar-Marker anstelle des einfachen Anführungszeichens verwendet, da Stack Overflow die Syntax-Hervorhebung etwas besser zu handhaben schien REM.

Was Sie versuchen, sollte gemäß den MSDN-Dokumenten für .Net 2.0 funktionieren. Sie können auch versuchen, direkt in der Nähe Ihres Einstiegspunkts für die Konsolen-App zu versuchen / zu fangen.

static void Main(string[] args)
{
    try
    {
        // Start Working
    }
    catch (Exception ex)
    {
        // Output/Log Exception
    }
    finally
    {
        // Clean Up If Needed
    }
}

Und jetzt behandelt Ihr Fang alles, was nicht gefangen wurde ( im Haupt-Thread ). Es kann elegant sein und sogar neu starten, wo es war, wenn Sie möchten, oder Sie können die App einfach sterben lassen und die Ausnahme protokollieren. Sie würden endlich eine hinzufügen, wenn Sie aufräumen wollten. Jeder Thread erfordert eine eigene Ausnahmebehandlung auf hoher Ebene, ähnlich der Hauptthread.

Bearbeitet, um den Punkt über Threads zu verdeutlichen, auf den BlueMonkMN hingewiesen und in seiner Antwort ausführlich gezeigt hat.