DynamicMethod Clase

Definición

Define y representa un método dinámico que se puede compilar, ejecutar y descartar.Defines and represents a dynamic method that can be compiled, executed, and discarded. Los métodos descartados están disponibles para la recolección de elementos no utilizados.Discarded methods are available for garbage collection.

public ref class DynamicMethod sealed : System::Reflection::MethodInfo
public sealed class DynamicMethod : System.Reflection.MethodInfo
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : System.Reflection.MethodInfo
type DynamicMethod = class
    inherit MethodInfo
[<System.Runtime.InteropServices.ComVisible(true)>]
type DynamicMethod = class
    inherit MethodInfo
Public NotInheritable Class DynamicMethod
Inherits MethodInfo
Herencia
Atributos

Ejemplos

En el ejemplo de código siguiente se crea un método dinámico que toma dos parámetros.The following code example creates a dynamic method that takes two parameters. En el ejemplo se emite un cuerpo de función simple que imprime el primer parámetro en la consola y el ejemplo usa el segundo parámetro como el valor devuelto del método.The example emits a simple function body that prints the first parameter to the console, and the example uses the second parameter as the return value of the method. En el ejemplo se completa el método mediante la creación de un delegado, se invoca al delegado con distintos parámetros y, por último, se invoca el método dinámico mediante el Invoke método.The example completes the method by creating a delegate, invokes the delegate with different parameters, and finally invokes the dynamic method using the Invoke method.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Globalization;

// Declare a delegate type that can be used to execute the completed
// dynamic method. 
private delegate int HelloDelegate(String^ msg, int ret);

void main()
{
    // Create an array that specifies the types of the parameters
    // of the dynamic method. This dynamic method has a String
    // parameter and an Integer parameter.
    array<Type^>^ helloArgs = { String::typeid, int::typeid };

    // Create a dynamic method with the name "Hello", a return type
    // of Integer, and two parameters whose types are specified by
    // the array helloArgs. Create the method in the module that
    // defines the String class.
    DynamicMethod^ hello = gcnew DynamicMethod("Hello", 
        int::typeid, 
        helloArgs, 
        String::typeid->Module);

    // Create an array that specifies the parameter types of the
    // overload of Console::WriteLine to be used in Hello.
    array<Type^>^ writeStringArgs = { String::typeid };
    // Get the overload of Console::WriteLine that has one
    // String parameter.
    MethodInfo^ writeString = Console::typeid->GetMethod("WriteLine", 
        writeStringArgs);

    // Get an ILGenerator and emit a body for the dynamic method,
    // using a stream size larger than the IL that will be
    // emitted.
    ILGenerator^ il = hello->GetILGenerator(256);
    // Load the first argument, which is a string, onto the stack.
    il->Emit(OpCodes::Ldarg_0);
    // Call the overload of Console::WriteLine that prints a string.
    il->EmitCall(OpCodes::Call, writeString, nullptr);
    // The Hello method returns the value of the second argument;
    // to do this, load the onto the stack and return.
    il->Emit(OpCodes::Ldarg_1);
    il->Emit(OpCodes::Ret);

    // Add parameter information to the dynamic method. (This is not
    // necessary, but can be useful for debugging.) For each parameter,
    // identified by position, supply the parameter attributes and a 
    // parameter name.
    hello->DefineParameter(1, ParameterAttributes::In, "message");
    hello->DefineParameter(2, ParameterAttributes::In, "valueToReturn");

    // Create a delegate that represents the dynamic method. This
    // action completes the method. Any further attempts to
    // change the method are ignored.
    HelloDelegate^ hi = 
        (HelloDelegate^) hello->CreateDelegate(HelloDelegate::typeid);

    // Use the delegate to execute the dynamic method.
    Console::WriteLine("\r\nUse the delegate to execute the dynamic method:");
    int retval = hi("\r\nHello, World!", 42);
    Console::WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

    // Execute it again, with different arguments.
    retval = hi("\r\nHi, Mom!", 5280);
    Console::WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

    Console::WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
    // Create an array of arguments to use with the Invoke method.
    array<Object^>^ invokeArgs = { "\r\nHello, World!", 42 };
    // Invoke the dynamic method using the arguments. This is much
    // slower than using the delegate, because you must create an
    // array to contain the arguments, and value-type arguments
    // must be boxed.
    Object^ objRet = hello->Invoke(nullptr, BindingFlags::ExactBinding, nullptr, invokeArgs, gcnew CultureInfo("en-us"));
    Console::WriteLine("hello.Invoke returned: " + objRet);

    Console::WriteLine("\r\n ----- Display information about the dynamic method -----");
    // Display MethodAttributes for the dynamic method, set when 
    // the dynamic method was created.
    Console::WriteLine("\r\nMethod Attributes: {0}", hello->Attributes);

    // Display the calling convention of the dynamic method, set when the 
    // dynamic method was created.
    Console::WriteLine("\r\nCalling convention: {0}", hello->CallingConvention);

    // Display the declaring type, which is always null for dynamic
    // methods.
    if (hello->DeclaringType == nullptr)
    {
        Console::WriteLine("\r\nDeclaringType is always null for dynamic methods.");
    }
    else
    {
        Console::WriteLine("DeclaringType: {0}", hello->DeclaringType);
    }

    // Display the default value for InitLocals.
    if (hello->InitLocals)
    {
        Console::Write("\r\nThis method contains verifiable code.");
    }
    else
    {
        Console::Write("\r\nThis method contains unverifiable code.");
    }
    Console::WriteLine(" (InitLocals = {0})", hello->InitLocals);

    // Display the module specified when the dynamic method was created.
    Console::WriteLine("\r\nModule: {0}", hello->Module);

    // Display the name specified when the dynamic method was created.
    // Note that the name can be blank.
    Console::WriteLine("\r\nName: {0}", hello->Name);

    // For dynamic methods, the reflected type is always null.
    if (hello->ReflectedType == nullptr)
    {
        Console::WriteLine("\r\nReflectedType is null.");
    }
    else
    {
        Console::WriteLine("\r\nReflectedType: {0}", hello->ReflectedType);
    }

    if (hello->ReturnParameter == nullptr)
    {
        Console::WriteLine("\r\nMethod has no return parameter.");
    }
    else
    {
        Console::WriteLine("\r\nReturn parameter: {0}", hello->ReturnParameter);
    }

    // If the method has no return type, ReturnType is System.Void.
    Console::WriteLine("\r\nReturn type: {0}", hello->ReturnType);

    // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
    // that can be used to enumerate the custom attributes of the
    // return value. At present, there is no way to set such custom
    // attributes, so the list is empty.
    if (hello->ReturnType == Void::typeid)
    {
        Console::WriteLine("The method has no return type.");
    }
    else
    {
        ICustomAttributeProvider^ caProvider = hello->ReturnTypeCustomAttributes;
        array<Object^>^ returnAttributes = caProvider->GetCustomAttributes(true);
        if (returnAttributes->Length == 0)
        {
            Console::WriteLine("\r\nThe return type has no custom attributes.");
        }
        else
        {
            Console::WriteLine("\r\nThe return type has the following custom attributes:");
            for each (Object^ attr in returnAttributes)
            {
                Console::WriteLine("\t{0}", attr->ToString());
            }
        }
    }

    Console::WriteLine("\r\nToString: {0}", hello->ToString());

    // Display parameter information.
    array<ParameterInfo^>^ parameters = hello->GetParameters();
    Console::WriteLine("\r\nParameters: name, type, ParameterAttributes");
    for each (ParameterInfo^ p in parameters)
    {
        Console::WriteLine("\t{0}, {1}, {2}", 
            p->Name, p->ParameterType, p->Attributes);
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Test
{
    // Declare a delegate type that can be used to execute the completed
    // dynamic method.
    private delegate int HelloDelegate(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This dynamic method has a String
        // parameter and an Integer parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of Integer, and two parameters whose types are specified by
        // the array helloArgs. Create the method in the module that
        // defines the String class.
        DynamicMethod hello = new DynamicMethod("Hello",
            typeof(int),
            helloArgs,
            typeof(string).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString = typeof(Console).GetMethod("WriteLine",
            writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method,
        // using a stream size larger than the IL that will be
        // emitted.
        ILGenerator il = hello.GetILGenerator(256);
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Add parameter information to the dynamic method. (This is not
        // necessary, but can be useful for debugging.) For each parameter,
        // identified by position, supply the parameter attributes and a
        // parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message");
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

        // Create a delegate that represents the dynamic method. This
        // action completes the method. Any further attempts to
        // change the method are ignored.
        HelloDelegate hi =
            (HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));

        // Use the delegate to execute the dynamic method.
        Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

        // Execute it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

        Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = {"\r\nHello, World!", 42};
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and value-type arguments
        // must be boxed.
        object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
        Console.WriteLine("hello.Invoke returned: " + objRet);

        Console.WriteLine("\r\n ----- Display information about the dynamic method -----");
        // Display MethodAttributes for the dynamic method, set when
        // the dynamic method was created.
        Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);

        // Display the calling convention of the dynamic method, set when the
        // dynamic method was created.
        Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);

        // Display the declaring type, which is always null for dynamic
        // methods.
        if (hello.DeclaringType == null)
        {
            Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
        }
        else
        {
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
        }

        // Display the default value for InitLocals.
        if (hello.InitLocals)
        {
            Console.Write("\r\nThis method contains verifiable code.");
        }
        else
        {
            Console.Write("\r\nThis method contains unverifiable code.");
        }
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);

        // Display the module specified when the dynamic method was created.
        Console.WriteLine("\r\nModule: {0}", hello.Module);

        // Display the name specified when the dynamic method was created.
        // Note that the name can be blank.
        Console.WriteLine("\r\nName: {0}", hello.Name);

        // For dynamic methods, the reflected type is always null.
        if (hello.ReflectedType == null)
        {
            Console.WriteLine("\r\nReflectedType is null.");
        }
        else
        {
            Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
        }

        if (hello.ReturnParameter == null)
        {
            Console.WriteLine("\r\nMethod has no return parameter.");
        }
        else
        {
            Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
        }

        // If the method has no return type, ReturnType is System.Void.
        Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);

        // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        // that can be used to enumerate the custom attributes of the
        // return value. At present, there is no way to set such custom
        // attributes, so the list is empty.
        if (hello.ReturnType == typeof(void))
        {
            Console.WriteLine("The method has no return type.");
        }
        else
        {
            ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
            object[] returnAttributes = caProvider.GetCustomAttributes(true);
            if (returnAttributes.Length == 0)
            {
                Console.WriteLine("\r\nThe return type has no custom attributes.");
            }
            else
            {
                Console.WriteLine("\r\nThe return type has the following custom attributes:");
                foreach( object attr in returnAttributes )
                {
                    Console.WriteLine("\t{0}", attr.ToString());
                }
            }
        }

        Console.WriteLine("\r\nToString: {0}", hello.ToString());

        // Display parameter information.
        ParameterInfo[] parameters = hello.GetParameters();
        Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
        foreach( ParameterInfo p in parameters )
        {
            Console.WriteLine("\t{0}, {1}, {2}",
                p.Name, p.ParameterType, p.Attributes);
        }
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Globalization

Public Class Test
    ' Declare a delegate type that can be used to execute the completed
    ' dynamic method. 
    Private Delegate Function HelloDelegate(ByVal msg As String, _
        ByVal ret As Integer) As Integer

    Public Shared Sub Main()
        ' Create an array that specifies the types of the parameters
        ' of the dynamic method. This dynamic method has a String
        ' parameter and an Integer parameter.
        Dim helloArgs() As Type = {GetType(String), GetType(Integer)}

        ' Create a dynamic method with the name "Hello", a return type
        ' of Integer, and two parameters whose types are specified by
        ' the array helloArgs. Create the method in the module that
        ' defines the String class.
        Dim hello As New DynamicMethod("Hello", _
            GetType(Integer), _
            helloArgs, _
            GetType(String).Module)

        ' Create an array that specifies the parameter types of the
        ' overload of Console.WriteLine to be used in Hello.
        Dim writeStringArgs() As Type = {GetType(String)}
        ' Get the overload of Console.WriteLine that has one
        ' String parameter.
        Dim writeString As MethodInfo = GetType(Console). _
            GetMethod("WriteLine", writeStringArgs) 

        ' Get an ILGenerator and emit a body for the dynamic method,
        ' using a stream size larger than the IL that will be
        ' emitted.
        Dim il As ILGenerator = hello.GetILGenerator(256)
        ' Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0)
        ' Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, Nothing)
        ' The Hello method returns the value of the second argument;
        ' to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1)
        il.Emit(OpCodes.Ret)

        ' Add parameter information to the dynamic method. (This is not
        ' necessary, but can be useful for debugging.) For each parameter,
        ' identified by position, supply the parameter attributes and a 
        ' parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message")
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn")

        ' Create a delegate that represents the dynamic method. This
        ' action completes the method. Any further attempts to
        ' change the method are ignored.
    Dim hi As HelloDelegate = _
            CType(hello.CreateDelegate(GetType(HelloDelegate)), HelloDelegate)

        ' Use the delegate to execute the dynamic method.
        Console.WriteLine(vbCrLf & "Use the delegate to execute the dynamic method:")
        Dim retval As Integer = hi(vbCrLf & "Hello, World!", 42)
        Console.WriteLine("Invoking delegate hi(""Hello, World!"", 42) returned: " _
            & retval & ".")

        ' Execute it again, with different arguments.
        retval = hi(vbCrLf & "Hi, Mom!", 5280)
        Console.WriteLine("Invoking delegate hi(""Hi, Mom!"", 5280) returned: " _
            & retval & ".")

        Console.WriteLine(vbCrLf & "Use the Invoke method to execute the dynamic method:")
        ' Create an array of arguments to use with the Invoke method.
        Dim invokeArgs() As Object = {vbCrLf & "Hello, World!", 42}
        ' Invoke the dynamic method using the arguments. This is much
        ' slower than using the delegate, because you must create an
        ' array to contain the arguments, and value-type arguments
        ' must be boxed.
        Dim objRet As Object = hello.Invoke(Nothing, _
            BindingFlags.ExactBinding, Nothing, invokeArgs, _
            New CultureInfo("en-us"))
        Console.WriteLine("hello.Invoke returned: {0}", objRet)

        Console.WriteLine(vbCrLf & _
            " ----- Display information about the dynamic method -----")
        ' Display MethodAttributes for the dynamic method, set when 
        ' the dynamic method was created.
        Console.WriteLine(vbCrLf & "Method Attributes: {0}", _
            hello.Attributes)

        ' Display the calling convention of the dynamic method, set when the 
        ' dynamic method was created.
        Console.WriteLine(vbCrLf & "Calling convention: {0}", _ 
            hello.CallingConvention)

        ' Display the declaring type, which is always Nothing for dynamic
        ' methods.
        If hello.DeclaringType Is Nothing Then
            Console.WriteLine(vbCrLf & "DeclaringType is always Nothing for dynamic methods.")
        Else
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType)
        End If

        ' Display the default value for InitLocals.
        If hello.InitLocals Then
            Console.Write(vbCrLf & "This method contains verifiable code.")
        Else
            Console.Write(vbCrLf & "This method contains unverifiable code.")
        End If
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals)

        ' Display the module specified when the dynamic method was created.
        Console.WriteLine(vbCrLf & "Module: {0}", hello.Module)

        ' Display the name specified when the dynamic method was created.
        ' Note that the name can be blank.
        Console.WriteLine(vbCrLf & "Name: {0}", hello.Name)

        ' For dynamic methods, the reflected type is always Nothing.
        If hello.ReflectedType Is Nothing Then
            Console.WriteLine(vbCrLf & "ReflectedType is Nothing.")
        Else
            Console.WriteLine(vbCrLf & "ReflectedType: {0}", _
                hello.ReflectedType)
        End If

        If hello.ReturnParameter Is Nothing Then
            Console.WriteLine(vbCrLf & "Method has no return parameter.")
        Else
            Console.WriteLine(vbCrLf & "Return parameter: {0}", _
                hello.ReturnParameter)
        End If

        ' If the method has no return type, ReturnType is System.Void.
        Console.WriteLine(vbCrLf & "Return type: {0}", hello.ReturnType)           

        ' ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        ' that can be used to enumerate the custom attributes of the
        ' return value. At present, there is no way to set such custom
        ' attributes, so the list is empty.
        If hello.ReturnType Is GetType(System.Void) Then
            Console.WriteLine("The method has no return type.")
        Else
            Dim caProvider As ICustomAttributeProvider = _
                hello.ReturnTypeCustomAttributes
            Dim returnAttributes() As Object = _
                caProvider.GetCustomAttributes(True)
            If returnAttributes.Length = 0 Then
                Console.WriteLine(vbCrLf _
                    & "The return type has no custom attributes.")
            Else
                Console.WriteLine(vbCrLf _
                    & "The return type has the following custom attributes:")
                For Each attr As Object In returnAttributes
                    Console.WriteLine(vbTab & attr.ToString())
                Next attr
            End If
        End If

        Console.WriteLine(vbCrLf & "ToString: " & hello.ToString())

        ' Display parameter information.
        Dim parameters() As ParameterInfo = hello.GetParameters()
        Console.WriteLine(vbCrLf & "Parameters: name, type, ParameterAttributes")
        For Each p As ParameterInfo In parameters
            Console.WriteLine(vbTab & "{0}, {1}, {2}", _ 
                p.Name, p.ParameterType, p.Attributes)
        Next p
    End Sub
End Class

' This code example produces the following output:
'
'Use the delegate to execute the dynamic method:
'
'Hello, World!
'Invoking delegate hi("Hello, World!", 42) returned: 42.
'
'Hi, Mom!
'Invoking delegate hi("Hi, Mom!", 5280) returned: 5280.
'
'Use the Invoke method to execute the dynamic method:
'
'Hello, World!
'hello.Invoke returned: 42
'
' ----- Display information about the dynamic method -----
'
'Method Attributes: PrivateScope, Public, Static
'
'Calling convention: Standard
'
'DeclaringType is always Nothing for dynamic methods.
'
'This method contains verifiable code. (InitLocals = True)
'
'Module: CommonLanguageRuntimeLibrary
'
'Name: Hello
'
'ReflectedType is Nothing.
'
'Method has no return parameter.
'
'Return type: System.Int32
'
'The return type has no custom attributes.
'
'ToString: Int32 Hello(System.String, Int32)
'
'Parameters: name, type, ParameterAttributes
'        message, System.String, In
'        valueToReturn, System.Int32, In

Comentarios

Puede utilizar la DynamicMethod clase para generar y ejecutar un método en tiempo de ejecución, sin tener que generar un ensamblado dinámico y un tipo dinámico para contener el método.You can use the DynamicMethod class to generate and execute a method at run time, without having to generate a dynamic assembly and a dynamic type to contain the method. El código ejecutable que crea el compilador Just-in-Time (JIT) se recupera cuando DynamicMethod se reclama el objeto.The executable code created by the just-in-time (JIT) compiler is reclaimed when the DynamicMethod object is reclaimed. Los métodos dinámicos son la forma más eficaz de generar y ejecutar pequeñas cantidades de código.Dynamic methods are the most efficient way to generate and execute small amounts of code.

Un método dinámico se puede hospedar de forma anónima o se puede asociar lógicamente a un módulo o a un tipo.A dynamic method can be anonymously hosted, or it can be logically associated with a module or with a type.

  • Si el método dinámico se hospeda de forma anónima, se encuentra en un ensamblado proporcionado por el sistema y, por tanto, está aislado de otro código.If the dynamic method is anonymously hosted, it is located in a system-provided assembly, and therefore is isolated from other code. De forma predeterminada, no tiene acceso a ningún dato no público.By default, it does not have access to any non-public data. Un método dinámico hospedado de forma anónima puede tener capacidad restringida para omitir las comprobaciones de visibilidad del compilador JIT, si se ha concedido ReflectionPermission con la ReflectionPermissionFlag.RestrictedMemberAccess marca.An anonymously hosted dynamic method can have restricted ability to skip the JIT compiler's visibility checks, if it has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag. El nivel de confianza del ensamblado a cuyos miembros no públicos tiene acceso el método dinámico debe ser igual o un subconjunto del nivel de confianza de la pila de llamadas que emitió el método dinámico.The trust level of the assembly whose non-public members are accessed by the dynamic method must be equal to, or a subset of, the trust level of the call stack that emitted the dynamic method. Para obtener más información acerca de los métodos dinámicos hospedados de forma anónima, vea Tutorial: emitir código en escenarios de confianza parcial.For more information about anonymously hosted dynamic methods, see Walkthrough: Emitting Code in Partial Trust Scenarios.

  • Si el método dinámico está asociado a un módulo que se especifica, el método dinámico es realmente globalmente a ese módulo.If the dynamic method is associated with a module that you specify, the dynamic method is effectively global to that module. Puede tener acceso a todos los tipos del módulo y a todos los internal Friend miembros (en Visual Basic) de los tipos.It can access all types in the module and all internal (Friend in Visual Basic) members of the types. Puede asociar un método dinámico a cualquier módulo, independientemente de si creó el módulo, siempre que ReflectionPermission RestrictedMemberAccess la pila de llamadas que incluye el código pueda satisfacer una demanda de con la marca.You can associate a dynamic method with any module, regardless of whether you created the module, provided that a demand for ReflectionPermission with the RestrictedMemberAccess flag can be satisfied by the call stack that includes your code. Si la ReflectionPermissionFlag.MemberAccess marca se incluye en la concesión, el método dinámico puede omitir las comprobaciones de visibilidad del compilador JIT y obtener acceso a los datos privados de todos los tipos declarados en el módulo o en cualquier otro módulo de cualquier ensamblado.If the ReflectionPermissionFlag.MemberAccess flag is included in the grant, the dynamic method can skip the JIT compiler's visibility checks and access the private data of all types declared in the module or in any other module in any assembly.

    Nota

    Cuando se especifica el módulo con el que está asociado un método dinámico, dicho módulo no debe estar en el ensamblado proporcionado por el sistema que se usa para el hospedaje anónimo.When you specify the module with which a dynamic method is associated, that module must not be in the system-provided assembly that is used for anonymous hosting.

  • Si el método dinámico está asociado a un tipo que especifique, tiene acceso a todos los miembros del tipo, sin tener en cuenta el nivel de acceso.If the dynamic method is associated with a type that you specify, it has access to all members of the type, regardless of access level. Además, se pueden omitir las comprobaciones de visibilidad JIT.In addition, JIT visibility checks can be skipped. Esto proporciona al método dinámico acceso a los datos privados de otros tipos declarados en el mismo módulo o en cualquier otro módulo de cualquier ensamblado.This gives the dynamic method access to the private data of other types declared in the same module or in any other module in any assembly. Puede asociar un método dinámico a cualquier tipo, pero se debe conceder el código ReflectionPermission con las RestrictedMemberAccess MemberAccess marcas y.You can associate a dynamic method with any type, but your code must be granted ReflectionPermission with both the RestrictedMemberAccess and MemberAccess flags.

En la tabla siguiente se muestran los tipos y miembros a los que se puede tener acceso a través de un método dinámico hospedado de forma anónima, con y sin comprobaciones de visibilidad JIT, en función de si ReflectionPermission RestrictedMemberAccess se ha concedido con la marca.The following table shows which types and members are accessible to an anonymously hosted dynamic method, with and without JIT visibility checks, depending on whether ReflectionPermission with the RestrictedMemberAccess flag is granted.

Sin RestrictedMemberAccessWithout RestrictedMemberAccess Con RestrictedMemberAccessWith RestrictedMemberAccess
Sin omitir las comprobaciones de visibilidad JITWithout skipping JIT visibility checks Miembros públicos de tipos públicos en cualquier ensamblado.Public members of public types in any assembly. Miembros públicos de tipos públicos en cualquier ensamblado.Public members of public types in any assembly.
Omitir comprobaciones de visibilidad JIT, con restriccionesSkipping JIT visibility checks, with restrictions Miembros públicos de tipos públicos en cualquier ensamblado.Public members of public types in any assembly. Todos los miembros de todos los tipos, solo en los ensamblados cuyos niveles de confianza son iguales o menores que el nivel de confianza del ensamblado que emitió el método dinámico.All members of all types, only in assemblies whose trust levels are equal to or less than the trust level of the assembly that emitted the dynamic method.

Nota

Antes de la .NET Framework 2,0 Service Pack 1, emitiendo el código necesario ReflectionPermission con la ReflectionPermissionFlag.ReflectionEmit marca.Prior to the .NET Framework 2.0 Service Pack 1, emitting code required ReflectionPermission with the ReflectionPermissionFlag.ReflectionEmit flag. Este permiso se incluye de forma predeterminada en los conjuntos de permisos con nombre FullTrust y LocalIntranet, pero no en el conjunto de permisos de Internet.This permission is included by default in the FullTrust and LocalIntranet named permission sets, but not in the Internet permission set. Por lo tanto, en versiones anteriores del .NET Framework una biblioteca solo se puede usar con permisos de Internet si tiene el SecurityCriticalAttribute atributo y también ejecuta un Assert para ReflectionEmit .Therefore, in earlier versions of the .NET Framework a library can be used with Internet permissions only if it has the SecurityCriticalAttribute attribute and also executes an Assert for ReflectionEmit. Estas bibliotecas requieren una revisión cuidadosa de la seguridad porque los errores de codificación pueden provocar vulnerabilidades de seguridad.Such libraries require careful security review because coding errors could result in security holes. .NET Framework 2.0 SP1 permite emitir código en escenarios de confianza parcial sin emitir ninguna petición de seguridad, porque la generación de código no es en sí una operación que requiera privilegios.The .NET Framework 2.0 SP1 allows code to be emitted in partial trust scenarios without issuing any security demands, because generating code is not inherently a privileged operation. Es decir, el código generado no tiene más permisos que el ensamblado que lo emite.That is, the generated code has no more permissions than the assembly that emits it. Esto permite que las bibliotecas que emiten código sean transparentes en seguridad y elimina la necesidad de declarar ReflectionEmit, lo que simplifica la tarea de escribir una biblioteca segura.This allows libraries that emit code to be security transparent and removes the need to assert ReflectionEmit, which simplifies the task of writing a secure library. Para usar esta característica, la aplicación debe tener como destino la .NET Framework 3,5 o posterior.To use this feature, your application should target the .NET Framework 3.5 or later.

En la tabla siguiente se muestran los tipos y miembros a los que se puede tener acceso a través de un método dinámico que está asociado a un módulo o con un tipo de un módulo.The following table shows which types and members are accessible to a dynamic method that is associated with a module or with a type in a module.

Asociado al móduloAssociated with module Asociado al tipoAssociated with type
Sin omitir las comprobaciones de visibilidad JITWithout skipping JIT visibility checks Miembros públicos e internos de los tipos públicos, internos y privados en el módulo.Public and internal members of public, internal, and private types in the module.

Miembros públicos de tipos públicos en cualquier ensamblado.Public members of public types in any assembly.
Todos los miembros del tipo asociado.All members of the associated type. Miembros públicos e internos de todos los demás tipos del módulo.Public and internal members of all the other types in the module.

Miembros públicos de tipos públicos en cualquier ensamblado.Public members of public types in any assembly.
Omitir comprobaciones de visibilidad JITSkipping JIT visibility checks Todos los miembros de todos los tipos de un ensamblado.All members of all types in any assembly. Todos los miembros de todos los tipos de un ensamblado.All members of all types in any assembly.

Un método dinámico que está asociado a un módulo tiene los permisos de ese módulo.A dynamic method that is associated with a module has the permissions of that module. Un método dinámico que está asociado a un tipo tiene los permisos del módulo que contiene ese tipo.A dynamic method that is associated with a type has the permissions of the module containing that type.

No es necesario que los métodos dinámicos y sus parámetros se denominen, pero puede especificar nombres para ayudar en la depuración.Dynamic methods and their parameters do not have to be named, but you can specify names to assist in debugging. Los atributos personalizados no se admiten en métodos dinámicos ni en sus parámetros.Custom attributes are not supported on dynamic methods or their parameters.

Aunque los métodos dinámicos son static métodos ( Shared métodos en Visual Basic), las reglas relajadas para el enlace de delegado introducidas en el .NET Framework 2,0 permiten enlazar un método dinámico a un objeto, de modo que actúe como un método de instancia cuando se llame mediante esa instancia de delegado.Although dynamic methods are static methods (Shared methods in Visual Basic), the relaxed rules for delegate binding introduced in the .NET Framework 2.0 allow a dynamic method to be bound to an object, so that it acts like an instance method when called using that delegate instance. Un ejemplo que muestra esto se proporciona para la CreateDelegate(Type, Object) sobrecarga del método.An example that demonstrates this is provided for the CreateDelegate(Type, Object) method overload.

Nota

En el .NET Framework 2,0, los métodos dinámicos no admiten la información de símbolos, es decir, los nombres de las variables locales y la asignación de números de línea.In the .NET Framework 2.0, dynamic methods do not support symbol information, that is, local variable names and line-number mapping. Esta limitación podría quitarse en una versión futura.This limitation might be removed in a future version. Puede usar AssemblyBuilder durante el desarrollo para simplificar la depuración del lenguaje intermedio de Microsoft (MSIL) generado y, a continuación, cambiar a los métodos dinámicos durante la implementación final, ya que las ILGenerator llamadas son las mismas en ambos casos.You can use AssemblyBuilder during development to simplify debugging the generated Microsoft intermediate language (MSIL), and then switch to dynamic methods during final deployment, because the ILGenerator calls are the same in both cases.

ComprobaciónVerification

En la lista siguiente se resumen las condiciones en las que los métodos dinámicos pueden contener código no comprobable.The following list summarizes the conditions under which dynamic methods can contain unverifiable code. (Por ejemplo, un método dinámico no es comprobable si su InitLocals propiedad está establecida en false .)(For example, a dynamic method is unverifiable if its InitLocals property is set to false.)

  • Un método dinámico que está asociado a un ensamblado crítico para la seguridad también es crítico para la seguridad y puede omitir la comprobación.A dynamic method that is associated with a security-critical assembly is also security-critical, and can skip verification. Por ejemplo, un ensamblado sin atributos de seguridad que se ejecuta como una aplicación de escritorio se trata como crítico para la seguridad en tiempo de ejecución.For example, an assembly without security attributes that is run as a desktop application is treated as security-critical by the runtime. Si asocia un método dinámico al ensamblado, el método dinámico puede contener código no comprobable.If you associate a dynamic method with the assembly, the dynamic method can contain unverifiable code.

  • Si un método dinámico que contiene código no comprobable está asociado a un ensamblado que tiene la transparencia de nivel 1, el compilador Just-in-Time (JIT) inserta una demanda de seguridad.If a dynamic method that contains unverifiable code is associated with an assembly that has level 1 transparency, the just-in-time (JIT) compiler injects a security demand. La petición se realiza correctamente solo si el código de plena confianza ejecuta el método dinámico.The demand succeeds only if the dynamic method is executed by fully trusted code. Vea código transparente en seguridad, nivel 1.See Security-Transparent Code, Level 1.

  • Si un método dinámico que contiene código no comprobable está asociado a un ensamblado que tiene una transparencia de nivel 2 (como mscorlib.dll), produce una excepción (inyectada por el compilador JIT) en lugar de crear una petición de seguridad.If a dynamic method that contains unverifiable code is associated with an assembly that has level 2 transparency (such as mscorlib.dll), it throws an exception (injected by the JIT compiler) instead of making a security demand. Vea código transparente en seguridad, nivel 2.See Security-Transparent Code, Level 2.

  • Un método dinámico hospedado de forma anónima que contiene código no comprobable siempre produce una excepción.An anonymously hosted dynamic method that contains unverifiable code always throws an exception. Nunca puede omitir la comprobación, incluso si se crea y ejecuta por código de plena confianza.It can never skip verification, even if it is created and executed by fully trusted code.

La excepción que se produce para el código no comprobable varía en función de la manera en que se invoca el método dinámico.The exception that is thrown for unverifiable code varies depending on the way the dynamic method is invoked. Si invoca un método dinámico utilizando un delegado devuelto por el CreateDelegate método, VerificationException se produce una excepción.If you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. Si invoca el método dinámico mediante el Invoke método, TargetInvocationException se produce una excepción con un interno VerificationException .If you invoke the dynamic method by using the Invoke method, a TargetInvocationException is thrown with an inner VerificationException.

Constructores

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)

Crea un método dinámico que es global para un módulo, especificando el nombre del método, los atributos, la convención de nomenclatura, el tipo de valor devuelto, los tipos de parámetros, el módulo y si se deben omitir comprobaciones de visibilidad Just-In-Time (JIT) para tipos y miembros a los que se tiene acceso por el lenguaje intermedio de Microsoft (MSIL) del método dinámico.Creates a dynamic method that is global to a module, specifying the method name, attributes, calling convention, return type, parameter types, module, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)

Crea un método dinámico que especifica el nombre del método, los atributos, la convención de llamada, el tipo de valor de devolución, los tipos de parámetros, el tipo con el que está asociado lógicamente el método dinámico y si se deben omitir comprobaciones de visibilidad Just-In-Time (JIT) para los tipos y miembros a los que se tiene acceso mediante el lenguaje intermedio de Microsoft (MSIL) del método dinámico.Creates a dynamic method, specifying the method name, attributes, calling convention, return type, parameter types, the type with which the dynamic method is logically associated, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, Type, Type[])

Inicializa un método dinámico hospedado de forma anónima, especificando el nombre del método, el tipo de valor devuelto y los tipos de parámetros.Initializes an anonymously hosted dynamic method, specifying the method name, return type, and parameter types.

DynamicMethod(String, Type, Type[], Boolean)

Inicializa un método dinámico hospedado de forma anónima, especificando el nombre del método, el tipo de valor devuelto, los tipos de parámetros y si se deben omitir comprobaciones de visibilidad Just-In-Time (JIT) para tipos y miembros a los que se tiene acceso por el lenguaje intermedio de Microsoft (MSIL) del método dinámico.Initializes an anonymously hosted dynamic method, specifying the method name, return type, parameter types, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, Type, Type[], Module)

Crea un método dinámico que es global para un módulo, especificando el nombre del método, el tipo de devolución, los tipos de parámetros y el módulo.Creates a dynamic method that is global to a module, specifying the method name, return type, parameter types, and module.

DynamicMethod(String, Type, Type[], Module, Boolean)

Crea un método dinámico que es global para un módulo, especificando el nombre del método, el tipo de valor devuelto, los tipos de parámetros, el módulo y si se deben omitir comprobaciones de visibilidad Just-In-Time (JIT) para tipos y miembros a los que se tiene acceso por el lenguaje intermedio de Microsoft (MSIL) del método dinámico.Creates a dynamic method that is global to a module, specifying the method name, return type, parameter types, module, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, Type, Type[], Type)

Crea un método dinámico, especificando el nombre del método, tipo de valor devuelto, los tipos de parámetro y el tipo al que está asociado lógicamente el método dinámico.Creates a dynamic method, specifying the method name, return type, parameter types, and the type with which the dynamic method is logically associated.

DynamicMethod(String, Type, Type[], Type, Boolean)

Crea un método dinámico que especifica el nombre del método, el tipo de valor de devolución, los tipos de parámetros, el tipo con el que está asociado lógicamente el método dinámico y si se deben omitir comprobaciones de visibilidad Just-In-Time (JIT) para los tipos y miembros a los que se tiene acceso mediante el lenguaje intermedio de Microsoft (MSIL) del método dinámico.Creates a dynamic method, specifying the method name, return type, parameter types, the type with which the dynamic method is logically associated, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

Propiedades

Attributes

Obtiene los atributos especificados cuando se creó el método dinámico.Gets the attributes specified when the dynamic method was created.

CallingConvention

Obtiene la convención de llamada especificada cuando se creó el método dinámico.Gets the calling convention specified when the dynamic method was created.

ContainsGenericParameters

Obtiene un valor que indica si un método genérico contiene parámetros de tipo genérico sin asignar.Gets a value that indicates whether a generic method contains unassigned generic type parameters.

(Heredado de MethodInfo)
CustomAttributes

Obtiene una colección que contiene los atributos personalizados de este miembro.Gets a collection that contains this member's custom attributes.

(Heredado de MemberInfo)
DeclaringType

Obtiene el tipo que declara el método, que es siempre null para los métodos dinámicos.Gets the type that declares the method, which is always null for dynamic methods.

InitLocals

Obtiene o establece un valor que indica si las variables locales del método se inicializan a cero.Gets or sets a value indicating whether the local variables in the method are zero-initialized.

IsAbstract

Obtiene un valor que indica si el método es abstracto.Gets a value indicating whether the method is abstract.

(Heredado de MethodBase)
IsAssembly

Obtiene un valor que indica si Assembly describe la visibilidad posible de este método o constructor; es decir, el método o el constructor es visible como mucho para otros tipos del mismo ensamblado y no es visible para los tipos derivados fuera del ensamblado.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(Heredado de MethodBase)
IsCollectible

Obtiene un valor que indica si este objeto MemberInfo forma parte de un ensamblado contenido en un AssemblyLoadContext recopilable.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Heredado de MemberInfo)
IsConstructedGenericMethod (Heredado de MethodBase)
IsConstructor

Obtiene un valor que indica si el método es un constructor.Gets a value indicating whether the method is a constructor.

(Heredado de MethodBase)
IsFamily

Obtiene un valor que indica si Family describe la visibilidad de este método o constructor; es decir, el método o el constructor sólo es visible dentro de su clase y clases derivadas.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(Heredado de MethodBase)
IsFamilyAndAssembly

Obtiene un valor que indica si FamANDAssem describe la visibilidad de este método o constructor; es decir, las clases derivadas pueden llamar al método o constructor, pero sólo si están en el mismo ensamblado.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

(Heredado de MethodBase)
IsFamilyOrAssembly

Obtiene un valor que indica si FamORAssem describe la visibilidad posible de este método o constructor; es decir, las clases derivadas pueden llamar al método o constructor con independencia de dónde se encuentren, así como las clases del mismo ensamblado.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(Heredado de MethodBase)
IsFinal

Obtiene un valor que indica si este método es final.Gets a value indicating whether this method is final.

(Heredado de MethodBase)
IsGenericMethod

Obtiene un valor que indica si el método actual es genérico.Gets a value indicating whether the current method is a generic method.

(Heredado de MethodInfo)
IsGenericMethodDefinition

Obtiene un valor que indica si el MethodInfo actual representa la definición de un método genérico.Gets a value indicating whether the current MethodInfo represents the definition of a generic method.

(Heredado de MethodInfo)
IsHideBySig

Obtiene un valor que indica si sólo hay un miembro del mismo tipo y con idéntica firma oculto en la clase derivada.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Heredado de MethodBase)
IsPrivate

Obtiene un valor que indica si este miembro es privado.Gets a value indicating whether this member is private.

(Heredado de MethodBase)
IsPublic

Obtiene un valor que indica si éste es un método público.Gets a value indicating whether this is a public method.

(Heredado de MethodBase)
IsSecurityCritical

Obtiene un valor que indica si el método dinámico actual es crítico para la seguridad o crítico para la seguridad y disponible desde código transparente y, por tanto, puede realizar operaciones críticas.Gets a value that indicates whether the current dynamic method is security-critical or security-safe-critical, and therefore can perform critical operations.

IsSecurityCritical

Obtiene un valor que indica si el método o el constructor actual es crítico para la seguridad o es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual y, por tanto, puede realizar operaciones críticas.Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

(Heredado de MethodBase)
IsSecuritySafeCritical

Obtiene un valor que indica si el método dinámico actual es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y está disponible desde código transparente.Gets a value that indicates whether the current dynamic method is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

IsSecuritySafeCritical

Obtiene un valor que indica si el método o el constructor actual es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y está disponible desde código transparente.Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(Heredado de MethodBase)
IsSecurityTransparent

Obtiene un valor que indica si el método dinámico actual es transparente en el nivel de confianza actual y, por tanto, no puede realizar operaciones críticas.Gets a value that indicates whether the current dynamic method is transparent at the current trust level, and therefore cannot perform critical operations.

IsSecurityTransparent

Obtiene un valor que indica si el método o el constructor actual es transparente en el nivel de confianza actual y, por tanto, no puede realizar operaciones críticas.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

(Heredado de MethodBase)
IsSpecialName

Obtiene un valor que indica si este método tiene un nombre especial.Gets a value indicating whether this method has a special name.

(Heredado de MethodBase)
IsStatic

Obtiene un valor que indica si el método es static.Gets a value indicating whether the method is static.

(Heredado de MethodBase)
IsVirtual

Obtiene un valor que indica si el método es virtual.Gets a value indicating whether the method is virtual.

(Heredado de MethodBase)
MemberType

Obtiene un valor de MemberTypes que indica que este miembro es un método.Gets a MemberTypes value indicating that this member is a method.

(Heredado de MethodInfo)
MetadataToken

Obtiene un valor que identifica un elemento de metadatos.Gets a value that identifies a metadata element.

(Heredado de MemberInfo)
MethodHandle

No se admite para los métodos dinámicos.Not supported for dynamic methods.

MethodHandle

Obtiene un identificador para la representación interna de metadatos de un método.Gets a handle to the internal metadata representation of a method.

(Heredado de MethodBase)
MethodImplementationFlags
MethodImplementationFlags

Obtiene las marcas MethodImplAttributes que especifican los atributos de una implementación de método.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

(Heredado de MethodBase)
Module

Obtiene el módulo con el que está asociado lógicamente el método dinámico.Gets the module with which the dynamic method is logically associated.

Module

Obtiene el módulo en el que el tipo que declara el miembro representado por el objeto MemberInfo actual está definido.Gets the module in which the type that declares the member represented by the current MemberInfo is defined.

(Heredado de MemberInfo)
Name

Obtiene el nombre del método dinámico.Gets the name of the dynamic method.

ReflectedType

Obtiene la clase que se usó en la reflexión para obtener el método.Gets the class that was used in reflection to obtain the method.

ReflectedType

Obtiene el objeto de la clase utilizado para obtener esta instancia de MemberInfo.Gets the class object that was used to obtain this instance of MemberInfo.

(Heredado de MemberInfo)
ReturnParameter

Obtiene el parámetro devuelto del método dinámico.Gets the return parameter of the dynamic method.

ReturnType

Obtiene el tipo de valor devuelto para el método dinámico.Gets the type of return value for the dynamic method.

ReturnTypeCustomAttributes

Obtiene los atributos personalizados del tipo de valor devuelto para el método dinámico.Gets the custom attributes of the return type for the dynamic method.

ReturnTypeCustomAttributes

Obtiene los atributos personalizados del tipo de valor devuelto.Gets the custom attributes for the return type.

(Heredado de MethodInfo)

Métodos

CreateDelegate(Type)

Finaliza el método dinámico y crea a un delegado que se puede usar para ejecutarlo.Completes the dynamic method and creates a delegate that can be used to execute it.

CreateDelegate(Type, Object)

Completa el método dinámico y crea un delegado que puede utilizarse para ejecutarlo, especificando el tipo de delegado y un objeto que se enlaza al delegado.Completes the dynamic method and creates a delegate that can be used to execute it, specifying the delegate type and an object the delegate is bound to.

CreateDelegate<T>()

Crea un delegado de tipo T a partir de este método.Creates a delegate of type T from this method.

(Heredado de MethodInfo)
CreateDelegate<T>(Object)

Crea un delegado de tipo T con el destino especificado a partir de este método.Creates a delegate of type T with the specified target from this method.

(Heredado de MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)

Define un parámetro del método dinámico.Defines a parameter of the dynamic method.

Equals(Object)

Devuelve un valor que indica si esta instancia es igual que un objeto especificado.Returns a value that indicates whether this instance is equal to a specified object.

(Heredado de MethodInfo)
GetBaseDefinition()

Devuelve la implementación para el método.Returns the base implementation for the method.

GetBaseDefinition()

Cuando se reemplaza en una clase derivada, se devuelve el objeto MethodInfo del método en la clase base directa o indirecta en la que se declaró por primera vez el método representado mediante esta instancia.When overridden in a derived class, returns the MethodInfo object for the method on the direct or indirect base class in which the method represented by this instance was first declared.

(Heredado de MethodInfo)
GetCustomAttributes(Boolean)

Devuelve todos los atributos personalizados definidos para el método.Returns all the custom attributes defined for the method.

GetCustomAttributes(Boolean)

Cuando se reemplaza en una clase derivada, devuelve una matriz de todos los atributos personalizados aplicados a este miembro.When overridden in a derived class, returns an array of all custom attributes applied to this member.

(Heredado de MemberInfo)
GetCustomAttributes(Type, Boolean)

Devuelve los atributos personalizados del tipo especificado que se han aplicado al método.Returns the custom attributes of the specified type that have been applied to the method.

GetCustomAttributes(Type, Boolean)

Cuando se invalida en una clase derivada, devuelve una matriz de atributos personalizados aplicados a este miembro e identificado por Type.When overridden in a derived class, returns an array of custom attributes applied to this member and identified by Type.

(Heredado de MemberInfo)
GetCustomAttributesData()

Devuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se aplicaron al miembro de destino.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Heredado de MemberInfo)
GetDynamicILInfo()

Devuelve un objeto DynamicILInfo que se puede usar para generar un cuerpo de método a partir de los tokens de metadatos, los ámbitos y las secuencias del lenguaje intermedio de Microsoft (MSIL).Returns a DynamicILInfo object that can be used to generate a method body from metadata tokens, scopes, and Microsoft intermediate language (MSIL) streams.

GetGenericArguments()

Devuelve una matriz de objetos Type que representan los argumentos de tipo de un método genérico o los parámetros de tipo de una definición de método genérico.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(Heredado de MethodInfo)
GetGenericMethodDefinition()

Devuelve un objeto MethodInfo que representa una definición de método genérico a partir de la cual se puede construir el método genérico actual.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

(Heredado de MethodInfo)
GetHashCode()

Devuelve el código hash de esta instancia.Returns the hash code for this instance.

(Heredado de MethodInfo)
GetILGenerator()

Devuelve un generador de Lenguaje Intermedio de Microsoft (MSIL) para el método con un tamaño de secuencia de MSIL predeterminado de 64 bytes.Returns a Microsoft intermediate language (MSIL) generator for the method with a default MSIL stream size of 64 bytes.

GetILGenerator(Int32)

Devuelve un generador de Lenguaje intermedio (MSIL) de Microsoft para el método con el tamaño de la secuencia MSIL especificado.Returns a Microsoft intermediate language (MSIL) generator for the method with the specified MSIL stream size.

GetMethodBody()

Cuando se reemplaza en una clase derivada, obtiene un objeto MethodBody que proporciona el acceso a la secuencia de MSIL, las variables locales y las excepciones del método actual.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

(Heredado de MethodBase)
GetMethodImplementationFlags()

Devuelve las marcas de implementación para el método.Returns the implementation flags for the method.

GetMethodImplementationFlags()

Cuando se reemplaza en una clase derivada, devuelve las marcas MethodImplAttributes.When overridden in a derived class, returns the MethodImplAttributes flags.

(Heredado de MethodBase)
GetParameters()

Devuelve los parámetros del método dinámico.Returns the parameters of the dynamic method.

GetType()

Detecta los atributos de un método y proporciona acceso a sus metadatos.Discovers the attributes of a method and provides access to method metadata.

(Heredado de MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Heredado de MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Invoca el método dinámico usando los parámetros especificados, bajo las restricciones del enlazador especificado, con la información de la referencia cultural especificada.Invokes the dynamic method using the specified parameters, under the constraints of the specified binder, with the specified culture information.

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Cuando se reemplaza en una clase derivada, invoca el método o constructor reflejado con los parámetros especificados.When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

(Heredado de MethodBase)
Invoke(Object, Object[])

Invoca el método o el constructor reflejados por esta instancia de MethodInfo.Invokes the method or constructor reflected by this MethodInfo instance.

(Heredado de MethodInfo)
IsDefined(Type, Boolean)

Indica si se ha definido el tipo de atributo personalizado especificado.Indicates whether the specified custom attribute type is defined.

IsDefined(Type, Boolean)

Cuando se reemplaza en una clase derivada, indica si se aplican a este miembro uno o más atributos del tipo especificado o de sus tipos derivados.When overridden in a derived class, indicates whether one or more attributes of the specified type or of its derived types is applied to this member.

(Heredado de MemberInfo)
MakeGenericMethod(Type[])

Sustituye los elementos de una matriz de tipos por los parámetros de tipo de la definición de método genérico actual y devuelve un objeto MethodInfo que representa el método construido resultante.Substitutes the elements of an array of types for the type parameters of the current generic method definition, and returns a MethodInfo object representing the resulting constructed method.

(Heredado de MethodInfo)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ToString()

Devuelve la firma del método, representada como una cadena.Returns the signature of the method, represented as a string.

Implementaciones de interfaz explícitas

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.Maps a set of names to a corresponding set of dispatch identifiers.

(Heredado de MemberInfo)
_MemberInfo.GetType()

Objeto Type que representa la clase MemberInfo.Gets a Type object representing the MemberInfo class.

(Heredado de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Heredado de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Heredado de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.Provides access to properties and methods exposed by an object.

(Heredado de MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.Maps a set of names to a corresponding set of dispatch identifiers.

(Heredado de MethodBase)
_MethodBase.GetType()

Para obtener una descripción de este miembro, vea GetType().For a description of this member, see GetType().

(Heredado de MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Heredado de MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Heredado de MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.Provides access to properties and methods exposed by an object.

(Heredado de MethodBase)
_MethodBase.IsAbstract

Para obtener una descripción de este miembro, vea IsAbstract.For a description of this member, see IsAbstract.

(Heredado de MethodBase)
_MethodBase.IsAssembly

Para obtener una descripción de este miembro, vea IsAssembly.For a description of this member, see IsAssembly.

(Heredado de MethodBase)
_MethodBase.IsConstructor

Para obtener una descripción de este miembro, vea IsConstructor.For a description of this member, see IsConstructor.

(Heredado de MethodBase)
_MethodBase.IsFamily

Para obtener una descripción de este miembro, vea IsFamily.For a description of this member, see IsFamily.

(Heredado de MethodBase)
_MethodBase.IsFamilyAndAssembly

Para obtener una descripción de este miembro, vea IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

(Heredado de MethodBase)
_MethodBase.IsFamilyOrAssembly

Para obtener una descripción de este miembro, vea IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

(Heredado de MethodBase)
_MethodBase.IsFinal

Para obtener una descripción de este miembro, vea IsFinal.For a description of this member, see IsFinal.

(Heredado de MethodBase)
_MethodBase.IsHideBySig

Para obtener una descripción de este miembro, vea IsHideBySig.For a description of this member, see IsHideBySig.

(Heredado de MethodBase)
_MethodBase.IsPrivate

Para obtener una descripción de este miembro, vea IsPrivate.For a description of this member, see IsPrivate.

(Heredado de MethodBase)
_MethodBase.IsPublic

Para obtener una descripción de este miembro, vea IsPublic.For a description of this member, see IsPublic.

(Heredado de MethodBase)
_MethodBase.IsSpecialName

Para obtener una descripción de este miembro, vea IsSpecialName.For a description of this member, see IsSpecialName.

(Heredado de MethodBase)
_MethodBase.IsStatic

Para obtener una descripción de este miembro, vea IsStatic.For a description of this member, see IsStatic.

(Heredado de MethodBase)
_MethodBase.IsVirtual

Para obtener una descripción de este miembro, vea IsVirtual.For a description of this member, see IsVirtual.

(Heredado de MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.Maps a set of names to a corresponding set of dispatch identifiers.

(Heredado de MethodInfo)
_MethodInfo.GetType()

Proporciona acceso al método GetType() desde COM.Provides access to the GetType() method from COM.

(Heredado de MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Obtiene la información de tipos de un objeto, que puede utilizarse para obtener la información de tipos de una interfaz.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Heredado de MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Heredado de MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.Provides access to properties and methods exposed by an object.

(Heredado de MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Devuelve una matriz de todos los atributos personalizados definidos en este miembro, excluidos los atributos con nombre, o una matriz vacía si no hay atributos personalizados.Returns an array of all of the custom attributes defined on this member, excluding named attributes, or an empty array if there are no custom attributes.

(Heredado de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Devuelve una matriz de atributos personalizados definidos en este miembro, identificados por tipo, o una matriz vacía si no hay atributos personalizados de ese tipo.Returns an array of custom attributes defined on this member, identified by type, or an empty array if there are no custom attributes of that type.

(Heredado de MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Indica si una o más instancias de attributeType se definen en este miembro.Indicates whether one or more instance of attributeType is defined on this member.

(Heredado de MemberInfo)

Métodos de extensión

GetCustomAttribute(MemberInfo, Type)

Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Recupera una colección de atributos personalizados que se aplican a un miembro especificado.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Recupera una colección de atributos personalizados que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Indica si se deben aplicar atributos personalizados de un tipo especificado a un miembro especificado.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Indica si los atributos personalizados de un tipo especificado se aplican a un miembro especificado y, opcionalmente, se aplican a sus antecesores.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Obtiene un token de metadatos del miembro determinado, si está disponible.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Devuelve un valor que indica si un token de metadatos está disponible para el miembro especificado.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)

Recupera un objeto que representa el método especificado en la clase base directa o indirecta donde el método se declaró por primera vez.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

Se aplica a