AppDomain.UnhandledException Ereignis

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Tritt auf, wenn eine Ausnahme nicht abgefangen wird.

public:
 event UnhandledExceptionEventHandler ^ UnhandledException;

public event UnhandledExceptionEventHandler? UnhandledException;

member this.UnhandledException : UnhandledExceptionEventHandler 

Public Custom Event UnhandledException As UnhandledExceptionEventHandler 

Ereignistyp

UnhandledExceptionEventHandler

Beispiele

Das folgende Beispiel veranschaulicht das UnhandledException Ereignis. Er definiert einen Ereignishandler , der aufgerufen wird, MyHandlerwenn eine nicht behandelte Ausnahme in der Standardanwendungsdomäne ausgelöst wird. Anschließend werden zwei Ausnahmen ausgelöst. Die erste wird von einem Try/Catch-Block verarbeitet. Die zweite wird nicht behandelt und ruft die MyHandle Routine auf, bevor die Anwendung beendet wird.

// The example should be compiled with the /clr:pure compiler option.
using namespace System;
using namespace System::Security::Permissions;

public ref class Example
{


private:
   static void MyHandler(Object^ sender, UnhandledExceptionEventArgs^ args)
   {
      Exception^ e = dynamic_cast<Exception^>(args->ExceptionObject);
      Console::WriteLine( "MyHandler caught : {0}", e->Message );
      Console::WriteLine("Runtime terminating: {0}", args->IsTerminating);
   }
   
public: 
   [SecurityPermissionAttribute( SecurityAction::Demand, ControlAppDomain = true )]
   static void Main()
   {
      AppDomain^ currentDomain = AppDomain::CurrentDomain;
      currentDomain->UnhandledException += gcnew UnhandledExceptionEventHandler(Example::MyHandler);
      try
      {
         throw gcnew Exception("1");
      }
      catch (Exception^ e) 
      {
         Console::WriteLine( "Catch clause caught : {0}\n", e->Message );
      }

      throw gcnew Exception("2");
   }
};

void main()
{
   Example::Main();
}   
// The example displays the following output:
//       Catch clause caught : 1
//       
//       MyHandler caught : 2
//       Runtime terminating: True
//       
//       Unhandled Exception: System.Exception: 2
//          at Example.Main()
//          at mainCRTStartup(String[] arguments)

using System;

public class Example
{
   public static void Main()
   {
      AppDomain currentDomain = AppDomain.CurrentDomain;
      currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyHandler);

      try {
         throw new Exception("1");
      } catch (Exception e) {
         Console.WriteLine("Catch clause caught : {0} \n", e.Message);
      }

      throw new Exception("2");
   }

   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);
   }
}
// The example displays the following output:
//       Catch clause caught : 1
//
//       MyHandler caught : 2
//       Runtime terminating: True
//
//       Unhandled Exception: System.Exception: 2
//          at Example.Main()

open System
open System.Security.Permissions

let myHandler _ (args: UnhandledExceptionEventArgs) =
    let e = args.ExceptionObject :?> Exception
    printfn $"MyHandler caught : {e.Message}"
    printfn $"Runtime terminating: {args.IsTerminating}"

[<EntryPoint>]
let main _ =
    let currentDomain = AppDomain.CurrentDomain
    currentDomain.UnhandledException.AddHandler(UnhandledExceptionEventHandler myHandler)

    try
        failwith "1"
    with e ->
        printfn $"Catch clause caught : {e.Message} \n"

    failwith "2"

// The example displays the following output:
//       Catch clause caught : 1
//
//       MyHandler caught : 2
//       Runtime terminating: True
//
//       Unhandled Exception: System.Exception: 2
//          at Example.main()

Module Example
   Sub Main()
      Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      AddHandler currentDomain.UnhandledException, AddressOf MyHandler
      
      Try
         Throw New Exception("1")
      Catch e As Exception
         Console.WriteLine("Catch clause caught : " + e.Message)
         Console.WriteLine()
      End Try
      
      Throw New Exception("2")
   End Sub
   
   Sub MyHandler(sender As Object, args As UnhandledExceptionEventArgs)
      Dim e As Exception = DirectCast(args.ExceptionObject, Exception)
      Console.WriteLine("MyHandler caught : " + e.Message)
      Console.WriteLine("Runtime terminating: {0}", args.IsTerminating)
   End Sub
End Module
' The example displays the following output:
'       Catch clause caught : 1
'       
'       MyHandler caught : 2
'       Runtime terminating: True
'       
'       Unhandled Exception: System.Exception: 2
'          at Example.Main()

Hinweise

Dieses Ereignis stellt Benachrichtigungen über nicht beendete Ausnahmen bereit. Es ermöglicht der Anwendung, Informationen über die Ausnahme zu protokollieren, bevor der Systemstandardhandler die Ausnahme an den Benutzer meldet und die Anwendung beendet. Wenn ausreichende Informationen über den Status der Anwendung verfügbar sind, können andere Maßnahmen ergriffen werden , z. B. das Speichern von Programmdaten für eine spätere Wiederherstellung. Es ist Vorsicht geboten, da Programmdaten beschädigt werden können, wenn Ausnahmen nicht behandelt werden.

Hinweis

In den .NET Framework Versionen 1.0 und 1.1 werden die Optionen zum Beenden und Debuggen der Anwendung an den Benutzer gemeldet, bevor dieses Ereignis ausgelöst wird, anstatt danach.

Dieses Ereignis kann in jeder Anwendungsdomäne behandelt werden. Das Ereignis wird jedoch nicht unbedingt in der Anwendungsdomäne ausgelöst, in der die Ausnahme aufgetreten ist. Eine Ausnahme wird nur dann nicht behandelt, wenn der gesamte Stapel für den Thread aufgehoben wurde, ohne einen entsprechenden Ausnahmehandler zu finden, sodass der erste Ort, an dem das Ereignis ausgelöst werden kann, in der Anwendungsdomäne liegt, aus der der Thread stammt.

Hinweis

In den .NET Framework Versionen 1.0 und 1.1 tritt dieses Ereignis nur für die Standardanwendungsdomäne auf, die vom System beim Starten einer Anwendung erstellt wird. Wenn eine Anwendung zusätzliche Anwendungsdomänen erstellt, hat die Angabe eines Delegaten für dieses Ereignis in diesen Anwendungsdomänen keine Auswirkungen.

Wenn das UnhandledException Ereignis in der Standardanwendungsdomäne behandelt wird, wird es dort für jede nicht behandelte Ausnahme in einem beliebigen Thread ausgelöst, unabhängig davon, in welcher Anwendungsdomäne der Thread gestartet wurde. Wenn der Thread in einer Anwendungsdomäne gestartet wurde, die über einen Ereignishandler für UnhandledExceptionverfügt, wird das -Ereignis in dieser Anwendungsdomäne ausgelöst. Wenn diese Anwendungsdomäne nicht die Standardanwendungsdomäne ist und es auch einen Ereignishandler in der Standardanwendungsdomäne gibt, wird das Ereignis in beiden Anwendungsdomänen ausgelöst.

Angenommen, ein Thread beginnt in der Anwendungsdomäne "AD1", ruft eine Methode in der Anwendungsdomäne "AD2" auf und ruft von dort eine Methode in der Anwendungsdomäne "AD3" auf, wo eine Ausnahme ausgelöst wird. Die erste Anwendungsdomäne, in der das UnhandledException Ereignis ausgelöst werden kann, ist "AD1". Wenn diese Anwendungsdomäne nicht die Standardanwendungsdomäne ist, kann das Ereignis auch in der Standardanwendungsdomäne ausgelöst werden.

Hinweis

Die Common Language Runtime hält Threadabbrüche an, während Ereignishandler für das UnhandledException Ereignis ausgeführt werden.

Wenn der Ereignishandler über ein ReliabilityContractAttribute Attribut mit den entsprechenden Flags verfügt, wird der Ereignishandler als eingeschränkter Ausführungsbereich behandelt.

Ab dem .NET Framework 4 wird dieses Ereignis nicht für Ausnahmen ausgelöst, die den Status des Prozesses beschädigen, z. B. Stapelüberläufe oder Zugriffsverletzungen, es sei denn, der Ereignishandler ist sicherheitskritisch und verfügt über das HandleProcessCorruptedStateExceptionsAttribute -Attribut.

In den .NET Framework Versionen 1.0 und 1.1 wird eine nicht behandelte Ausnahme, die in einem anderen Thread als dem Standard-Anwendungsthreads auftritt, von der Runtime abgefangen und führt daher nicht zum Beenden der Anwendung. Daher ist es möglich, dass das UnhandledException Ereignis ausgelöst wird, ohne dass die Anwendung beendet wird. Ab der .NET Framework Version 2.0 wurde dieser Backstop für nicht behandelte Ausnahmen in untergeordneten Threads entfernt, da die kumulative Auswirkung solcher stillen Fehler Leistungseinbußen, beschädigte Daten und Sperren umfasste, die alle nur schwer zu debuggen waren. Weitere Informationen, einschließlich einer Liste von Fällen, in denen die Runtime nicht beendet wird, finden Sie unter Ausnahmen in verwalteten Threads.

Um einen Ereignishandler für dieses Ereignis zu registrieren, müssen Sie über die erforderlichen Berechtigungen verfügen, oder ein SecurityException wird ausgelöst.

Weitere Informationen zur Behandlung von Ereignissen finden Sie unter behandeln und Auslösen von Ereignissen.

Andere Ereignisse für nicht behandelte Ausnahmen

Bei bestimmten Anwendungsmodellen kann das UnhandledException Ereignis durch andere Ereignisse vorbelastet werden, wenn die nicht behandelte Ausnahme im Standard Anwendungsthreads auftritt.

In Anwendungen, die Windows Forms verwenden, führen nicht behandelte Ausnahmen im Standard Anwendungsthreads dazu, dass das Application.ThreadException Ereignis ausgelöst wird. Wenn dieses Ereignis behandelt wird, ist das Standardverhalten, dass die nicht behandelte Ausnahme die Anwendung nicht beendet, obwohl die Anwendung in einem unbekannten Zustand verbleibt. In diesem Fall wird das UnhandledException Ereignis nicht ausgelöst. Dieses Verhalten kann mithilfe der Anwendungskonfigurationsdatei oder mithilfe der Application.SetUnhandledExceptionMode -Methode geändert werden, um den Modus in zu UnhandledExceptionMode.ThrowException ändern, bevor der ThreadException Ereignishandler eingebunden wird. Dies gilt nur für den Standard Anwendungsthreads. Das UnhandledException Ereignis wird für unbehandelte Ausnahmen ausgelöst, die in anderen Threads ausgelöst werden.

Ab Microsoft Visual Studio 2005 stellt das Visual Basic-Anwendungsframework ein weiteres Ereignis für nicht behandelte Ausnahmen im Standard-Anwendungsthreads bereit. Sehen Sie sich das Ereignis an WindowsFormsApplicationBase.UnhandledException . Dieses Ereignis verfügt über ein Ereignisargumentobjekt mit demselben Namen wie das von AppDomain.UnhandledExceptionverwendete Ereignisargumentobjekt, aber mit unterschiedlichen Eigenschaften. Insbesondere verfügt dieses Ereignisargumentobjekt über eine ExitApplication Eigenschaft, die es der Anwendung ermöglicht, die Ausführung fortzusetzen, die nicht behandelte Ausnahme zu ignorieren (und die Anwendung in einem unbekannten Zustand zu belassen). In diesem Fall wird das AppDomain.UnhandledException Ereignis nicht ausgelöst.