AppDomain.UnhandledException Evento

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

AppDomain.cs

Se produce cuando no se detecta una excepción.

public:
 event UnhandledExceptionEventHandler ^ UnhandledException;

public event UnhandledExceptionEventHandler? UnhandledException;

member this.UnhandledException : UnhandledExceptionEventHandler 

Public Custom Event UnhandledException As UnhandledExceptionEventHandler 

Tipo de evento

UnhandledExceptionEventHandler

Ejemplos

En el ejemplo siguiente se muestra el UnhandledException evento . Define un controlador de eventos, MyHandler, que se invoca cada vez que se produce una excepción no controlada en el dominio de aplicación predeterminado. A continuación, produce dos excepciones. La primera se controla mediante un bloque try/catch . El segundo no está controlado e invoca la MyHandle rutina antes de que finalice la aplicación.

// 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()

Comentarios

Los controladores se pueden invocar varias veces si se producen excepciones desde subprocesos diferentes.

El UnhandledException evento proporciona una notificación de excepciones no detectadas. Permite que la aplicación registre información sobre la excepción antes de que el controlador predeterminado del sistema notifique la excepción al usuario y finalice la aplicación. Si hay suficiente información sobre el estado de la aplicación disponible, se pueden realizar otras acciones, como guardar datos del programa para la recuperación posterior. Se recomienda precaución, ya que los datos del programa pueden dañarse cuando no se controlan las excepciones. El controlador también se ejecutará mientras se mantienen los bloqueos que se mantienen cuando se produjo la excepción, por lo que se debe tener cuidado para evitar esperar a otros recursos que podrían introducir interbloqueos.

Este evento se puede controlar en cualquier dominio de aplicación. Sin embargo, el evento no se genera necesariamente en el dominio de aplicación donde se produjo la excepción. Una excepción queda sin controlar solo si toda la pila del subproceso se ha desenrollado sin encontrar un controlador de excepciones aplicable, por lo que el primer lugar en el que se puede producir el evento se encuentra en el dominio de aplicación donde se originó el subproceso.

Si el UnhandledException evento se controla en el dominio de aplicación predeterminado, se genera allí para cualquier excepción no controlada en cualquier subproceso, independientemente del dominio de aplicación en el que se inició el subproceso. Si el subproceso se inició en un dominio de aplicación que tiene un controlador de eventos para UnhandledException, el evento se genera en ese dominio de aplicación. Si ese dominio de aplicación no es el dominio de aplicación predeterminado y también hay un controlador de eventos en el dominio de aplicación predeterminado, el evento se genera en ambos dominios de aplicación.

Por ejemplo, supongamos que un subproceso se inicia en el dominio de aplicación "AD1", llama a un método en el dominio de aplicación "AD2" y, desde allí, llama a un método en el dominio de aplicación "AD3", donde produce una excepción. El primer dominio de aplicación en el que se puede generar el UnhandledException evento es "AD1". Si ese dominio de aplicación no es el dominio de aplicación predeterminado, el evento también se puede generar en el dominio de aplicación predeterminado.

Note

El entorno de ejecución común suspende las anulaciones del subproceso mientras se ejecutan controladores de eventos para el evento UnhandledException.

Si el controlador de eventos tiene un ReliabilityContractAttribute atributo con las marcas adecuadas, el controlador de eventos se trata como una región de ejecución restringida.

Este evento no se genera para excepciones que dañan el estado del proceso, como desbordamientos de pila o infracciones de acceso, a menos que el controlador de eventos sea crítico para la seguridad y tenga el HandleProcessCorruptedStateExceptionsAttribute atributo .

Para registrar un controlador de eventos para este evento, debe tener los permisos necesarios o se produce una SecurityException excepción .

Para obtener más información sobre el manejo de eventos, consulte controlar y provocar eventos.

Otros eventos para excepciones no controladas

Para determinados modelos de aplicación, el UnhandledException evento puede ser reemplazado por otros eventos si la excepción no controlada se produce en el subproceso de aplicación principal.

En las aplicaciones que usan Windows Forms, las excepciones no controladas en el subproceso de aplicación principal hacen que se genere el Application.ThreadException evento. Si se controla este evento, el comportamiento predeterminado es que la excepción no controlada no finaliza la aplicación, aunque la aplicación se deja en un estado desconocido. En ese caso, el evento UnhandledException no se genera. Este comportamiento se puede cambiar mediante el archivo de configuración de la aplicación o mediante el método para cambiar el Application.SetUnhandledExceptionMode modo a UnhandledExceptionMode.ThrowException antes de que se conecte el ThreadException controlador de eventos. Esto solo se aplica al subproceso de aplicación principal. El UnhandledException evento se genera para excepciones no controladas lanzadas en otros hilos.

El entorno de aplicación de Visual Basic proporciona otro evento para excepciones no controladas en el hilo de la aplicación principal, el evento WindowsFormsApplicationBase.UnhandledException. Este evento tiene un objeto de argumentos de evento con el mismo nombre que el objeto de argumentos de evento utilizado por AppDomain.UnhandledException, pero con propiedades diferentes. En concreto, este objeto de argumentos de evento tiene una ExitApplication propiedad que permite a la aplicación seguir ejecutándose, ignorando la excepción no controlada (y dejando la aplicación en un estado desconocido). En ese caso, el evento AppDomain.UnhandledException no se genera.