AppDomain.UnhandledException Esemény

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

AppDomain.cs

Akkor fordul elő, ha a rendszer nem kap kivételt.

public:
 event UnhandledExceptionEventHandler ^ UnhandledException;

public event UnhandledExceptionEventHandler? UnhandledException;

member this.UnhandledException : UnhandledExceptionEventHandler 

Public Custom Event UnhandledException As UnhandledExceptionEventHandler 

Eseménytípus

UnhandledExceptionEventHandler

Példák

Az alábbi példa az eseményt UnhandledException mutatja be. Egy eseménykezelőt határoz meg, amely akkor lesz meghívva, MyHandleramikor nem kezelt kivétel kerül az alapértelmezett alkalmazástartományba. Ezután két kivételt vet ki. Az elsőt egy próba/fogási blokk kezeli. A második nincs kezelve, és meghívja a MyHandle rutint az alkalmazás leállása előtt.

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

Megjegyzések

A kezelők többször is meghívhatók, ha a különböző szálak kivételeket eredményeznek.

Az UnhandledException esemény értesítést küld a fel nem merült kivételekről. Ez lehetővé teszi, hogy az alkalmazás naplózza a kivétel adatait, mielőtt a rendszer alapértelmezett kezelője jelenti a kivételt a felhasználónak, és leállítja az alkalmazást. Ha elegendő információ áll rendelkezésre az alkalmazás állapotáról, más műveleteket is végrehajthat, például programadatok mentését a későbbi helyreállításhoz. Óvatosságra van szükség, mert a programadatok megsérülhetnek, ha a kivételeket nem kezelik. A kezelő a zárolásokat tartva fut, amelyeket a kivétel kivetésekor tartott, ezért ügyelni kell arra, hogy ne várakozzon más erőforrásokon, amelyek holtpontot okozhatnak.

Ez az esemény bármely alkalmazástartományban kezelhető. Az esemény azonban nem feltétlenül abban az alkalmazástartományban jelentkezik, ahol a kivétel történt. A kivétel kezelése csak akkor történik meg, ha a szál teljes veremét feloldották, és nem talál megfelelő kivételkezelőt, így az esemény első helye abban az alkalmazástartományban van, ahonnan a szál származik.

Ha a UnhandledException eseményt az alapértelmezett alkalmazástartományban kezeli a rendszer, akkor bármelyik szál nem kezelt kivétele esetén ott kerül előállításra, függetlenül attól, hogy a szál melyik alkalmazástartományban indult el. Ha a szál olyan alkalmazástartományban indult el, amelynek eseménykezelője UnhandledExceptionvan, az esemény az adott alkalmazástartományban lesz elindítva. Ha ez az alkalmazástartomány nem az alapértelmezett alkalmazástartomány, és az alapértelmezett alkalmazástartományban is van eseménykezelő, az esemény mindkét alkalmazástartományban létrejön.

Tegyük fel például, hogy egy szál az "AD1" alkalmazástartományban kezdődik, meghív egy metódust az "AD2" alkalmazástartományban, és onnan meghív egy metódust az "AD3" alkalmazástartományban, ahol kivételt jelez. Az első alkalmazástartomány, amelyben az UnhandledException eseményt elő lehet emelni, az "AD1". Ha ez az alkalmazástartomány nem az alapértelmezett alkalmazástartomány, az esemény az alapértelmezett alkalmazástartományban is előhozható.

Megjegyzés:

A közös nyelvi futtatókörnyezet felfüggeszti a szál megszakításait, miközben az UnhandledException esemény eseménykezelői futnak.

Ha az eseménykezelő rendelkezik a ReliabilityContractAttribute megfelelő jelzőkkel rendelkező attribútummal, az eseménykezelő korlátozott végrehajtási régióként lesz kezelve.

Ez az esemény nem merül fel olyan kivételek esetén, amelyek a folyamat állapotát rontják, például a verem túlcsordulása vagy a hozzáférés megsértései, kivéve, ha az eseménykezelő biztonsági szempontból kritikus fontosságú, és rendelkezik az HandleProcessCorruptedStateExceptionsAttribute attribútummal.

Ahhoz, hogy eseménykezelőt regisztráljon az eseményhez, rendelkeznie kell a szükséges engedélyekkel, vagy ki kell dobni egy SecurityException eseményt.

Az események kezelésével kapcsolatos további információkért lásd : Események kezelése és emelése.

Egyéb események kezeletlen kivételek esetén

Bizonyos alkalmazásmodellek esetében az UnhandledException eseményt más események is elővehetik, ha a kezeletlen kivétel a fő alkalmazásszálban fordul elő.

A Windows Formst használó alkalmazásokban a fő alkalmazásszálban nem kezelt kivételek okozzák az Application.ThreadException eseményt. Az esemény kezelésekor az alapértelmezett viselkedés az, hogy a kezeletlen kivétel nem szünteti meg az alkalmazást, bár az alkalmazás ismeretlen állapotban marad. Ebben az esetben az UnhandledException esemény nem merül fel. Ez a viselkedés megváltoztatható az alkalmazáskonfigurációs fájl vagy az Application.SetUnhandledExceptionMode metódus használatával, hogy UnhandledExceptionMode.ThrowException módra váltson, mielőtt az ThreadException eseménykezelőt csatlakoztatják. Ez csak a fő alkalmazásszálra vonatkozik. Az UnhandledException esemény a más szálakba vetett kezeletlen kivételek esetén jön létre.

A Visual Basic alkalmazás-keretrendszer egy másik eseményt biztosít a fő alkalmazásszál nem kezelt kivételeihez – az WindowsFormsApplicationBase.UnhandledException eseményhez. Az esemény egy olyan eseményargumentum-objektummal rendelkezik, amelynek neve megegyezik a használt AppDomain.UnhandledExceptioneseményargumentum-objektum nevével, de különböző tulajdonságokkal rendelkezik. Ez az eseményargumentum-objektum rendelkezik olyan ExitApplication tulajdonságmal, amely lehetővé teszi az alkalmazás futtatását, figyelmen kívül hagyva a kezeletlen kivételt (és ismeretlen állapotban hagyja az alkalmazást). Ebben az esetben az AppDomain.UnhandledException esemény nem merül fel.