ExceptionHandlingClauseOptions Enumeración

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Identifica los tipos de cláusulas de control de excepciones.

Esta enumeración admite una combinación bit a bit de sus valores de miembro.

C#

[System.Flags]
public enum ExceptionHandlingClauseOptions

Herencia

Object

ValueType

Enum

ExceptionHandlingClauseOptions

Atributos

FlagsAttribute

Campos

Nombre	Valor	Description
Clause	0	La cláusula acepta todas las excepciones que derivan de un tipo especificado.
Fault	4	La cláusula se ejecuta si ocurre una excepción, pero no en la finalización del flujo de control normal.
Filter	1	La cláusula contiene instrucciones especificadas por el usuario que determinan si se debe omitir la excepción (es decir, si se tiene que reanudar la ejecución normal), si la debe administrar el controlador asociado o si hay que pasarla a la siguiente cláusula.
Finally	2	La cláusula se ejecuta siempre que se cierra el bloque Try, a través del flujo de control normal o debido a una excepción no controlada.

Ejemplos

En el ejemplo de código siguiente se define un método de prueba denominado MethodBodyExampley se muestran la información de variables local y las cláusulas de control de excepciones. El MethodBase.GetMethodBody método se usa para obtener un MethodBody objeto para el método de prueba. La ExceptionHandlingClauses propiedad se usa para obtener una lista de ExceptionHandlingClause objetos y mostrar sus propiedades.

Este código forma parte de un ejemplo más grande proporcionado para la MethodBody clase .

C#

using System;
using System.Reflection;

public class Example
{
    public static void Main()
    {
        // Get method body information.
        MethodInfo mi = typeof(Example).GetMethod("MethodBodyExample");
        MethodBody mb = mi.GetMethodBody();
        Console.WriteLine("\r\nMethod: {0}", mi);

        // Display the general information included in the
        // MethodBody object.
        Console.WriteLine("    Local variables are initialized: {0}",
            mb.InitLocals);
        Console.WriteLine("    Maximum number of items on the operand stack: {0}",
            mb.MaxStackSize);

C#

// Display exception handling clauses.
Console.WriteLine();
foreach (ExceptionHandlingClause ehc in mb.ExceptionHandlingClauses)
{
    Console.WriteLine(ehc.Flags.ToString());

    // The FilterOffset property is meaningful only for Filter
    // clauses. The CatchType property is not meaningful for
    // Filter or Finally clauses.
    switch (ehc.Flags)
    {
        case ExceptionHandlingClauseOptions.Filter:
            Console.WriteLine("        Filter Offset: {0}",
                ehc.FilterOffset);
            break;
        case ExceptionHandlingClauseOptions.Finally:
            break;
        default:
            Console.WriteLine("    Type of exception: {0}",
                ehc.CatchType);
            break;
    }

    Console.WriteLine("       Handler Length: {0}", ehc.HandlerLength);
    Console.WriteLine("       Handler Offset: {0}", ehc.HandlerOffset);
    Console.WriteLine("     Try Block Length: {0}", ehc.TryLength);
    Console.WriteLine("     Try Block Offset: {0}", ehc.TryOffset);
}

C#

    }

    // The Main method contains code to analyze this method, using
    // the properties and methods of the MethodBody class.
    public void MethodBodyExample(object arg)
    {
        // Define some local variables. In addition to these variables,
        // the local variable list includes the variables scoped to
        // the catch clauses.
        int var1 = 42;
        string var2 = "Forty-two";

        try
        {
            // Depending on the input value, throw an ArgumentException or
            // an ArgumentNullException to test the Catch clauses.
            if (arg == null)
            {
                throw new ArgumentNullException("The argument cannot be null.");
            }
            if (arg.GetType() == typeof(string))
            {
                throw new ArgumentException("The argument cannot be a string.");
            }
        }

        // This filter clause selects only exceptions that derive
        // from the ArgumentException class.
        // Other exceptions, including ArgumentException itself,
        // are not handled by this filter clause.
        catch (ArgumentException ex) when (ex.GetType().IsSubclassOf(typeof(ArgumentException)))
        {
            Console.WriteLine("Filter clause caught: {0}", ex.GetType());
        }

        // This catch clause handles the ArgumentException class, and
        // any other class derived from Exception.
        catch(Exception ex)
        {
            Console.WriteLine("Ordinary exception-handling clause caught: {0}",
                ex.GetType());
        }
        finally
        {
            var1 = 3033;
            var2 = "Another string.";
        }
    }
}

// This code example produces output similar to the following:
//
//Method: Void MethodBodyExample(System.Object)
//    Local variables are initialized: True
//    Maximum number of items on the operand stack: 2

C#

//
//Filter
//      Filter Offset: 71
//      Handler Length: 23
//      Handler Offset: 116
//      Try Block Length: 61
//      Try Block Offset: 10
//Clause
//    Type of exception: System.Exception
//       Handler Length: 21
//       Handler Offset: 70
//     Try Block Length: 61
//     Try Block Offset: 9
//Finally
//       Handler Length: 14
//       Handler Offset: 94
//     Try Block Length: 85
//     Try Block Offset: 9

Comentarios

Para examinar las cláusulas de control de excepciones en un método, obtenga un MethodInfo objeto y llame al GetMethodBody método para obtener el cuerpo del método. Utilice la ExceptionHandlingClauses propiedad para obtener una lista de ExceptionHandlingClause objetos.

Nota

Trabajar con cláusulas de control de excepciones requiere un conocimiento exhaustivo de los metadatos y los formatos de instrucciones de lenguaje intermedio de Microsoft (MSIL). Puede encontrar información en la documentación de Common Language Infrastructure (CLI), especialmente "Partición II: Definición de metadatos y Semántica".

Se aplica a

Consulte también

• MethodBody
• ExceptionHandlingClause