DynamicMethod Classe

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.Lightweight.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Define e representa um método dinâmico que pode ser compilado, executado e descartado. Os métodos descartados estão disponíveis para coleta de lixo.

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

Herança

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Atributos

ComVisibleAttribute

Exemplos

O exemplo de código a seguir cria um método dinâmico que usa dois parâmetros. O exemplo emite um corpo de função simples que imprime o primeiro parâmetro no console e o exemplo usa o segundo parâmetro como o valor retornado do método. O exemplo conclui o método criando um delegado, invoca o delegado com parâmetros diferentes e, por fim, invoca o método dinâmico usando o Invoke método.

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

Comentários

Você pode usar a DynamicMethod classe para gerar e executar um método em tempo de execução, sem precisar gerar um assembly dinâmico e um tipo dinâmico para conter o método. O código executável criado pelo compilador JIT (just-in-time) é recuperado quando o DynamicMethod objeto é recuperado. Os métodos dinâmicos são a maneira mais eficiente de gerar e executar pequenas quantidades de código.

Um método dinâmico pode ser hospedado anonimamente ou pode ser logicamente associado a um módulo ou a um tipo.

• Se o método dinâmico estiver hospedado anonimamente, ele estará localizado em um assembly fornecido pelo sistema e, portanto, será isolado de outro código. Por padrão, ele não tem acesso a dados não públicos. Um método dinâmico hospedado anonimamente pode ter a capacidade restrita de ignorar as verificações de visibilidade do compilador JIT, se ele tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador. O nível de confiança do assembly cujos membros não públicos são acessados pelo método dinâmico deve ser igual ou a um subconjunto do nível de confiança da pilha de chamadas que emitia o método dinâmico. Para obter mais informações sobre métodos dinâmicos hospedados anonimamente, consulte Passo a passo: Emitir código em cenários de confiança parcial.

• Se o método dinâmico estiver associado a um módulo que você especificar, o método dinâmico será efetivamente global para esse módulo. Ele pode acessar todos os tipos no módulo e todos os internal membros (Friend em Visual Basic) dos tipos. Você pode associar um método dinâmico a qualquer módulo, independentemente de ter criado o módulo, desde que uma demanda pelo ReflectionPermission RestrictedMemberAccess sinalizador possa ser atendida pela pilha de chamadas que inclui o código. Se o ReflectionPermissionFlag.MemberAccess sinalizador estiver incluído na concessão, o método dinâmico poderá ignorar as verificações de visibilidade do compilador JIT e acessar os dados privados de todos os tipos declarados no módulo ou em qualquer outro módulo em qualquer assembly.

  Observação

  Quando você especifica o módulo com o qual um método dinâmico está associado, esse módulo não deve estar no assembly fornecido pelo sistema que é usado para hospedagem anônima.

• Se o método dinâmico estiver associado a um tipo especificado, ele terá acesso a todos os membros do tipo, independentemente do nível de acesso. Além disso, verificações de visibilidade JIT podem ser ignoradas. Isso fornece ao método dinâmico acesso aos dados privados de outros tipos declarados no mesmo módulo ou em qualquer outro módulo em qualquer assembly. Você pode associar um método dinâmico a qualquer tipo, mas seu código deve ser concedido ReflectionPermission com os sinalizadores e MemberAccess os RestrictedMemberAccess sinalizadores.

A tabela a seguir mostra quais tipos e membros estão acessíveis a um método dinâmico hospedado anonimamente, com e sem verificações de visibilidade JIT, dependendo se ReflectionPermission com o RestrictedMemberAccess sinalizador é concedido.

	Sem RestrictedMemberAccess	Com RestrictedMemberAccess
Sem ignorar verificações de visibilidade JIT	Membros públicos de tipos públicos em qualquer assembly.	Membros públicos de tipos públicos em qualquer assembly.
Ignorando verificações de visibilidade JIT, com restrições	Membros públicos de tipos públicos em qualquer assembly.	Todos os membros de todos os tipos, somente em assemblies cujos níveis de confiança são iguais ou menores que o nível de confiança do assembly que emitia o método dinâmico.

Observação

.NET Framework 2.0 permite que o código seja emitido em cenários de confiança parcial sem emitir nenhuma demanda de segurança, pois a geração de código não é inerentemente uma operação privilegiada. Ou seja, o código gerado não tem mais permissões que o assembly que o emite. Isso permite que as bibliotecas que emitem código tenham a segurança transparente e remove a necessidade de declarar ReflectionEmit, o que simplifica a tarefa de escrever uma biblioteca de segurança. Para usar esse recurso, seu aplicativo deve ser direcionado .NET Framework 3.5 ou posterior.

A tabela a seguir mostra quais tipos e membros estão acessíveis a um método dinâmico associado a um módulo ou a um tipo em um módulo.

	Associado ao módulo	Associado ao tipo
Sem ignorar verificações de visibilidade JIT	Membros públicos e internos de tipos públicos, internos e privados no módulo. Membros públicos de tipos públicos em qualquer assembly.	Todos os membros do tipo associado. Membros públicos e internos de todos os outros tipos no módulo. Membros públicos de tipos públicos em qualquer assembly.
Ignorando verificações de visibilidade JIT	Todos os membros de todos os tipos em qualquer assembly.	Todos os membros de todos os tipos em qualquer assembly.

Um método dinâmico associado a um módulo tem as permissões desse módulo. Um método dinâmico associado a um tipo tem as permissões do módulo que contém esse tipo.

Métodos dinâmicos e seus parâmetros não precisam ser nomeados, mas você pode especificar nomes para ajudar na depuração. Não há suporte para atributos personalizados em métodos dinâmicos ou parâmetros.

Embora os métodos dinâmicos sejam static métodos (Shared métodos em Visual Basic), as regras relaxadas para a associação de delegados introduzidas no .NET Framework 2.0 permitem que um método dinâmico seja associado a um objeto, de modo que ele atue como um método de instância quando chamado usando essa instância delegada. Um exemplo que demonstra que isso é fornecido para a sobrecarga do CreateDelegate(Type, Object) método.

Observação

No .NET Framework 2.0, os métodos dinâmicos não dão suporte a informações de símbolo, ou seja, nomes de variáveis locais e mapeamento de número de linha. Essa limitação pode ser removida em uma versão futura. Você pode usar AssemblyBuilder durante o desenvolvimento para simplificar a depuração da MSIL (linguagem intermediária da Microsoft) gerada e, em seguida, alternar para métodos dinâmicos durante a implantação final, pois as ILGenerator chamadas são as mesmas em ambos os casos.

Verificação

A lista a seguir resume as condições sob as quais os métodos dinâmicos podem conter código não verificável. (Por exemplo, um método dinâmico será inverificável se sua InitLocals propriedade for definida como false.)

• Um método dinâmico associado a um assembly crítico de segurança também é crítico à segurança e pode ignorar a verificação. Por exemplo, um assembly sem atributos de segurança executados como um aplicativo de área de trabalho é tratado como crítico de segurança pelo runtime. Se você associar um método dinâmico ao assembly, o método dinâmico poderá conter código não verificável.

• Se um método dinâmico que contém código não verificável estiver associado a um assembly que tenha transparência de nível 1, o compilador JIT (just-in-time) injetará uma demanda de segurança. A demanda só terá êxito se o método dinâmico for executado por código totalmente confiável. Consulte código transparente de segurança, nível 1.

• Se um método dinâmico que contém código não verificável estiver associado a um assembly que tenha transparência de nível 2 (como mscorlib.dll), ele lançará uma exceção (injetada pelo compilador JIT) em vez de fazer uma demanda de segurança. Consulte código transparente de segurança, nível 2.

• Um método dinâmico hospedado anonimamente que contém código não verificável sempre gera uma exceção. Ele nunca pode ignorar a verificação, mesmo que ela seja criada e executada por um código totalmente confiável.

A exceção gerada para código não verificável varia dependendo da maneira como o método dinâmico é invocado. Se você invocar um método dinâmico usando um delegado retornado do CreateDelegate método, um VerificationException será gerado. Se você invocar o método dinâmico usando o Invoke método, um TargetInvocationException será gerado com um interior VerificationException.

Construtores

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Cria um método dinâmico que é global para um módulo, especificando o nome do método, os atributos, a convenção de chamada, o tipo de retorno, os tipos de parâmetro, o módulo e se as verificações de visibilidade JIT (just-in-time) devem ser ignoradas para os tipos e membros acessados pelo MSIL (Microsoft Intermediate Language) do método dinâmico.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Cria um método dinâmico, especificando o nome do método, os atributos, a convenção de chamada, o tipo de retorno, os tipos de parâmetro, o tipo como qual o método dinâmico é logicamente associado e se as verificações de visibilidade JIT (just-in-time) devem ser ignoradas para tipos e membros acessados pelo MSIL (Microsoft Intermediate Language) do método dinâmico.
DynamicMethod(String, Type, Type[])	Inicializa um método dinâmico hospedado anonimamente, especificando o nome do método, o tipo de retorno e os tipos de parâmetro.
DynamicMethod(String, Type, Type[], Boolean)	Inicializa um método dinâmico hospedado anonimamente, especificando o nome do método, o tipo de retorno, os tipos de parâmetro e se as verificações de visibilidade JIT (Just-In-Time) devem ser ignoradas para os tipos e membros acessados pelo MSIL (Microsoft Intermediate Language) do método dinâmico.
DynamicMethod(String, Type, Type[], Module)	Cria um método dinâmico global para um módulo, especificando o nome do método, o tipo de retorno, os tipos de parâmetro e o módulo.
DynamicMethod(String, Type, Type[], Module, Boolean)	Cria um método dinâmico que é global para um módulo, especificando o nome do método, o tipo de retorno, os tipos de parâmetro, o módulo e se as verificações de visibilidade JIT (just-in-time) devem ser ignoradas para os tipos e membros acessados pelo MSIL (Microsoft Intermediate Language) do método dinâmico.
DynamicMethod(String, Type, Type[], Type)	Cria um método dinâmico, especificando o nome do método, o tipo de retorno, os tipos de parâmetro e o tipo ao qual o método dinâmico está logicamente associado.
DynamicMethod(String, Type, Type[], Type, Boolean)	Cria um método dinâmico, especificando o nome do método, o tipo de retorno, os tipos de parâmetro, o tipo como qual o método dinâmico é logicamente associado e se as verificações de visibilidade JIT (just-in-time) devem ser ignoradas para tipos e membros acessados pelo MSIL (Microsoft Intermediate Language) do método dinâmico.

Propriedades

Attributes	Obtém os atributos especificados quando o método dinâmico foi criado.
CallingConvention	Obtém a convenção de chamada especificada quando o método dinâmico foi criado.
ContainsGenericParameters	Obtém um valor que indica se um método genérico contém parâmetros de tipo genérico não atribuídos. (Herdado de MethodInfo)
CustomAttributes	Obtém uma coleção que contém os atributos personalizados desse membro. (Herdado de MemberInfo)
DeclaringType	Obtém o tipo que declara o método, que é sempre null para métodos dinâmicos.
InitLocals	Obtém ou define um valor que indica se as variáveis locais no método são inicializadas em zero.
IsAbstract	Obtém um valor que indica se o método é abstrato. (Herdado de MethodBase)
IsAssembly	Obtém um valor que indica se a visibilidade potencial deste método ou construtor é descrita por Assembly; ou seja, o construtor ou método é visível no máximo para outros tipos no mesmo assembly e não é visível a tipos derivados fora do assembly. (Herdado de MethodBase)
IsCollectible	Obtém um valor que indica se este objeto MemberInfo faz parte de um assembly mantido em uma coleção AssemblyLoadContext. (Herdado de MemberInfo)
IsConstructedGenericMethod	(Herdado de MethodBase)
IsConstructor	Obtém um valor que indica se o método é um construtor. (Herdado de MethodBase)
IsFamily	Obtém um valor que indica se a visibilidade deste método ou construtor é descrita por Family; ou seja, o método ou o construtor é visível somente dentro de sua classe e de classes derivadas. (Herdado de MethodBase)
IsFamilyAndAssembly	Obtém um valor que indica se a visibilidade deste método ou construtor é descrita por FamANDAssem; ou seja, o método ou o construtor pode ser chamado por classes derivadas, mas apenas se estiverem no mesmo assembly. (Herdado de MethodBase)
IsFamilyOrAssembly	Obtém um valor que indica se a visibilidade potencial deste método ou construtor é descrita por FamORAssem; ou seja, o método ou o construtor pode ser chamado por classes derivadas, não importa em que lugar elas estejam e por classes no mesmo assembly. (Herdado de MethodBase)
IsFinal	Obtém um valor que indica se esse método é final. (Herdado de MethodBase)
IsGenericMethod	Obtém um valor que indica se o método atual é um método genérico. (Herdado de MethodInfo)
IsGenericMethodDefinition	Obtém um valor que indica se o MethodInfo atual representa a definição de um método genérico. (Herdado de MethodInfo)
IsHideBySig	Obtém um valor que indica se apenas um membro do mesmo tipo, com exatamente a mesma assinatura, está oculto na classe derivada. (Herdado de MethodBase)
IsPrivate	Obtém um valor que indica se este membro é privado. (Herdado de MethodBase)
IsPublic	Obtém um valor que indica se este é um método público. (Herdado de MethodBase)
IsSecurityCritical	Obtém um valor que indica se o método dinâmico atual é crítico para segurança ou crítico para segurança e disponível no código transparente e, portanto, pode executar operações críticas.
IsSecurityCritical	Obtém um valor que indica se o método ou o construtor atual é crítico para segurança ou crítico para segurança e disponível no código transparente no nível de confiança atual e, portanto, pode realizar operações críticas. (Herdado de MethodBase)
IsSecuritySafeCritical	Obtém um valor que indica se o método dinâmico é crítico para segurança e disponível no código transparente no nível de confiança atual; ou seja, se ele pode realizar operações críticas e ser acessado pelo código transparente.
IsSecuritySafeCritical	Obtém um valor que indica se o método ou o construtor atual é crítico para segurança e disponível no código transparente no nível de confiança atual; ou seja, se ele pode realizar operações críticas e ser acessado pelo código transparente. (Herdado de MethodBase)
IsSecurityTransparent	Obtém um valor que indica que se o método dinâmico atual é transparente no nível de confiança atual e, portanto, não é pode realizar operações críticas.
IsSecurityTransparent	Obtém um valor que indica que se o método ou o construtor atual é transparente no nível de confiança atual e, portanto, não é pode realizar operações críticas. (Herdado de MethodBase)
IsSpecialName	Obtém um valor que indica se esse método tem um nome especial. (Herdado de MethodBase)
IsStatic	Obtém um valor que indica se o método é static. (Herdado de MethodBase)
IsVirtual	Obtém um valor que indica se o método é virtual. (Herdado de MethodBase)
MemberType	Obtém um valor MemberTypes que indica que esse membro é um método. (Herdado de MethodInfo)
MetadataToken	Obtém um valor que identifica um elemento de metadados. (Herdado de MemberInfo)
MethodHandle	Não tem suporte para métodos dinâmicos.
MethodHandle	Obtém um identificador para a representação interna de metadados de um método. (Herdado de MethodBase)
MethodImplementationFlags
MethodImplementationFlags	Obtém os sinalizadores MethodImplAttributes que especificam os atributos de uma implementação de método. (Herdado de MethodBase)
Module	Obtém o módulo ao qual o método dinâmico está logicamente associado.
Module	Obtém o módulo no qual o tipo que declara o membro representado pelo MemberInfo atual está definido. (Herdado de MemberInfo)
Name	Obtém o nome do método dinâmico.
ReflectedType	Obtém a classe que foi usada na reflexão para obter o método.
ReflectedType	Obtém o objeto de classe que foi usado para obter esta instância de MemberInfo. (Herdado de MemberInfo)
ReturnParameter	Obtém o parâmetro de retorno do método dinâmico.
ReturnType	Obtém o tipo de valor retornado do método dinâmico.
ReturnTypeCustomAttributes	Obtém os atributos personalizados do tipo de retorno para o método dinâmico.
ReturnTypeCustomAttributes	Obtém os atributos personalizados para o tipo de retorno. (Herdado de MethodInfo)

Métodos

CreateDelegate(Type)	Conclui o método dinâmico e cria um delegado que pode ser usado para executá-lo.
CreateDelegate(Type, Object)	Conclui o método dinâmico e cria um delegado que pode ser usado para executá-lo, especificando o tipo de delegado e um objeto ao qual o delegado está associado.
CreateDelegate<T>()	Cria um delegado do tipo T a partir deste método. (Herdado de MethodInfo)
CreateDelegate<T>(Object)	Cria um delegado do tipo T com o destino especificado neste método. (Herdado de MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)	Define um parâmetro do método dinâmico.
Equals(Object)	Retorna um valor que indica se essa instância é igual a um objeto especificado. (Herdado de MethodInfo)
GetBaseDefinition()	Retorna a implementação base para o método.
GetBaseDefinition()	Quando substituído em uma classe derivada, retorna o objeto MethodInfo para o método sobre a classe base direta ou indireta em que o método representado por esta instância foi declarado. (Herdado de MethodInfo)
GetCustomAttributes(Boolean)	Retorna todos os atributos personalizados definidos para o método.
GetCustomAttributes(Boolean)	Quando substituído em uma classe derivada, retorna uma matriz de todos os atributos personalizados aplicados a esse membro. (Herdado de MemberInfo)
GetCustomAttributes(Type, Boolean)	Retorna os atributos personalizados do tipo especificado que foram aplicados ao método.
GetCustomAttributes(Type, Boolean)	Quando substituído em uma classe derivada, retorna uma matriz de atributos personalizados aplicados a esse membro e identificados por Type. (Herdado de MemberInfo)
GetCustomAttributesData()	Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao membro de destino. (Herdado de MemberInfo)
GetDynamicILInfo()	Retorna um DynamicILInfo objeto que pode ser usado para gerar um corpo de método de tokens de metadados, escopos e fluxos MSIL (Microsoft Intermediate Language).
GetGenericArguments()	Retorna uma matriz de objetos Type que representam os argumentos de tipo de um método genérico ou os parâmetros de tipo de uma definição de método genérico. (Herdado de MethodInfo)
GetGenericMethodDefinition()	Retorna um objeto MethodInfo que representa uma definição de método genérico da qual o método atual pode ser criado. (Herdado de MethodInfo)
GetHashCode()	Retorna o código hash para a instância. (Herdado de MethodInfo)
GetILGenerator()	Retorna um gerador de MSIL (Microsoft Intermediate Language) para o método com um tamanho de fluxo MSIL padrão de 64 bytes.
GetILGenerator(Int32)	Retorna um gerador de MSIL (Microsoft Intermediate Language) para o método com o tamanho do fluxo MSIL especificado.
GetMethodBody()	Quando substituído em uma classe derivada, obtém um objeto MethodBody que fornece acesso ao fluxo MSIL, variáveis locais e exceções para o método atual. (Herdado de MethodBase)
GetMethodImplementationFlags()	Retorna os sinalizadores de implementação para o método.
GetMethodImplementationFlags()	Quando substituído em uma classe derivada, retorna os sinalizadores MethodImplAttributes. (Herdado de MethodBase)
GetParameters()	Retorna os parâmetros do método dinâmico.
GetType()	Descobre os atributos de um método e fornece acesso aos metadados de método. (Herdado de MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	(Herdado de MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Invoca o método dinâmico usando os parâmetros especificados, sob as restrições do associador especificado e com as informações de cultura especificadas.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Quando substituído em uma classe derivada, invoca o método ou o construtor refletido com parâmetros especificados. (Herdado de MethodBase)
Invoke(Object, Object[])	Invoca o método ou o construtor representado pela instância atual, usando os parâmetros especificados. (Herdado de MethodInfo)
IsDefined(Type, Boolean)	Indica se o tipo de atributo personalizado especificado é definido.
IsDefined(Type, Boolean)	Quando substituído em uma classe derivada, indica se um ou mais atributos do tipo especificado ou de seus tipos derivados são aplicados a esse membro. (Herdado de MemberInfo)
MakeGenericMethod(Type[])	Substitui os elementos de uma matriz de tipos pelos parâmetros de tipo da definição de método genérico atual e retorna um objeto MethodInfo que representa o método construído resultante. (Herdado de MethodInfo)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna a assinatura do método, representada como uma cadeia de caracteres.

Implantações explícitas de interface

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição. (Herdado de MemberInfo)
_MemberInfo.GetType()	Obtém um objeto Type que representa a classe MemberInfo. (Herdado de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface. (Herdado de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1). (Herdado de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fornece acesso a propriedades e métodos expostos por um objeto. (Herdado de MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição. (Herdado de MethodBase)
_MethodBase.GetType()	Para obter uma descrição desse membro, confira GetType(). (Herdado de MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface. (Herdado de MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1). (Herdado de MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fornece acesso a propriedades e métodos expostos por um objeto. (Herdado de MethodBase)
_MethodBase.IsAbstract	Para obter uma descrição desse membro, confira IsAbstract. (Herdado de MethodBase)
_MethodBase.IsAssembly	Para obter uma descrição desse membro, confira IsAssembly. (Herdado de MethodBase)
_MethodBase.IsConstructor	Para obter uma descrição desse membro, confira IsConstructor. (Herdado de MethodBase)
_MethodBase.IsFamily	Para obter uma descrição desse membro, confira IsFamily. (Herdado de MethodBase)
_MethodBase.IsFamilyAndAssembly	Para obter uma descrição desse membro, confira IsFamilyAndAssembly. (Herdado de MethodBase)
_MethodBase.IsFamilyOrAssembly	Para obter uma descrição desse membro, confira IsFamilyOrAssembly. (Herdado de MethodBase)
_MethodBase.IsFinal	Para obter uma descrição desse membro, confira IsFinal. (Herdado de MethodBase)
_MethodBase.IsHideBySig	Para obter uma descrição desse membro, confira IsHideBySig. (Herdado de MethodBase)
_MethodBase.IsPrivate	Para obter uma descrição desse membro, confira IsPrivate. (Herdado de MethodBase)
_MethodBase.IsPublic	Para obter uma descrição desse membro, confira IsPublic. (Herdado de MethodBase)
_MethodBase.IsSpecialName	Para obter uma descrição desse membro, confira IsSpecialName. (Herdado de MethodBase)
_MethodBase.IsStatic	Para obter uma descrição desse membro, confira IsStatic. (Herdado de MethodBase)
_MethodBase.IsVirtual	Para obter uma descrição desse membro, confira IsVirtual. (Herdado de MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição. (Herdado de MethodInfo)
_MethodInfo.GetType()	Dá acesso ao GetType() método do COM. (Herdado de MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Recupera as informações de tipo para um objeto, que pode ser usado para obter as informações de tipo para uma interface. (Herdado de MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)	Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1). (Herdado de MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fornece acesso a propriedades e métodos expostos por um objeto. (Herdado de MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Retorna uma matriz de todos os atributos personalizados definidos neste membro, exceto atributos nomeados ou então uma matriz vazia, se não houver nenhum atributo personalizado. (Herdado de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Retorna uma matriz de atributos personalizados definidos neste membro, identificados por tipo ou então uma matriz vazia, se não houver nenhum atributo personalizado desse tipo. (Herdado de MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Indica se uma ou mais instâncias de attributeType estão definidas nesse membro. (Herdado de MemberInfo)

Métodos de Extensão

GetCustomAttribute(MemberInfo, Type)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.
GetCustomAttribute(MemberInfo, Type, Boolean)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttribute<T>(MemberInfo)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.
GetCustomAttribute<T>(MemberInfo, Boolean)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes(MemberInfo)	Recupera uma coleção de atributos personalizados que são aplicados a um membro especificado.
GetCustomAttributes(MemberInfo, Boolean)	Recupera uma coleção de atributos personalizados aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes(MemberInfo, Type)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.
GetCustomAttributes(MemberInfo, Type, Boolean)	Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes<T>(MemberInfo)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.
GetCustomAttributes<T>(MemberInfo, Boolean)	Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
IsDefined(MemberInfo, Type)	Indica se os atributos personalizados de um tipo especificados são aplicados a um membro especificado.
IsDefined(MemberInfo, Type, Boolean)	Indica se os atributos personalizados de um tipo especificado são aplicados a um membro especificado e, opcionalmente, aplicados a seus ancestrais.
GetMetadataToken(MemberInfo)	Obtém um token de metadados para o membro fornecido, se disponível.
HasMetadataToken(MemberInfo)	Retorna um valor que indica se um token de metadados está disponível para o membro especificado.
GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)	Recupera um objeto que representa o método especificado na classe base direta ou indireta em que o método foi declarado pela primeira vez.

Confira também

• Como: Definir e executar métodos dinâmicos
• Problemas de segurança na emissão de reflexão
• Passo a passo: Emitindo o código em cenários de confiança parcial