AppDomain.UnhandledException Evento

Definição

Ocorre quando uma exceção não é capturada.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 

Implementações

Atributos

Exemplos

O exemplo a seguir demonstra o evento UnhandledException.The following example demonstrates the UnhandledException event. Ele define um manipulador de eventos, MyHandler, que é invocado sempre que uma exceção sem tratamento é lançada no domínio do aplicativo padrão.It defines an event handler, MyHandler, that is invoked whenever an unhandled exception is thrown in the default application domain. Em seguida, ele gera duas exceções.It then throws two exceptions. O primeiro é tratado por um bloco try/catch .The first is handled by a try/catch block. O segundo não é manipulado e invoca a rotina de MyHandle antes de o aplicativo ser encerrado.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()

Comentários

Esse evento fornece notificação de exceções não capturadas.This event provides notification of uncaught exceptions. Ele permite que o aplicativo registre informações sobre a exceção antes que o manipulador padrão do sistema relate a exceção ao usuário e encerre o aplicativo.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. Se forem disponibilizadas informações suficientes sobre o estado do aplicativo, outras ações poderão ser realizadas, como salvar os dados do programa para recuperação 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. Cuidado é recomendável, pois os dados do programa podem ser corrompidos quando exceções não são tratadas.Caution is advised, because program data can become corrupted when exceptions are not handled.

Observação

No .NET Framework versões 1,0 e 1,1, as opções de encerramento e depuração do aplicativo são relatadas ao usuário antes que esse evento seja gerado, em vez de depois.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.

Esse evento pode ser tratado em qualquer domínio de aplicativo.This event can be handled in any application domain. No entanto, o evento não é necessariamente gerado no domínio do aplicativo em que ocorreu a exceção.However, the event is not necessarily raised in the application domain where the exception occurred. Uma exceção não será tratada somente se toda a pilha do thread tiver sido desfeita sem encontrar um manipulador de exceção aplicável, portanto, o primeiro lugar em que o evento pode ser gerado está no domínio do aplicativo em que o thread foi originado.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.

Observação

No .NET Framework versões 1,0 e 1,1, esse evento ocorre somente para o domínio de aplicativo padrão que é criado pelo sistema quando um aplicativo é iniciado.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. Se um aplicativo criar domínios de aplicativo adicionais, a especificação de um delegado para esse evento nos domínios de aplicativos não terá nenhum efeito.If an application creates additional application domains, specifying a delegate for this event in those applications domains has no effect.

Se o evento UnhandledException for tratado no domínio do aplicativo padrão, ele será gerado para qualquer exceção sem tratamento em qualquer thread, não importa em qual domínio de aplicativo o thread iniciou.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. Se o thread iniciou em um domínio de aplicativo que tem um manipulador de eventos para UnhandledException, o evento é gerado nesse domínio de aplicativo.If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. Se esse domínio de aplicativo não for o domínio de aplicativo padrão e houver também um manipulador de eventos no domínio de aplicativo padrão, o evento será gerado em ambos os domínios de aplicativo.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 exemplo, suponha que um thread comece no domínio do aplicativo "AD1", chame um método no domínio do aplicativo "AD2" e, a partir daí, chame um método no domínio do aplicativo "AD3", no qual ele gera uma exceção.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. O primeiro domínio do aplicativo no qual o evento UnhandledException pode ser gerado é "AD1".The first application domain in which the UnhandledException event can be raised is "AD1". Se esse domínio de aplicativo não for o domínio de aplicativo padrão, o evento também poderá ser gerado no domínio de aplicativo padrão.If that application domain is not the default application domain, the event can also be raised in the default application domain.

Observação

O Common Language Runtime suspende as anulações de thread enquanto os manipuladores de eventos do evento UnhandledException estão em execução.The common language runtime suspends thread aborts while event handlers for the UnhandledException event are executing.

Se o manipulador de eventos tiver um atributo ReliabilityContractAttribute com os sinalizadores apropriados, o manipulador de eventos será tratado como uma região de execução restrita.If the event handler has a ReliabilityContractAttribute attribute with the appropriate flags, the event handler is treated as a constrained execution region.

A partir do .NET Framework 4.NET Framework 4, esse evento não é gerado para exceções que corrompem o estado do processo, como estouros de pilha ou violações de acesso, a menos que o manipulador de eventos seja de segurança crítica e tenha o atributo 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.

No .NET Framework versões 1,0 e 1,1, uma exceção sem tratamento que ocorre em um thread que não seja o thread do aplicativo principal é detectada pelo tempo de execução e, portanto, não faz com que o aplicativo seja encerrado.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. Portanto, é possível que o evento UnhandledException seja gerado sem que o aplicativo seja encerrado.Thus, it is possible for the UnhandledException event to be raised without the application terminating. A partir do .NET Framework versão 2,0, esse Backstop para exceções não tratadas em threads filho foi removido, pois o efeito cumulativo dessas falhas silenciosas incluía degradação de desempenho, dados corrompidos e travamentos, que são difíceis de verificação.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 obter mais informações, incluindo uma lista de casos em que o tempo de execução não termina, consulte exceções em threads gerenciados.For more information, including a list of cases in which the runtime does not terminate, see Exceptions in Managed Threads.

Para registrar um manipulador de eventos para esse evento, você deve ter as permissões necessárias, ou um SecurityException é lançado.To register an event handler for this event, you must have the required permissions, or a SecurityException is thrown.

Para obter mais informações sobre como manipular eventos, consulte manipulando e gerando eventos.For more information about handling events, see Handling and Raising Events.

Outros eventos para exceções não identificadasOther Events for Unhandled Exceptions

Para determinados modelos de aplicativo, o evento UnhandledException pode ser admitido por outros eventos se a exceção não tratada ocorrer no thread do aplicativo principal.For certain application models, the UnhandledException event can be preempted by other events if the unhandled exception occurs in the main application thread.

Em aplicativos que usam Windows Forms, as exceções sem tratamento no thread do aplicativo principal fazem com que o evento de Application.ThreadException seja gerado.In applications that use Windows Forms, unhandled exceptions in the main application thread cause the Application.ThreadException event to be raised. Se esse evento for tratado, o comportamento padrão é que a exceção sem tratamento não encerra o aplicativo, embora o aplicativo seja deixado em um estado desconhecido.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. Nesse caso, o evento UnhandledException não é gerado.In that case, the UnhandledException event is not raised. Esse comportamento pode ser alterado usando o arquivo de configuração do aplicativo ou usando o método Application.SetUnhandledExceptionMode para alterar o modo para UnhandledExceptionMode.ThrowException antes que o manipulador de eventos ThreadException seja conectado.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. Isso se aplica somente ao thread do aplicativo principal.This applies only to the main application thread. O evento UnhandledException é gerado para exceções não tratadas lançadas em outros threads.The UnhandledException event is raised for unhandled exceptions thrown in other threads.

A partir do Microsoft Visual Studio 2005, a estrutura do aplicativo Visual Basic fornece outro evento para exceções sem tratamento no thread do aplicativo principal.Starting with Microsoft Visual Studio 2005, the Visual Basic application framework provides another event for unhandled exceptions in the main application thread. Consulte o evento WindowsFormsApplicationBase.UnhandledException.See the WindowsFormsApplicationBase.UnhandledException event. Esse evento tem um objeto de argumentos de evento com o mesmo nome que o objeto de argumentos de evento usado por AppDomain.UnhandledException, mas com propriedades 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. Em particular, esse objeto de argumentos de evento tem uma propriedade ExitApplication que permite que o aplicativo continue em execução, ignorando a exceção sem tratamento (e deixando o aplicativo em um estado desconhecido).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). Nesse caso, o evento AppDomain.UnhandledException não é gerado.In that case, the AppDomain.UnhandledException event is not raised.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Aplica-se a