AppDomain.UnhandledException AppDomain.UnhandledException AppDomain.UnhandledException AppDomain.UnhandledException Event

Definición

Se produce cuando no se detecta una excepción.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 

Implementaciones

Atributos

Ejemplos

En el ejemplo siguiente se UnhandledException muestra el evento.The following example demonstrates the UnhandledException event. Define un controlador de eventos, MyHandler, que se invoca siempre que se produce una excepción no controlada en el dominio de aplicación predeterminado.It defines an event handler, MyHandler, that is invoked whenever an unhandled exception is thrown in the default application domain. Después, inicia dos excepciones.It then throws two exceptions. El primero lo controla un bloque try/catch .The first is handled by a try/catch block. El segundo es no controlado e invoca la MyHandle rutina antes de que finalice la aplicación.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()

Comentarios

Este evento proporciona una notificación de excepciones no detectadas.This event provides notification of uncaught exceptions. Permite que la aplicación registre información sobre la excepción antes de que el controlador predeterminado del sistema informe de la excepción al usuario y termine la aplicación.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 hay suficiente información disponible sobre el estado de la aplicación, se pueden emprender otras acciones, como guardar los datos del programa para su recuperación posterior.If sufficient information about the state of the application is available, other actions may be undertaken - such as saving program data for later recovery. Se recomienda tener cuidado, ya que los datos del programa pueden resultar dañados cuando no se controlan las excepciones.Caution is advised, because program data can become corrupted when exceptions are not handled.

Nota

En las versiones .NET Framework 1,0 y 1,1, las opciones de finalización y depuración de la aplicación se envían al usuario antes de que se genere este evento, en lugar de despué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.

Este evento se puede controlar en cualquier dominio de aplicación.This event can be handled in any application domain. Sin embargo, el evento no se genera necesariamente en el dominio de aplicación donde se produjo la excepción.However, the event is not necessarily raised in the application domain where the exception occurred. Una excepción no se controla solo si toda la pila del subproceso se ha desenredado sin encontrar un controlador de excepciones aplicable, por lo que el primer lugar en el que se puede generar el evento es el dominio de aplicación donde se originó el subproceso.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.

Nota

En las versiones 1,0 y 1,1 de .NET Framework, este evento solo se produce para el dominio de aplicación predeterminado creado por el sistema cuando se inicia una aplicación.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 una aplicación crea dominios de aplicación adicionales, la especificación de un delegado para este evento en esos dominios de aplicaciones no tiene ningún efecto.If an application creates additional application domains, specifying a delegate for this event in those applications domains has no effect.

Si el UnhandledException evento se controla en el dominio de aplicación predeterminado, se genera ahí para cualquier excepción no controlada en cualquier subproceso, independientemente del dominio de aplicación en el que se inició el subproceso.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 el subproceso se inicia en un dominio de aplicación que tiene un UnhandledExceptioncontrolador de eventos para, el evento se genera en ese dominio de aplicación.If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. 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.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.

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, llama a un método en el dominio de aplicación "AD3", donde produce una excepción.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. El primer dominio de aplicación en el UnhandledException que se puede generar el evento es "AD1".The first application domain in which the UnhandledException event can be raised is "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.If that application domain is not the default application domain, the event can also be raised in the default application domain.

Nota

El Common Language Runtime suspende las anulaciones de subprocesos mientras se ejecutan los controladores de eventos para el UnhandledException evento.The common language runtime suspends thread aborts while event handlers for the UnhandledException event are executing.

Si el controlador de eventos tiene ReliabilityContractAttribute un atributo con las marcas apropiadas, el controlador de eventos se trata como una región de ejecución restringida.If the event handler has a ReliabilityContractAttribute attribute with the appropriate flags, the event handler is treated as a constrained execution region.

A partir HandleProcessCorruptedStateExceptionsAttribute de ,esteeventonosegeneraparalasexcepcionesquedañanelestadodelproceso,comolosdesbordamientosdelapilaolasinfraccionesdeacceso,amenosqueelcontroladordeeventosseacríticoparalaseguridady.NET Framework 4.NET Framework 4tenga el atributo.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.

En las versiones .NET Framework 1,0 y 1,1, el tiempo de ejecución detecta una excepción no controlada que se produce en un subproceso distinto del subproceso de aplicación principal y, por tanto, no hace que la aplicación finalice.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. Por lo tanto, es posible que UnhandledException se produzca el evento sin que finalice la aplicación.Thus, it is possible for the UnhandledException event to be raised without the application terminating. A partir de la versión 2,0 de .NET Framework, se ha quitado esta parada de las excepciones no controladas en subprocesos secundarios, ya que el efecto acumulativo de estos errores silenciosos incluía la degradación del rendimiento, los datos dañados y los bloqueos, todos los cuales eran difíciles de depura.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. Para obtener más información, incluida una lista de casos en los que el tiempo de ejecución no finaliza, consulte excepciones en subprocesos administrados.For more information, including a list of cases in which the runtime does not terminate, see Exceptions in Managed Threads.

Para registrar un controlador de eventos para este evento, debe tener los permisos necesarios o se producirá una SecurityException excepción.To register an event handler for this event, you must have the required permissions, or a SecurityException is thrown.

Para obtener más información sobre el manejo de eventos, consulte controlar y provocar eventos.For more information about handling events, see Handling and Raising Events.

Otros eventos para las excepciones no controladasOther Events for Unhandled Exceptions

En algunos modelos de aplicación, UnhandledException otros eventos pueden adelantar el evento si la excepción no controlada se produce en el subproceso de la aplicación principal.For certain application models, the UnhandledException event can be preempted by other events if the unhandled exception occurs in the main application thread.

En las aplicaciones que usan Windows Forms, las excepciones no controladas en el subproceso principal Application.ThreadException de la aplicación provocan que se genere el evento.In applications that use Windows Forms, unhandled exceptions in the main application thread cause the Application.ThreadException event to be raised. 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.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. En ese caso, el UnhandledException evento no se genera.In that case, the UnhandledException event is not raised. Este comportamiento se puede cambiar mediante el archivo de configuración de la aplicación o mediante el Application.SetUnhandledExceptionMode método para cambiar el modo a UnhandledExceptionMode.ThrowException antes de ThreadException enlazar el controlador de eventos.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. Esto solo se aplica al subproceso de aplicación principal.This applies only to the main application thread. El UnhandledException evento se desencadena para las excepciones no controladas producidas en otros subprocesos.The UnhandledException event is raised for unhandled exceptions thrown in other threads.

A partir de Microsoft Visual Studio 2005, el marco de trabajo de la aplicación Visual Basic proporciona otro evento para las excepciones no controladas en el subproceso principal de la aplicación.Starting with Microsoft Visual Studio 2005, the Visual Basic application framework provides another event for unhandled exceptions in the main application thread. Vea el WindowsFormsApplicationBase.UnhandledException evento.See the WindowsFormsApplicationBase.UnhandledException event. Este evento tiene un objeto de argumentos de evento con el mismo nombre que el objeto de argumentos AppDomain.UnhandledExceptionde evento utilizado por, pero con propiedades diferentes.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 concreto, este objeto de argumentos de evento ExitApplication tiene una propiedad que permite que la aplicación siga ejecutándose, pasando por alto la excepción no controlada (y abandonando la aplicación en un estado desconocido).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). En ese caso, el AppDomain.UnhandledException evento no se genera.In that case, the AppDomain.UnhandledException event is not raised.

Seguridad

SecurityCriticalAttribute
requiere plena confianza para el llamador inmediato.requires full trust for the immediate caller. Este miembro no puede ser utilizado por código transparente o de confianza parcial.This member cannot be used by partially trusted or transparent code.

Se aplica a