AppDomain.UnhandledException Gebeurtenis

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 

Gebeurtenistype

Implementeringen

Kenmerken

SecurityCriticalAttribute

Voorbeelden

In het volgende voorbeeld ziet u de UnhandledException gebeurtenis. Het definieert een gebeurtenis-handler, MyHandlerdie wordt aangeroepen wanneer een niet-verwerkte uitzondering wordt gegenereerd in het standaardtoepassingsdomein. Vervolgens worden er twee uitzonderingen gemaakt. De eerste wordt verwerkt door een try/catch-blok . De tweede is niet verwerkt en roept de MyHandle routine aan voordat de toepassing wordt beëindigd.

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

Opmerkingen

Handlers kunnen meerdere keren worden aangeroepen als er uitzonderingen worden gegenereerd vanuit verschillende threads.

De UnhandledException gebeurtenis geeft een melding over onopgevangen uitzonderingen. Hiermee kan de toepassing informatie over de uitzondering registreren voordat de standaardhandler van het systeem de uitzondering rapporteert aan de gebruiker en de toepassing beëindigt. Als er voldoende informatie over de status van de toepassing beschikbaar is, kunnen andere acties worden uitgevoerd, zoals het opslaan van programmagegevens voor later herstel. Let op, want programmagegevens kunnen beschadigd raken wanneer er geen uitzonderingen worden verwerkt. De handler wordt ook uitgevoerd terwijl de vergrendelingen die werden vastgehouden toen de uitzondering optrad, behouden blijven. Zorg er dus voor dat u vermijdt te wachten op andere resources die tot deadlocks kunnen leiden.

Deze gebeurtenis kan worden verwerkt in elk toepassingsdomein. De gebeurtenis wordt echter niet noodzakelijkerwijs gegenereerd in het toepassingsdomein waar de uitzondering is opgetreden. Een uitzondering is alleen niet verwerkt als de hele stack voor de thread niet is afgewikkeld zonder een toepasselijke uitzonderingshandler te vinden, dus de eerste plaats waar de gebeurtenis kan worden gegenereerd, bevindt zich in het toepassingsdomein waar de thread vandaan komt.

Als de UnhandledException gebeurtenis wordt verwerkt in het standaardtoepassingsdomein, wordt deze daar gegenereerd voor een niet-verwerkte uitzondering in een thread, ongeacht het toepassingsdomein waarin de thread is gestart. Als de thread is gestart in een toepassingsdomein waarvoor een gebeurtenis-handler UnhandledExceptionis opgegeven, wordt de gebeurtenis gegenereerd in dat toepassingsdomein. Als dat toepassingsdomein niet het standaardtoepassingsdomein is en er ook een gebeurtenis-handler is in het standaardtoepassingsdomein, wordt de gebeurtenis gegenereerd in beide toepassingsdomeinen.

Stel dat een thread wordt gestart in het toepassingsdomein AD1, een methode aanroept in het toepassingsdomein AD2 en daar een methode aanroept in het toepassingsdomein AD3, waarbij er een uitzondering wordt gegenereerd. Het eerste toepassingsdomein waarin de UnhandledException gebeurtenis kan worden gegenereerd, is AD1. Als dat toepassingsdomein niet het standaardtoepassingsdomein is, kan de gebeurtenis ook worden gegenereerd in het standaardtoepassingsdomein.

Als de gebeurtenis-handler een ReliabilityContractAttribute kenmerk heeft met de juiste vlaggen, wordt de gebeurtenis-handler behandeld als een beperkte uitvoeringsregio.

Deze gebeurtenis wordt niet gegenereerd voor uitzonderingen die de status van het proces beschadigen, zoals stack-overflows of toegangsschendingen, tenzij de gebeurtenis-handler beveiligingskritiek is en het HandleProcessCorruptedStateExceptionsAttribute kenmerk heeft.

Als u een gebeurtenis-handler voor deze gebeurtenis wilt registreren, moet u over de vereiste machtigingen beschikken, anders wordt er een uitzondering SecurityException gegenereerd.

Zie Gebeurtenissen verwerken en genereren voor meer informatie over het afhandelen van gebeurtenissen.

Andere gebeurtenissen voor niet-verwerkte uitzonderingen

Voor bepaalde toepassingsmodellen kan de UnhandledException gebeurtenis worden afgewend door andere gebeurtenissen als de niet-verwerkte uitzondering optreedt in de hoofdtoepassingsthread.

In toepassingen die Gebruikmaken van Windows Forms, worden niet-verwerkte uitzonderingen in de hoofdtoepassingsthread veroorzaakt dat de Application.ThreadException gebeurtenis wordt gegenereerd. Als deze gebeurtenis wordt verwerkt, is het standaardgedrag dat de niet-verwerkte uitzondering de toepassing niet beëindigt, hoewel de toepassing een onbekende status heeft. In dat geval wordt de UnhandledException gebeurtenis niet gegenereerd. Dit gedrag kan worden gewijzigd met behulp van het toepassingsconfiguratiebestand of door de Application.SetUnhandledExceptionMode methode te gebruiken om de modus te wijzigen in UnhandledExceptionMode.ThrowException voordat de ThreadException gebeurtenis-handler wordt gekoppeld. Dit geldt alleen voor de hoofd-toepassingsthread. De UnhandledException gebeurtenis wordt gegenereerd voor niet-afgehandelde uitzonderingen die in andere threads optreden.

Het Visual Basic-toepassingsframework biedt een andere gebeurtenis voor niet-verwerkte uitzonderingen in de hoofdtoepassingsthread: de WindowsFormsApplicationBase.UnhandledException gebeurtenis. Deze gebeurtenis heeft een gebeurtenisargumentobject met dezelfde naam als het object gebeurtenisargumenten dat wordt gebruikt door AppDomain.UnhandledException, maar met verschillende eigenschappen. Dit gebeurtenisargumentenobject heeft met name een ExitApplication eigenschap waarmee de toepassing kan blijven worden uitgevoerd, waarbij de niet-verwerkte uitzondering wordt genegeerd (en de toepassing in een onbekende status blijft). In dat geval wordt de AppDomain.UnhandledException gebeurtenis niet gegenereerd.