AppDomain.UnhandledException Événement

Définition

Se produit quand une exception n'est pas interceptée.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 

Implémente

Attributs

Exemples

L’exemple suivant illustre l’événement UnhandledException.The following example demonstrates the UnhandledException event. Il définit un gestionnaire d’événements, MyHandler, qui est appelé chaque fois qu’une exception non gérée est levée dans le domaine d’application par défaut.It defines an event handler, MyHandler, that is invoked whenever an unhandled exception is thrown in the default application domain. Il lève ensuite deux exceptions.It then throws two exceptions. Le premier est géré par un bloc try/catch .The first is handled by a try/catch block. La seconde n’est pas gérée et appelle la routine MyHandle avant la fermeture de l’application.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()

Remarques

Cet événement fournit une notification d’exceptions non interceptées.This event provides notification of uncaught exceptions. Elle permet à l’application de consigner des informations sur l’exception avant que le gestionnaire par défaut du système ne signale l’exception à l’utilisateur et mette fin à l’application.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. Si des informations suffisantes sur l’état de l’application sont disponibles, d’autres actions peuvent être effectuées, telles que l’enregistrement des données du programme pour une récupération ultérieure.If sufficient information about the state of the application is available, other actions may be undertaken - such as saving program data for later recovery. Attention est recommandé, car les données du programme peuvent être endommagées lorsque des exceptions ne sont pas gérées.Caution is advised, because program data can become corrupted when exceptions are not handled.

Notes

Dans les versions de .NET Framework 1,0 et 1,1, les options d’arrêt et de débogage de l’application sont signalées à l’utilisateur avant que cet événement soit déclenché, et non après.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.

Cet événement peut être géré dans n’importe quel domaine d’application.This event can be handled in any application domain. Toutefois, l’événement n’est pas nécessairement déclenché dans le domaine d’application où l’exception s’est produite.However, the event is not necessarily raised in the application domain where the exception occurred. Une exception n’est pas gérée uniquement si la pile entière du thread a été déroulée sans rechercher un gestionnaire d’exceptions applicable. par conséquent, le premier emplacement où l’événement peut être déclenché est le domaine d’application où le thread provient.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.

Notes

Dans les versions 1,0 et 1,1 de .NET Framework, cet événement se produit uniquement pour le domaine d’application par défaut créé par le système lorsqu’une application est démarrée.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. Si une application crée des domaines d’application supplémentaires, la spécification d’un délégué pour cet événement dans ces domaines d’application n’a aucun effet.If an application creates additional application domains, specifying a delegate for this event in those applications domains has no effect.

Si l’événement UnhandledException est géré dans le domaine d’application par défaut, il est déclenché pour toute exception non gérée dans un thread, quel que soit le domaine d’application dans lequel le thread a démarré.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. Si le thread a démarré dans un domaine d’application qui a un gestionnaire d’événements pour UnhandledException, l’événement est déclenché dans ce domaine d’application.If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. Si ce domaine d’application n’est pas le domaine d’application par défaut, et qu’il existe également un gestionnaire d’événements dans le domaine d’application par défaut, l’événement est déclenché dans les deux domaines d’application.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.

Par exemple, supposons qu’un thread démarre dans le domaine d’application « AD1 », appelle une méthode dans le domaine d’application « AD2 » et qu’il appelle une méthode dans le domaine d’application « AD3 », où il lève une exception.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. Le premier domaine d’application dans lequel l’événement UnhandledException peut être déclenché est « AD1 ».The first application domain in which the UnhandledException event can be raised is "AD1". Si ce domaine d’application n’est pas le domaine d’application par défaut, l’événement peut également être déclenché dans le domaine d’application par défaut.If that application domain is not the default application domain, the event can also be raised in the default application domain.

Notes

Le common language runtime interrompt les abandons de thread alors que les gestionnaires d’événements pour l’événement UnhandledException sont en cours d’exécution.The common language runtime suspends thread aborts while event handlers for the UnhandledException event are executing.

Si le gestionnaire d’événements a un attribut ReliabilityContractAttribute avec les indicateurs appropriés, le gestionnaire d’événements est traité comme une région d’exécution restreinte.If the event handler has a ReliabilityContractAttribute attribute with the appropriate flags, the event handler is treated as a constrained execution region.

À partir de la .NET Framework 4.NET Framework 4, cet événement n’est pas déclenché pour les exceptions qui corrompent l’état du processus, telles que les dépassements de capacité de la pile ou les violations d’accès, sauf si le gestionnaire d’événements est critique de sécurité et possède l’attribut HandleProcessCorruptedStateExceptionsAttribute.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.

Dans les versions 1,0 et 1,1 de .NET Framework, une exception non gérée qui se produit dans un thread autre que le thread d’application principal est interceptée par le runtime et n’entraîne donc pas l’arrêt de l’application.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. Par conséquent, il est possible de déclencher l’événement UnhandledException sans que l’application se termine.Thus, it is possible for the UnhandledException event to be raised without the application terminating. À partir de la version 2,0 de .NET Framework, cette suppression pour les exceptions non gérées dans les threads enfants a été supprimée, car l’effet cumulatif de ces échecs silencieux comprenait la dégradation des performances, les données endommagées et les blocages, qui étaient tous difficiles à Debug.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. Pour plus d’informations, notamment une liste des cas dans lesquels le runtime ne se termine pas, consultez exceptions dans les threads managés.For more information, including a list of cases in which the runtime does not terminate, see Exceptions in Managed Threads.

Pour inscrire un gestionnaire d’événements pour cet événement, vous devez disposer des autorisations requises, ou une SecurityException est levée.To register an event handler for this event, you must have the required permissions, or a SecurityException is thrown.

Pour plus d'informations sur la gestion des événements, voir gestion et déclenchement d’événements.For more information about handling events, see Handling and Raising Events.

Autres événements pour les exceptions non géréesOther Events for Unhandled Exceptions

Pour certains modèles d’application, l’événement UnhandledException peut être devancé par d’autres événements si l’exception non gérée se produit dans le thread d’application principal.For certain application models, the UnhandledException event can be preempted by other events if the unhandled exception occurs in the main application thread.

Dans les applications qui utilisent Windows Forms, les exceptions non gérées dans le thread d’application principal provoquent le déclenchement de l’événement Application.ThreadException.In applications that use Windows Forms, unhandled exceptions in the main application thread cause the Application.ThreadException event to be raised. Si cet événement est géré, le comportement par défaut est que l’exception non gérée ne met pas fin à l’application, même si l’application est laissée dans un état inconnu.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. Dans ce cas, l’événement UnhandledException n’est pas déclenché.In that case, the UnhandledException event is not raised. Ce comportement peut être modifié à l’aide du fichier de configuration de l’application, ou à l’aide de la méthode Application.SetUnhandledExceptionMode pour changer le mode en UnhandledExceptionMode.ThrowException avant que le gestionnaire d’événements ThreadException soit raccordé.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. Cela s’applique uniquement au thread d’application principal.This applies only to the main application thread. L’événement UnhandledException est déclenché pour les exceptions non gérées levées dans d’autres threads.The UnhandledException event is raised for unhandled exceptions thrown in other threads.

À compter de Microsoft Visual Studio 2005, l’infrastructure d’application Visual Basic fournit un autre événement pour les exceptions non gérées dans le thread d’application principal.Starting with Microsoft Visual Studio 2005, the Visual Basic application framework provides another event for unhandled exceptions in the main application thread. Consultez l’événement WindowsFormsApplicationBase.UnhandledException.See the WindowsFormsApplicationBase.UnhandledException event. Cet événement possède un objet d’arguments d’événement portant le même nom que l’objet d’arguments d’événement utilisé par AppDomain.UnhandledException, mais avec des propriétés différentes.This event has an event arguments object with the same name as the event arguments object used by AppDomain.UnhandledException, but with different properties. En particulier, cet objet d’arguments d’événement a une propriété ExitApplication qui permet à l’application de continuer à s’exécuter, en ignorant l’exception non gérée (et en laissant l’application dans un état inconnu).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). Dans ce cas, l’événement AppDomain.UnhandledException n’est pas déclenché.In that case, the AppDomain.UnhandledException event is not raised.

Sécurité

SecurityCriticalAttribute
requiert une confiance totale pour l’appelant immédiat.requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

S’applique à