UnhandledExceptionEventArgs.ExceptionObject Propiedad

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

UnhandledExceptionEventArgs.cs

Obtiene el objeto de excepción no controlado.

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

public object ExceptionObject { get; }

member this.ExceptionObject : obj

Public ReadOnly Property ExceptionObject As Object

Valor de propiedad

Object

Objeto de excepción no controlado.

Ejemplos

En el ejemplo siguiente se muestra el UnhandledException evento . Define un controlador de eventos, MyHandler, que se invoca cada vez que se produce una excepción no controlada en el dominio de aplicación predeterminado. A continuación, produce dos excepciones. La primera se controla mediante un bloque try/catch . El segundo no está controlado e invoca la MyHandle rutina antes de que finalice la aplicación.

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

Comentarios

Esta propiedad devuelve un objeto de tipo Object en lugar de uno derivado de Exception. Aunque Common Language Specification requiere que todos los tipos de excepción deriven de Exception, es posible que los métodos inicien excepciones con objetos no derivados de Exception. Puede hacer lo siguiente para trabajar con esta excepción:

• Aplique el RuntimeCompatibilityAttribute atributo con un RuntimeCompatibilityAttribute.WrapNonExceptionThrows valor de true al ensamblado que contiene el controlador de eventos. Esto encapsula todas las excepciones no derivadas de la Exception clase en un RuntimeWrappedException objeto . A continuación, puede convertir de forma segura (en C#) o convertir (en Visual Basic) el objeto devuelto por esta propiedad en un Exception objeto y recuperar el objeto de excepción original de la RuntimeWrappedException.WrappedException propiedad . Tenga en cuenta que algunos compiladores, como los compiladores de C# y Visual Basic, aplican automáticamente este atributo.

• Convierta el objeto devuelto por esta propiedad en un Exception objeto .

Consulte también

• RuntimeCompatibilityAttribute
• RuntimeWrappedException