UnhandledExceptionEventArgs.ExceptionObject Vlastnost

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

UnhandledExceptionEventArgs.cs

Získá neošetřený objekt výjimky.

public:
 property System::Object ^ ExceptionObject { System::Object ^ get(); };

public object ExceptionObject { get; }

member this.ExceptionObject : obj

Public ReadOnly Property ExceptionObject As Object

Hodnota vlastnosti

Object

Neošetřený objekt výjimky.

Příklady

Následující příklad ukazuje UnhandledException událost. Definuje obslužnou rutinu události, MyHandlerkterá se vyvolá při každém neošetřené výjimce vyvolá ve výchozí doméně aplikace. Potom vyvolá dvě výjimky. První je zpracován blokem try/catch . Druhá je neošetřená a vyvolá rutinu MyHandle před ukončením aplikace.

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

Poznámky

Tato vlastnost vrátí objekt typu Object , nikoli objekt odvozený z Exception. Ačkoli specifikace běžného jazyka vyžaduje, aby všechny typy výjimek odvozeny z Exception, je možné metody vyvolat výjimky s objekty, které nejsou odvozeny z Exception. S touto výjimkou můžete pracovat takto:

• RuntimeCompatibilityAttribute Použijte atribut s RuntimeCompatibilityAttribute.WrapNonExceptionThrows hodnotou true sestavení, která obsahuje obslužnou rutinu události. Tím se zabalí všechny výjimky, které nejsou odvozené z Exception třídy v objektu RuntimeWrappedException . Pak můžete bezpečně přetypovat (v jazyce C#) nebo převést (v jazyce Visual Basic) objekt vrácený touto vlastností na Exception objekt a načíst původní objekt výjimky z RuntimeWrappedException.WrappedException vlastnosti. Všimněte si, že některé kompilátory, například kompilátory jazyka C# a Visual Basic, automaticky používají tento atribut.

• Přetypujte objekt vrácený touto vlastností na Exception objekt.

Viz také

• RuntimeCompatibilityAttribute
• RuntimeWrappedException