AppDomain.UnhandledException Evento

public:
 event UnhandledExceptionEventHandler ^ UnhandledException;

public:
 virtual event UnhandledExceptionEventHandler ^ UnhandledException;

public event UnhandledExceptionEventHandler? UnhandledException;

public event UnhandledExceptionEventHandler UnhandledException;

[add: System.Security.SecurityCritical]
[remove: System.Security.SecurityCritical]
public event UnhandledExceptionEventHandler UnhandledException;

member this.UnhandledException : UnhandledExceptionEventHandler 

[<add: System.Security.SecurityCritical>]
[<remove: System.Security.SecurityCritical>]
member this.UnhandledException : UnhandledExceptionEventHandler 

Public Custom Event UnhandledException As UnhandledExceptionEventHandler 

Tipo de Evento

Implementações

Atributos

SecurityCriticalAttribute

Exemplos

O exemplo seguinte demonstra o UnhandledException evento. Define um gestor de eventos, MyHandler, que é invocado sempre que uma exceção não tratada é lançada no domínio de aplicação predefinido. Depois lança duas exceções. O primeiro é controlado por um bloqueio de tentativa/receção . O segundo não é tratado e invoca a MyHandle rotina antes de a aplicação terminar.

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

Observações

Os handlers podem ser invocados várias vezes se forem lançadas exceções de diferentes threads.

O UnhandledException evento fornece notificação de exceções não detetadas. Ele permite que o aplicativo registre informações sobre a exceção antes que o manipulador padrão do sistema informe a exceção ao usuário e encerre o aplicativo. Se informações suficientes sobre o estado do aplicativo estiverem disponíveis, outras ações podem ser realizadas - como salvar dados do programa para recuperação posterior. Recomenda-se cuidado, porque os dados do programa podem ficar corrompidos quando as exceções não são tratadas. O manipulador também estará funcionando enquanto mantém bloqueios mantidos quando a exceção foi lançada, portanto, deve-se tomar cuidado para evitar esperar por outros recursos que poderiam introduzir bloqueios.

Esse evento pode ser manipulado em qualquer domínio de aplicativo. No entanto, o evento não é necessariamente gerado no domínio do aplicativo onde a exceção ocorreu. Uma exceção não será tratada somente se toda a pilha do thread tiver sido desenrolada sem encontrar um manipulador de exceção aplicável, portanto, o primeiro lugar em que o evento pode ser gerado é no domínio do aplicativo onde o thread se originou.

Se o UnhandledException evento for manipulado no domínio de aplicativo padrão, ele será gerado para qualquer exceção não tratada em qualquer thread, independentemente do domínio do aplicativo em que o thread começou. Se o thread foi iniciado em um domínio de aplicativo que tem um manipulador de eventos para UnhandledException, o evento é gerado nesse domínio de aplicativo. Se esse domínio de aplicativo não for o domínio de aplicativo padrão e também houver um manipulador de eventos no domínio de aplicativo padrão, o evento será gerado em ambos os domínios de aplicativo.

Por exemplo, suponha que um thread começa no domínio do aplicativo "AD1", chama um método no domínio do aplicativo "AD2" e, a partir daí, chama um método no domínio do aplicativo "AD3", onde ele lança uma exceção. O primeiro domínio de aplicação em que o UnhandledException evento pode ser gerado é "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.

Se o manipulador de eventos tiver um ReliabilityContractAttribute atributo com os sinalizadores apropriados, o manipulador de eventos será tratado como uma região de execução restrita.

Este evento não é ativado para exceções que corrompam o estado do processo, como overflows de pilha ou violações de acesso, a menos que o gestor de eventos seja crítico para a segurança e tenha o HandleProcessCorruptedStateExceptionsAttribute atributo.

Para registar um manipulador de eventos para este evento, é necessário ter as permissões requeridas, caso contrário, ocorre um erro SecurityException.

Para obter mais informações sobre como manipular eventos, consulte Manipulando e gerando eventos.

Outros eventos para exceções não tratadas

Para determinados modelos de aplicação, o UnhandledException evento pode ser preemptado por outros eventos se a exceção não tratada ocorrer na thread principal da aplicação.

Em aplicativos que usam Windows Forms, exceções não tratadas no thread principal do aplicativo fazem com que o Application.ThreadException evento seja gerado. Se esse evento for manipulado, o comportamento padrão é que a exceção sem tratamento não encerra o aplicativo, embora o aplicativo seja deixado em um estado desconhecido. Nesse caso, o evento UnhandledException não é levantado. Esse comportamento pode ser alterado usando o arquivo de configuração do aplicativo ou usando o Application.SetUnhandledExceptionMode método para alterar o modo para UnhandledExceptionMode.ThrowException antes que o ThreadException manipulador de eventos seja conectado. Isso se aplica somente ao thread principal do aplicativo. O UnhandledException evento é gerado para exceções não tratadas lançadas em outros threads.

A estrutura do aplicativo Visual Basic fornece outro evento para exceções não tratadas no thread principal do aplicativo — o WindowsFormsApplicationBase.UnhandledException evento. Esse evento tem um objeto de argumentos de evento com o mesmo nome que o objeto de argumentos de evento usado pela AppDomain.UnhandledException, mas com propriedades diferentes. Em particular, esse objeto de argumentos de evento tem uma ExitApplication propriedade que permite que o aplicativo continue em execução, ignorando a exceção não tratada (e deixando o aplicativo em um estado desconhecido). Nesse caso, o evento AppDomain.UnhandledException não é levantado.