AppDomain.UnhandledException Ereignis

Definition

Tritt auf, wenn eine Ausnahme nicht abgefangen wird.

public:
 event UnhandledExceptionEventHandler ^ UnhandledException;
public:
 virtual event UnhandledExceptionEventHandler ^ UnhandledException;
public event UnhandledExceptionEventHandler? UnhandledException;
public event UnhandledExceptionEventHandler UnhandledException;
[add: System.Security.SecurityCritical]
[remove: System.Security.SecurityCritical]
public event UnhandledExceptionEventHandler UnhandledException;
member this.UnhandledException : UnhandledExceptionEventHandler 
[<add: System.Security.SecurityCritical>]
[<remove: System.Security.SecurityCritical>]
member this.UnhandledException : UnhandledExceptionEventHandler 
Public Custom Event UnhandledException As UnhandledExceptionEventHandler 

Ereignistyp

UnhandledExceptionEventHandler

Implementiert

Attribute

Beispiele

Im folgenden Beispiel wird das UnhandledException Ereignis veranschaulicht. 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. Der erste wird von einem Try/Catch-Block behandelt. Die zweite ist unbehandelt 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 enthält Benachrichtigungen über uncaught-Ausnahmen. 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 genügend Informationen über den Zustand der Anwendung verfügbar sind, können andere Aktionen durchgeführt werden – z. B. das Speichern von Programmdaten für die spätere Wiederherstellung. Vorsicht wird empfohlen, da Programmdaten beschädigt werden können, wenn Ausnahmen nicht behandelt werden.

Hinweis

In den .NET Framework Versionen 1.0 und 1.1 werden Anwendungsabbruch- und Debugoptionen für den Benutzer gemeldet, bevor dieses Ereignis ausgelöst wird und nicht nach.

Dieses Ereignis kann in einer beliebigen Anwendungsdomäne behandelt werden. Das Ereignis wird jedoch nicht unbedingt in der Anwendungsdomäne ausgelöst, in der die Ausnahme aufgetreten ist. Eine Ausnahme ist nur dann unbehandelt, wenn der gesamte Stapel für den Thread aufgehoben wurde, ohne einen anwendbaren Ausnahmehandler zu finden, sodass der erste Ort, an dem das Ereignis ausgelöst werden kann, in der die Anwendungsdomäne ausgelöst werden kann, in 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 erstellt wird, wenn eine Anwendung gestartet wird. Wenn eine Anwendung zusätzliche Anwendungsdomänen erstellt, hat die Angabe eines Delegaten für dieses Ereignis in diesen Anwendungsdomänen keine Auswirkung.

Wenn das UnhandledException Ereignis in der Standardanwendungsdomäne behandelt wird, wird es für jede nicht behandelte Ausnahme in jedem Thread ausgelöst, unabhängig davon, in welcher Anwendungsdomäne der Thread gestartet wurde. Wenn der Thread in einer Anwendungsdomäne gestartet wurde, für die ein Ereignishandler vorhanden UnhandledExceptionist, wird das Ereignis in dieser Anwendungsdomäne ausgelöst. Wenn diese Anwendungsdomäne nicht die Standardanwendungsdomäne ist, und es gibt auch einen Ereignishandler in der Standardanwendungsdomäne, 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 von dort wird eine Methode in der Anwendungsdomäne "AD3" aufgerufen, in der eine Ausnahme ausgelöst wird. Die erste Anwendungsdomäne, in der das UnhandledException Ereignis ausgelöst werden kann, lautet "AD1". Wenn diese Anwendungsdomäne nicht die Standardanwendungsdomäne ist, kann das Ereignis auch in der Standardanwendungsdomäne ausgelöst werden.

Hinweis

Die allgemeine Sprachlaufzeit 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 hat 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 Hauptanwendungsthread auftritt, von der Laufzeit erfasst und führt daher nicht dazu, dass die Anwendung beendet wird. Daher ist es möglich, dass das UnhandledException Ereignis ausgelöst werden kann, 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 der kumulative Effekt solcher automatischer Fehler Leistungsbeeinträchtigungen, beschädigte Daten und Sperrungen umfasste, die alle schwer debuggen konnten. Weitere Informationen, einschließlich einer Liste von Fällen, in denen die Laufzeit 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 Ausgelöst wird.

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 von anderen Ereignissen vorgelesen werden, wenn die nicht behandelte Ausnahme im Hauptanwendungsthread auftritt.

Bei Anwendungen, die Windows Forms verwenden, werden nicht behandelte Ausnahmen im Hauptanwendungsthread dazu führen, 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 zu UnhandledExceptionMode.ThrowException ändern, bevor der ThreadException Ereignishandler eingebunden wird. Dies gilt nur für den Hauptanwendungsthread. Das UnhandledException Ereignis wird für unbehandelte Ausnahmen ausgelöst, die in anderen Threads ausgelöst werden.

Ab Microsoft Visual Studio 2005 bietet das Visual Basic Anwendungsframework ein weiteres Ereignis für nicht behandelte Ausnahmen im Hauptanwendungsthread. Sehen Sie sich das WindowsFormsApplicationBase.UnhandledException Ereignis an. Dieses Ereignis verfügt über ein Ereignisargumentobjekt mit demselben Namen wie das von , aber mit unterschiedlichen Eigenschaften verwendete AppDomain.UnhandledExceptionEreignisargumentobjekt. Insbesondere verfügt dieses Ereignisargumentobjekt über eine ExitApplication Eigenschaft, mit der die Anwendung weiterhin ausgeführt werden kann, wobei die nicht behandelte Ausnahme ignoriert wird (und die Anwendung in einem unbekannten Zustand verlassen wird). In diesem Fall wird das AppDomain.UnhandledException Ereignis nicht ausgelöst.

Gilt für: