MethodBuilder Clase

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

System.Reflection.Emit.dll

Source:

MethodBuilder.cs

Define y representa un método (o constructor) de una clase dinámica.

public ref class MethodBuilder abstract : System::Reflection::MethodInfo

public abstract class MethodBuilder : System.Reflection.MethodInfo

type MethodBuilder = class
    inherit MethodInfo

Public MustInherit Class MethodBuilder
Inherits MethodInfo

Herencia

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Ejemplos

En el ejemplo siguiente se usa la MethodBuilder clase para crear un método dentro de un tipo dinámico.

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

void AddMethodDynamically( TypeBuilder^ myTypeBld, 
                           String^ mthdName, 
                           array<Type^>^ mthdParams, 
                           Type^ returnType, 
                           String^ mthdAction )
{
   MethodBuilder^ myMthdBld = myTypeBld->DefineMethod( mthdName, static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), returnType, mthdParams );
   ILGenerator^ ILOut = myMthdBld->GetILGenerator();
   int numParams = mthdParams->Length;
   for ( Byte x = 0; x < numParams; x++ )
   {
      ILOut->Emit( OpCodes::Ldarg_S, x );

   }
   if ( numParams > 1 )
   {
      for ( int y = 0; y < (numParams - 1); y++ )
      {
         if ( mthdAction->Equals( "A" ) )
                  ILOut->Emit( OpCodes::Add );
         else
         if ( mthdAction->Equals( "M" ) )
                  ILOut->Emit( OpCodes::Mul );
         else
                  ILOut->Emit( OpCodes::Add );

      }
   }

   ILOut->Emit( OpCodes::Ret );
};

void main()
{
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ asmName = gcnew AssemblyName;
   asmName->Name = "MyDynamicAsm";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( asmName, 
                                                                    AssemblyBuilderAccess::RunAndSave );
   ModuleBuilder^ myModule = myAsmBuilder->DefineDynamicModule( "MyDynamicAsm", 
                                                                "MyDynamicAsm.dll" );
   TypeBuilder^ myTypeBld = myModule->DefineType( "MyDynamicType", 
                                                  TypeAttributes::Public );
   
   // Get info from the user to build the method dynamically.
   Console::WriteLine( "Let's build a simple method dynamically!" );
   Console::WriteLine( "Please enter a few numbers, separated by spaces." );
   String^ inputNums = Console::ReadLine();
   Console::Write( "Do you want to [A]dd (default) or [M]ultiply these numbers? " );
   String^ myMthdAction = Console::ReadLine()->ToUpper();
   Console::Write( "Lastly, what do you want to name your new dynamic method? " );
   String^ myMthdName = Console::ReadLine();
   
   // Process inputNums into an array and create a corresponding Type array
   int index = 0;
   array<String^>^inputNumsList = inputNums->Split();
   array<Type^>^myMthdParams = gcnew array<Type^>(inputNumsList->Length);
   array<Object^>^inputValsList = gcnew array<Object^>(inputNumsList->Length);
   for each (String^ inputNum in inputNumsList)
   {
      inputValsList[ index ] = Convert::ToInt32( inputNum );
      myMthdParams[ index ] = int::typeid;
      index++;
   }

   
   // Now, call the method building method with the parameters, passing the
   // TypeBuilder by reference.
   AddMethodDynamically( myTypeBld, 
                         myMthdName, 
                         myMthdParams, 
                         int::typeid, 
                         myMthdAction );
   Type^ myType = myTypeBld->CreateType();

   Console::WriteLine( "---" );
   Console::WriteLine( "The result of {0} the inputted values is: {1}", 
                       ((myMthdAction->Equals( "M" )) ? "multiplying" : "adding"), 
                       myType->InvokeMember( myMthdName, 
                                             BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static, 
                       nullptr, 
                       nullptr, 
                       inputValsList ) );
   Console::WriteLine( "---" );
   
   // Let's take a look at the method we created.
   // If you are interested in seeing the MSIL generated dynamically for the method
   // your program generated, change to the directory where you ran the compiled
   // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
   // of manifest contents appears, click on "MyDynamicType" and then on the name of
   // of the method you provided during execution.

   myAsmBuilder->Save( "MyDynamicAsm.dll" );

   MethodInfo^ myMthdInfo = myType->GetMethod( myMthdName );
   Console::WriteLine( "Your Dynamic Method: {0};", myMthdInfo );
}

using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoMethodBuilder
{
    public static void AddMethodDynamically (TypeBuilder myTypeBld,
                                             string mthdName,
                                             Type[] mthdParams,
                                             Type returnType,
                                             string mthdAction)
    {

        MethodBuilder myMthdBld = myTypeBld.DefineMethod(
                                             mthdName,
                                             MethodAttributes.Public |
                                             MethodAttributes.Static,
                                             returnType,
                                             mthdParams);

        ILGenerator ILout = myMthdBld.GetILGenerator();

        int numParams = mthdParams.Length;

        for (byte x=0; x < numParams; x++)
        {
            ILout.Emit(OpCodes.Ldarg_S, x);
        }

        if (numParams > 1)
        {
            for (int y=0; y<(numParams-1); y++)
            {
                switch (mthdAction)
                {
                    case "A": ILout.Emit(OpCodes.Add);
                              break;
                    case "M": ILout.Emit(OpCodes.Mul);
                              break;
                    default: ILout.Emit(OpCodes.Add);
                              break;
                }
            }
        }
        ILout.Emit(OpCodes.Ret);
    }

    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName();
        asmName.Name = "MyDynamicAsm";

        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                                       asmName,
                                       AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("MyDynamicAsm",
                                                                  "MyDynamicAsm.dll");

        TypeBuilder myTypeBld = myModule.DefineType("MyDynamicType",
                                                    TypeAttributes.Public);

        // Get info from the user to build the method dynamically.
        Console.WriteLine("Let's build a simple method dynamically!");
        Console.WriteLine("Please enter a few numbers, separated by spaces.");
        string inputNums = Console.ReadLine();
        Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ");
        string myMthdAction = Console.ReadLine().ToUpper();
        Console.Write("Lastly, what do you want to name your new dynamic method? ");
        string myMthdName = Console.ReadLine();

        // Process inputNums into an array and create a corresponding Type array
        int index = 0;
        string[] inputNumsList = inputNums.Split();

        Type[] myMthdParams = new Type[inputNumsList.Length];
        object[] inputValsList = new object[inputNumsList.Length];

        foreach (string inputNum in inputNumsList)
        {
            inputValsList[index] = (object)Convert.ToInt32(inputNum);
                myMthdParams[index] = typeof(int);
                index++;
        }

        // Now, call the method building method with the parameters, passing the
        // TypeBuilder by reference.
        AddMethodDynamically(myTypeBld,
                             myMthdName,
                             myMthdParams,
                             typeof(int),
                             myMthdAction);

        Type myType = myTypeBld.CreateType();

        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
                          ((myMthdAction == "M") ? "multiplying" : "adding"),
                          myType.InvokeMember(myMthdName,
                          BindingFlags.InvokeMethod | BindingFlags.Public |
                          BindingFlags.Static,
                          null,
                          null,
                          inputValsList));
        Console.WriteLine("---");

        // Let's take a look at the method we created.
        // If you are interested in seeing the MSIL generated dynamically for the method
        // your program generated, change to the directory where you ran the compiled
        // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
        // of manifest contents appears, click on "MyDynamicType" and then on the name of
        // of the method you provided during execution.

        myAsmBuilder.Save("MyDynamicAsm.dll");

        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByVal myTypeBld As TypeBuilder, _
                                          ByVal mthdName As String, _
                                          ByVal mthdParams() As Type, _
                                          ByVal returnType As Type, _
                                          ByVal mthdAction As String)
      
      Dim myMthdBld As MethodBuilder = myTypeBld.DefineMethod(mthdName, _
                                       MethodAttributes.Public Or MethodAttributes.Static, _
                                       returnType, _
                                       mthdParams)
      
      Dim ILout As ILGenerator = myMthdBld.GetILGenerator()
      
      Dim numParams As Integer = mthdParams.Length
      
      Dim x As Byte
      For x = 0 To numParams - 1
         ILout.Emit(OpCodes.Ldarg_S, x)
      Next x
      
      If numParams > 1 Then
         Dim y As Integer
         For y = 0 To (numParams - 1) - 1
            Select Case mthdAction
               Case "A"
                  ILout.Emit(OpCodes.Add)
               Case "M"
                  ILout.Emit(OpCodes.Mul)
               Case Else
                  ILout.Emit(OpCodes.Add)
            End Select
         Next y
      End If
      ILout.Emit(OpCodes.Ret)
   End Sub 
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim asmName As New AssemblyName()
      asmName.Name = "MyDynamicAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _
                                            AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyDynamicAsm", _
                                                                       "MyDynamicAsm.dll")
      
      Dim myTypeBld As TypeBuilder = myModule.DefineType("MyDynamicType", TypeAttributes.Public)
      
      ' Get info from the user to build the method dynamically.
      Console.WriteLine("Let's build a simple method dynamically!")
      Console.WriteLine("Please enter a few numbers, separated by spaces.")
      Dim inputNums As String = Console.ReadLine()
      Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ")
      Dim myMthdAction As String = Console.ReadLine().ToUpper()
      Console.Write("Lastly, what do you want to name your new dynamic method? ")
      Dim myMthdName As String = Console.ReadLine()
      
      ' Process inputNums into an array and create a corresponding Type array 
      Dim index As Integer = 0
      Dim inputNumsList As String() = inputNums.Split()
      
      Dim myMthdParams(inputNumsList.Length - 1) As Type
      Dim inputValsList(inputNumsList.Length - 1) As Object
      
      
      Dim inputNum As String
      For Each inputNum In  inputNumsList
         inputValsList(index) = CType(Convert.ToInt32(inputNum), Object)
         myMthdParams(index) = GetType(Integer)
         index += 1
      Next inputNum
      
      ' Now, call the method building method with the parameters, passing the 
      ' TypeBuilder by reference.
      AddMethodDynamically(myTypeBld, myMthdName, myMthdParams, GetType(Integer), myMthdAction)
      
      Dim myType As Type = myTypeBld.CreateType()
     
      Dim description as String 
      If myMthdAction = "M" Then
         description = "multiplying"
      Else
         description = "adding"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the values is: {1}", _
                         description, _
                         myType.InvokeMember(myMthdName, _
                                             BindingFlags.InvokeMethod _
                                               Or BindingFlags.Public _
                                               Or BindingFlags.Static, _
                                             Nothing, _
                                             Nothing, _
                                             inputValsList)) 
      Console.WriteLine("---")

      ' If you are interested in seeing the MSIL generated dynamically for the method
      ' your program generated, change to the directory where you ran the compiled
      ' code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
      ' of manifest contents appears, click on "MyDynamicType" and then on the name of
      ' of the method you provided during execution.
 
      myAsmBuilder.Save("MyDynamicAsm.dll") 

      Dim myMthdInfo As MethodInfo = myType.GetMethod(myMthdName)
      Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString())
   End Sub 
End Class

Comentarios

Para obtener más información sobre esta API, consulte Comentarios de api complementarias para MethodBuilder.

Constructores

MethodBuilder()

Inicializa una nueva instancia de la clase MethodBuilder.

Propiedades

Attributes	Recupera los atributos para este método.
CallingConvention	Devuelve la convención de llamada del método.
ContainsGenericParameters	No se admite para este tipo.
CustomAttributes	Obtiene una colección que contiene los atributos personalizados de este miembro. (Heredado de MemberInfo)
DeclaringType	Devuelve el tipo que declara este método.
InitLocals	Obtiene o establece un valor booleano que especifica si las variables locales de este método se inicializan en cero. El valor predeterminado de esta propiedad es true.
InitLocalsCore	Cuando se reemplaza en una clase derivada, obtiene o establece un valor que indica si las variables locales de este método se inicializan en cero.
IsAbstract	Obtiene un valor que indica si el método es abstracto. (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. (Heredado de MethodBase)
IsCollectible	Obtiene un valor que indica si este objeto MemberInfo forma parte de un ensamblado contenido en un AssemblyLoadContext recopilable. (Heredado de MemberInfo)
IsConstructedGenericMethod	Define y representa un método (o constructor) de una clase dinámica. (Heredado de MethodBase)
IsConstructor	Obtiene un valor que indica si el método es un 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. (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. (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. (Heredado de MethodBase)
IsFinal	Obtiene un valor que indica si este método es final. (Heredado de MethodBase)
IsGenericMethod	Obtiene un valor que indica si el método es genérico.
IsGenericMethodDefinition	Obtiene un valor que indica si el objeto MethodBuilder actual representa la definición de un método genérico.
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. (Heredado de MethodBase)
IsPrivate	Obtiene un valor que indica si este miembro es privado. (Heredado de MethodBase)
IsPublic	Obtiene un valor que indica si éste es un método público. (Heredado de MethodBase)
IsSecurityCritical	Devuelve NotSupportedException en todos los casos
IsSecuritySafeCritical	Devuelve NotSupportedException en todos los casos
IsSecurityTransparent	Devuelve NotSupportedException en todos los casos
IsSpecialName	Obtiene un valor que indica si este método tiene un nombre especial. (Heredado de MethodBase)
IsStatic	Obtiene un valor que indica si el método es static. (Heredado de MethodBase)
IsVirtual	Obtiene un valor que indica si el método es virtual. (Heredado de MethodBase)
MemberType	Obtiene un valor de MemberTypes que indica que este miembro es un método. (Heredado de MethodInfo)
MetadataToken	Obtiene un token que identifica el módulo dinámico actual en los metadatos.
MethodHandle	Recupera el identificador interno para el método. Use este identificador para tener acceso al identificador de metadatos subyacente.
MethodImplementationFlags	Obtiene las marcas MethodImplAttributes que especifican los atributos de una implementación de método. (Heredado de MethodBase)
Module	Obtiene el módulo en el que se define el método actual.
Name	Recupera el nombre de este método.
ReflectedType	Recupera la clase que se usó en la reflexión para obtener este método.
ReturnParameter	Obtiene un objeto ParameterInfo que contiene información sobre el tipo de valor devuelto del método como, por ejemplo, cuando el tipo de valor devuelto tiene modificadores personalizados.
ReturnType	Obtiene el tipo de valor devuelto del método representando por este MethodBuilder.
ReturnTypeCustomAttributes	Devuelve los atributos personalizados del tipo de valor devuelto del método.

Métodos

CreateDelegate(Type)	Crea un delegado del tipo especificado a partir de este método. (Heredado de MethodInfo)
CreateDelegate(Type, Object)	Crea un delegado del tipo especificado con el destino especificado a partir de este método. (Heredado de MethodInfo)
CreateDelegate<T>()	Crea un delegado de tipo T a partir de este método. (Heredado de MethodInfo)
CreateDelegate<T>(Object)	Crea un delegado de tipo T con el destino especificado a partir de este método. (Heredado de MethodInfo)
DefineGenericParameters(String[])	Establece los parámetros de tipo genérico para el método actual, especifica sus nombres y devuelve una matriz de objetos GenericTypeParameterBuilder que pueden usarse para establecer sus restricciones.
DefineGenericParametersCore(String[])	Cuando se reemplaza en una clase derivada, establece el número de parámetros de tipo genérico para el método actual, especifica sus nombres y devuelve una matriz de GenericTypeParameterBuilder objetos que se pueden usar para definir sus restricciones.
DefineParameter(Int32, ParameterAttributes, String)	Establece los atributos de parámetro y el nombre de un parámetro de este método, o del valor devuelto de este método. Devuelve un ParameterBuilder, que se puede usar para aplicar atributos personalizados.
DefineParameterCore(Int32, ParameterAttributes, String)	Cuando se reemplaza en una clase derivada, define un parámetro o un parámetro devuelto para este método.
Equals(Object)	Determina si el objeto dado es igual a esta instancia.
GetBaseDefinition()	Devuelve la implementación base para un método.
GetCustomAttributes(Boolean)	Devuelve todos los atributos personalizados definidos para este método.
GetCustomAttributes(Type, Boolean)	Devuelve los atributos personalizados identificados por el tipo proporcionado.
GetCustomAttributesData()	Devuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se aplicaron al miembro de destino. (Heredado de MemberInfo)
GetGenericArguments()	Devuelve una matriz de objetos GenericTypeParameterBuilder que representan los parámetros de tipo del método si es genérico.
GetGenericMethodDefinition()	Devuelve este método.
GetHashCode()	Obtiene el código hash de este método.
GetILGenerator()	Devuelve un ILGenerator para este método con el tamaño de secuencia del lenguaje intermedio de Microsoft (MSIL) predeterminado de 64 bytes.
GetILGenerator(Int32)	Devuelve un ILGenerator para este método con el tamaño de secuencia del lenguaje intermedio de Microsoft (MSIL).
GetILGeneratorCore(Int32)	Cuando se invalida en una clase derivada, obtiene un ILGenerator objeto que se puede usar para emitir un cuerpo de método para este método.
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. (Heredado de MethodBase)
GetMethodImplementationFlags()	Devuelve las marcas de implementación para el método.
GetParameters()	Devuelve los parámetros de este método.
GetType()	Detecta los atributos de un método y proporciona acceso a sus metadatos. (Heredado de MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Define y representa un método (o constructor) de una clase dinámica. (Heredado de MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Invoca dinámicamente el método reflejado por esta instancia en el objeto dado, pasando los parámetros especificados y considerando las restricciones del enlazador facilitado.
Invoke(Object, Object[])	Invoca el método o constructor representado por la instancia actual, utilizando los parámetros especificados. (Heredado de MethodInfo)
IsDefined(Type, Boolean)	Comprueba si se define el tipo de atributo personalizado especificado.
MakeGenericMethod(Type[])	Devuelve un método genérico construido a partir de la definición de método genérico actual mediante los argumentos de tipo genérico especificados.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Establece un atributo personalizado mediante un blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Establece un atributo personalizado mediante un generador de atributos personalizado.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Cuando se invalida en una clase derivada, establece un atributo personalizado en este ensamblado.
SetImplementationFlags(MethodImplAttributes)	Establece las marcas de implementación para este método.
SetImplementationFlagsCore(MethodImplAttributes)	Cuando se invalida en una clase derivada, establece las marcas de implementación para este método.
SetParameters(Type[])	Establece el número y los tipos de parámetros de un método.
SetReturnType(Type)	Establece el tipo devuelto del método.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Establece la firma del método, incluidos el tipo de valor devuelto, los tipos de parámetros y los modificadores personalizados necesarios y opcionales de los tipos de parámetros y el tipo de valor devuelto.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Cuando se reemplaza en una clase derivada, establece la firma del método, incluido el tipo de valor devuelto, los tipos de parámetro y los modificadores personalizados necesarios y opcionales del tipo de valor devuelto y los tipos de parámetro.
ToString()	Devuelve esta instancia MethodBuilder como cadena.

Métodos de extensión

GetCustomAttribute(MemberInfo, Type)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto.
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.
GetCustomAttribute<T>(MemberInfo)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto.
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.
GetCustomAttributes(MemberInfo)	Recupera una colección de atributos personalizados que se aplican a un miembro especificado.
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.
GetCustomAttributes(MemberInfo, Type)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto.
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.
GetCustomAttributes<T>(MemberInfo)	Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto.
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.
IsDefined(MemberInfo, Type)	Indica si se deben aplicar atributos personalizados de un tipo especificado a un miembro especificado.
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.
GetMetadataToken(MemberInfo)	Obtiene un token de metadatos del miembro determinado, si está disponible.
HasMetadataToken(MemberInfo)	Devuelve un valor que indica si un token de metadatos está disponible para el miembro especificado.
GetBaseDefinition(MethodInfo)	Define y representa un método (o constructor) de una clase dinámica.
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.