AppDomain.UnhandledException Ereignis

Definition

Tritt auf, wenn eine Ausnahme nicht abgefangen wird.Occurs when an exception is not caught.

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

Implementiert

Attribute

Beispiele

Im folgenden Beispiel wird das UnhandledException-Ereignis veranschaulicht.The following example demonstrates the UnhandledException event. Es definiert einen Ereignishandler (MyHandler), der immer dann aufgerufen wird, wenn in der Standard Anwendungsdomäne eine nicht behandelte Ausnahme ausgelöst wird.It defines an event handler, MyHandler, that is invoked whenever an unhandled exception is thrown in the default application domain. Anschließend werden zwei Ausnahmen ausgelöst.It then throws two exceptions. Der erste wird von einem try/catch- Block behandelt.The first is handled by a try/catch block. Die zweite ist unbehandelt und ruft die MyHandle Routine auf, bevor die Anwendung beendet wird.The second is unhandled and invokes the MyHandle routine before the application terminates.

// 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;
using System.Security.Permissions;

public class Example 
{
   [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlAppDomain)]
   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()  
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 eine Benachrichtigung über nicht abgefangene Ausnahmen bereit.This event provides notification of uncaught exceptions. Dadurch kann die Anwendung Informationen zu der Ausnahme protokollieren, bevor der System Standard Handler die Ausnahme an den Benutzer meldet und die Anwendung beendet.It allows the application to log information about the exception before the system default handler reports the exception to the user and terminates the application. Wenn genügend Informationen über den Status der Anwendung verfügbar sind, können andere Aktionen ausgeführt werden, z. b. das Speichern von Programm Daten für eine spätere Wiederherstellung.If sufficient information about the state of the application is available, other actions may be undertaken - such as saving program data for later recovery. Vorsicht wird empfohlen, da die Programm Daten beschädigt werden können, wenn Ausnahmen nicht behandelt werden.Caution is advised, because program data can become corrupted when exceptions are not handled.

Hinweis

In den .NET Framework Versionen 1,0 und 1,1 werden dem Benutzer vor dem ausgelöst dieses Ereignisses und nicht nach dem Ereignis die Optionen zum Beenden und Debuggen von Anwendungen gemeldet.In the .NET Framework versions 1.0 and 1.1, application termination and debugging options are reported to the user before this event is raised, rather than after.

Dieses Ereignis kann in einer beliebigen Anwendungsdomäne behandelt werden.This event can be handled in any application domain. Das Ereignis wird jedoch nicht notwendigerweise in der Anwendungsdomäne ausgelöst, in der die Ausnahme aufgetreten ist.However, the event is not necessarily raised in the application domain where the exception occurred. Eine Ausnahme wird nur dann unbehandelt, wenn der gesamte Stapel für den Thread entladen wurde, ohne einen anwendbaren Ausnahmehandler zu finden. der erste Ort, an dem das Ereignis ausgelöst werden kann, befindet sich in der Anwendungsdomäne, aus der der Thread stammt.An exception is unhandled only if the entire stack for the thread has been unwound without finding an applicable exception handler, so the first place the event can be raised is in the application domain where the thread originated.

Hinweis

In den .NET Framework Versionen 1,0 und 1,1 tritt dieses Ereignis nur für die Standard Anwendungsdomäne ein, die vom System beim Starten einer Anwendung erstellt wird.In the .NET Framework versions 1.0 and 1.1, this event occurs only for the default application domain that is created by the system when an application is started. Wenn eine Anwendung zusätzliche Anwendungs Domänen erstellt, hat die Angabe eines Delegaten für dieses Ereignis in diesen Anwendungs Domänen keinerlei Auswirkungen.If an application creates additional application domains, specifying a delegate for this event in those applications domains has no effect.

Wenn das UnhandledException-Ereignis in der Standard Anwendungsdomäne behandelt wird, wird es für alle nicht behandelten Ausnahmen in jedem Thread ausgelöst, unabhängig davon, in welcher Anwendungsdomäne der Thread gestartet wurde.If the UnhandledException event is handled in the default application domain, it is raised there for any unhandled exception in any thread, no matter what application domain the thread started in. Wenn der Thread in einer Anwendungsdomäne gestartet wird, die über einen Ereignishandler für UnhandledExceptionverfügt, wird das-Ereignis in dieser Anwendungsdomäne ausgelöst.If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. Wenn diese Anwendungsdomäne nicht die Standard Anwendungsdomäne ist und auch ein Ereignishandler in der Standard Anwendungsdomäne vorhanden ist, wird das-Ereignis in beiden Anwendungs Domänen ausgelöst.If that application domain is not the default application domain, and there is also an event handler in the default application domain, the event is raised in both application domains.

Angenommen, ein Thread startet 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.For example, suppose a thread starts in application domain "AD1", calls a method in application domain "AD2", and from there calls a method in application domain "AD3", where it throws an exception. Die erste Anwendungsdomäne, in der das UnhandledException Ereignis ausgelöst werden kann, ist "AD1".The first application domain in which the UnhandledException event can be raised is "AD1". Wenn diese Anwendungsdomäne nicht die Standard Anwendungsdomäne ist, kann das Ereignis auch in der Standard Anwendungsdomäne ausgelöst werden.If that application domain is not the default application domain, the event can also be raised in the default application domain.

Hinweis

Der Common Language Runtime hält Thread Abbrüche an, während Ereignishandler für das UnhandledException Ereignis ausgeführt werden.The common language runtime suspends thread aborts while event handlers for the UnhandledException event are executing.

Wenn der Ereignishandler über ein ReliabilityContractAttribute Attribut mit den entsprechenden Flags verfügt, wird der Ereignishandler als eingeschränkter Ausführungs Bereich behandelt.If the event handler has a ReliabilityContractAttribute attribute with the appropriate flags, the event handler is treated as a constrained execution region.

Beginnend mit dem .NET Framework 4.NET Framework 4wird dieses Ereignis nicht für Ausnahmen ausgelöst, die den Status des Prozesses beschädigen (z. b. Stapel Überläufe oder Zugriffs Verletzungen), es sei denn, der Ereignishandler ist sicherheitskritisch und verfügt über das HandleProcessCorruptedStateExceptionsAttribute-Attribut.Starting with the .NET Framework 4.NET Framework 4, this event is not raised for exceptions that corrupt the state of the process, such as stack overflows or access violations, unless the event handler is security-critical and has the HandleProcessCorruptedStateExceptionsAttribute attribute.

In den .NET Framework Versionen 1,0 und 1,1 wird eine nicht behandelte Ausnahme, die in einem anderen Thread als dem Hauptanwendungs Thread auftritt, von der Laufzeit abgefangen und bewirkt daher nicht, dass die Anwendung beendet wird.In the .NET Framework versions 1.0 and 1.1, an unhandled exception that occurs in a thread other than the main application thread is caught by the runtime and therefore does not cause the application to terminate. Daher ist es möglich, dass das UnhandledException Ereignis ausgelöst wird, ohne dass die Anwendung beendet wird.Thus, it is possible for the UnhandledException event to be raised without the application terminating. Beginnend mit der .NET Framework Version 2,0 wurde dieses Back-End für nicht behandelte Ausnahmen in untergeordneten Threads entfernt, da der kumulative Effekt von solchen stillen Fehlern zu Leistungseinbußen, beschädigten Daten und Lockups geführt hat, die alle schwierig zu gen.Starting with the .NET Framework version 2.0, this backstop for unhandled exceptions in child threads was removed, because the cumulative effect of such silent failures included performance degradation, corrupted data, and lockups, all of which were difficult to debug. Weitere Informationen, einschließlich einer Liste der Fälle, in denen die Laufzeit nicht beendet wird, finden Sie unter Ausnahmen in verwalteten Threads.For more information, including a list of cases in which the runtime does not terminate, see Exceptions in Managed Threads.

Um einen Ereignishandler für dieses Ereignis zu registrieren, müssen Sie über die erforderlichen Berechtigungen verfügen, oder es wird eine SecurityException ausgelöst.To register an event handler for this event, you must have the required permissions, or a SecurityException is thrown.

Weitere Informationen zur Behandlung von Ereignissen finden Sie unter behandeln und Auslösen von Ereignissen.For more information about handling events, see Handling and Raising Events.

Andere Ereignisse für nicht behandelte AusnahmenOther Events for Unhandled Exceptions

Für bestimmte Anwendungsmodelle kann das UnhandledException-Ereignis durch andere Ereignisse vorzeitig entfernt werden, wenn die unbehandelte Ausnahme im Hauptanwendungs Thread auftritt.For certain application models, the UnhandledException event can be preempted by other events if the unhandled exception occurs in the main application thread.

In Anwendungen, die Windows Forms verwenden, bewirken nicht behandelte Ausnahmen im Haupt Anwendungs Thread, dass das Application.ThreadException Ereignis ausgelöst wird.In applications that use Windows Forms, unhandled exceptions in the main application thread cause the Application.ThreadException event to be raised. Wenn dieses Ereignis behandelt wird, besteht das Standardverhalten darin, dass die Anwendung nicht von der nicht behandelten Ausnahme beendet wird, obwohl die Anwendung in einem unbekannten Zustand verbleibt.If this event is handled, the default behavior is that the unhandled exception does not terminate the application, although the application is left in an unknown state. In diesem Fall wird das UnhandledException-Ereignis nicht ausgelöst.In that case, the UnhandledException event is not raised. Dieses Verhalten kann mithilfe der Anwendungs Konfigurationsdatei oder mithilfe der Application.SetUnhandledExceptionMode-Methode geändert werden, um den Modus in UnhandledExceptionMode.ThrowException zu ändern, bevor der ThreadException-Ereignishandler eingebunden wird.This behavior can be changed by using the application configuration file, or by using the Application.SetUnhandledExceptionMode method to change the mode to UnhandledExceptionMode.ThrowException before the ThreadException event handler is hooked up. Dies gilt nur für den Hauptanwendungs Thread.This applies only to the main application thread. Das UnhandledException Ereignis wird für nicht behandelte Ausnahmen ausgelöst, die in anderen Threads ausgelöst werden.The UnhandledException event is raised for unhandled exceptions thrown in other threads.

Ab Microsoft Visual Studio 2005 stellt das Visual Basic-Anwendungs Framework ein weiteres Ereignis für nicht behandelte Ausnahmen im Hauptanwendungs Thread bereit.Starting with Microsoft Visual Studio 2005, the Visual Basic application framework provides another event for unhandled exceptions in the main application thread. Weitere Informationen finden Sie unter WindowsFormsApplicationBase.UnhandledException Ereignis.See the WindowsFormsApplicationBase.UnhandledException event. Dieses Ereignis verfügt über ein Ereignis Argument Objekt mit demselben Namen wie das Ereignis Argument Objekt, das von AppDomain.UnhandledExceptionverwendet wird, jedoch mit unterschiedlichen Eigenschaften.This event has an event arguments object with the same name as the event arguments object used by AppDomain.UnhandledException, but with different properties. Dieses Ereignis Argument Objekt verfügt insbesondere über eine ExitApplication-Eigenschaft, mit der die Anwendung weiter ausgeführt werden kann, wobei die nicht behandelte Ausnahme ignoriert wird (und die Anwendung in einem unbekannten Zustand belassen wird).In particular, this event arguments object has an ExitApplication property that allows the application to continue running, ignoring the unhandled exception (and leaving the application in an unknown state). In diesem Fall wird das AppDomain.UnhandledException-Ereignis nicht ausgelöst.In that case, the AppDomain.UnhandledException event is not raised.

Sicherheit

SecurityCriticalAttribute
Erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

Gilt für: