Leer en inglés

Compartir a través de

MethodBody Clase

  • Referencia

Definición

Espacio de nombres:
System.Reflection
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll
Source:
MethodBody.cs
Source:
MethodBody.cs
Source:
MethodBody.cs

Proporciona acceso a los metadatos y al lenguaje MSIL del cuerpo de un método.

public class MethodBody
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBody
[System.Runtime.InteropServices.ComVisible(true)]
public class MethodBody
Herencia
Object
MethodBody
Atributos
ComVisibleAttribute

Ejemplos

En el ejemplo de código siguiente se define un método de prueba denominado MethodBodyExample y se muestra su información de variable 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.

En el ejemplo se usa la LocalVariables propiedad para obtener una lista de LocalVariableInfo objetos y, a continuación, se muestran sus tipos y orden de índice. La ExceptionHandlingClauses propiedad se usa para obtener una lista de cláusulas de control de excepciones.

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

        // Display information about the local variables in the
        // method body.
        Console.WriteLine();
        foreach (LocalVariableInfo lvi in mb.LocalVariables)
        {
            Console.WriteLine("Local variable: {0}", lvi);
        }

        // 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);
        }
    }

    // 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
//
//Local variable: System.Int32 (0)
//Local variable: System.String (1)
//Local variable: System.Exception (2)
//Local variable: System.Boolean (3)
//
//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

La MethodBody clase proporciona acceso a información sobre las variables locales y las cláusulas de control de excepciones en un cuerpo del método y al lenguaje intermedio de Microsoft (MSIL) que constituye el cuerpo del método.

Puede usar los métodos de resolución de tokens de la clase de módulo, como ResolveType, ResolveMethody ResolveType, para resolver los tokens del cuerpo Type del método en objetos, MethodInfo objetos y FieldInfo objetos que proporcionan información detallada sobre los tipos, métodos y campos a los que accede el MSIL en el cuerpo del método.

Nota

El análisis de los cuerpos del método requiere un conocimiento exhaustivo de los metadatos y los formatos de instrucción 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".

Para obtener un MethodBody objeto para un método determinado, primero obtenga un MethodInfo objeto para el método y, a continuación, llame al MethodInfo método del GetMethodBody objeto.

Constructores

MethodBody()

Inicializa una nueva instancia de la clase MethodBody.

Propiedades

ExceptionHandlingClauses

Obtiene una lista que incluye todas las cláusulas de control de excepciones en el cuerpo del método.
InitLocals

Obtiene un valor que indica si las variables locales en el cuerpo del método se inicializan en los valores predeterminados de sus tipos.
LocalSignatureMetadataToken

Obtiene un token de metadatos para la firma que describe las variables locales del método en los metadatos.
LocalVariables

Obtiene la lista de variables locales declaradas en el cuerpo del método.
MaxStackSize

Obtiene el número máximo de elementos en la pila de operandos cuando el método se está ejecutando.

Métodos

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetILAsByteArray()

Devuelve el lenguaje MSIL del cuerpo del método como una matriz de bytes.
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)

Se aplica a

Producto Versiones
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1