UnhandledExceptionEventArgs.ExceptionObject Eigenschaft

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

public object ExceptionObject { get; }

member this.ExceptionObject : obj

Public ReadOnly Property ExceptionObject As Object

Eigenschaftswert

Das nicht behandelte Ausnahmeobjekt.

Beispiele

Im folgenden Beispiel wird das UnhandledException -Ereignis veranschaulicht. Es definiert einen Ereignishandler, MyHandler, der aufgerufen wird, wenn eine nicht behandelte Ausnahme in der Standardanwendungsdomäne ausgelöst wird. Anschließend werden zwei Ausnahmen ausgelöst. Die erste wird von einem try/catch-Block behandelt. Die zweite wird nicht behandelt und ruft die MyHandle Routine auf, bevor die Anwendung beendet wird.

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

Hinweise

Diese Eigenschaft gibt ein Objekt vom Typ Object zurück, nicht eines, das von abgeleitet wird Exception. Obwohl die Common Language Specification erfordert, dass alle Ausnahmetypen von Exceptionabgeleitet werden, ist es möglich, dass Methoden Ausnahmen mit Objekten auslösen, die nicht von Exceptionabgeleitet sind. Sie können die folgenden Schritte ausführen, um mit dieser Ausnahme zu arbeiten:

• Wenden Sie das RuntimeCompatibilityAttribute Attribut mit dem RuntimeCompatibilityAttribute.WrapNonExceptionThrows Wert von true auf die Assembly an, die den Ereignishandler enthält. Dadurch werden alle Ausnahmen umgebrochen, die nicht von der Exception -Klasse in einem RuntimeWrappedException -Objekt abgeleitet sind. Sie können dann das von dieser Eigenschaft zurückgegebene Objekt sicher (in C#) umwandeln oder (in Visual Basic) in ein Exception -Objekt konvertieren und das ursprüngliche Ausnahmeobjekt aus der RuntimeWrappedException.WrappedException -Eigenschaft abrufen. Beachten Sie, dass einige Compiler, z. B. die C#- und Visual Basic-Compiler, dieses Attribut automatisch anwenden.

• Wandeln Sie das von dieser Eigenschaft zurückgegebene Objekt in ein -Objekt um Exception .

Gilt für:

Weitere Informationen

• RuntimeCompatibilityAttribute
• RuntimeWrappedException