Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase MethodBody

 

Publicado: octubre de 2016

Proporciona acceso a los metadatos y MSIL para el cuerpo de un método.

Espacio de nombres:   System.Reflection
Ensamblado:  mscorlib (en mscorlib.dll)

System.Object
  System.Reflection.MethodBody

[ComVisibleAttribute(true)]
public class MethodBody

NombreDescripción
System_CAPS_protmethodMethodBody()

Inicializa una nueva instancia de la clase MethodBody.

NombreDescripción
System_CAPS_pubpropertyExceptionHandlingClauses

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

System_CAPS_pubpropertyInitLocals

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

System_CAPS_pubpropertyLocalSignatureMetadataToken

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

System_CAPS_pubpropertyLocalVariables

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

System_CAPS_pubpropertyMaxStackSize

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

NombreDescripción
System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetILAsByteArray()

Devuelve el código de MSIL para el cuerpo del método, como una matriz de bytes.

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

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

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

System_CAPS_noteNota

Para analizar los cuerpos de los métodos, es preciso conocer a fondo los metadatos y formatos de instrucciones del lenguaje MSIL. Puede encontrar información en la documentación de Common Language Infrastructure (CLI), especialmente en "Partición II: definición y semántica de los metadatos" y "Partition III: CIL Instruction Set". La documentación está disponible en línea; consulte ECMA C# and Common Language Infrastructure Standards en MSDN y Standard ECMA-335 - Common Language Infrastructure (CLI) en el sitio Web de Ecma International.

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

En el ejemplo de código siguiente se define un método de prueba denominado MethodBodyExample y muestra su información de variables locales y cláusulas de control de excepciones. El MethodBase.GetMethodBody método se utiliza para obtener un MethodBody objeto para el método de prueba.

El ejemplo utiliza el LocalVariables propiedad para obtener una lista de LocalVariableInfo objetos y, a continuación, muestra sus tipos y orden de índice. El ExceptionHandlingClauses propiedad se utiliza para obtener una lista de cláusulas de control de excepciones.

System_CAPS_noteNota

No todos los lenguajes de programación pueden generar ExceptionHandlingClauseOptions.Filter cláusulas. El ejemplo de Visual Basic muestra una cláusula de filtro, utilizando Visual Basic When expresión, que se omite en los ejemplos de otros lenguajes.

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.");
            }        
        }

        // There is no Filter clause in this code example. See the Visual 
        // Basic code for an example of a Filter clause.

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

.NET Framework
Disponible desde 2.0

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: