Compartir a través de


MethodBuilder Clase

Definición

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

public ref class MethodBuilder sealed : System::Reflection::MethodInfo
public ref class MethodBuilder abstract : System::Reflection::MethodInfo
public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder
public sealed class MethodBuilder : System.Reflection.MethodInfo
public abstract class MethodBuilder : System.Reflection.MethodInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder
type MethodBuilder = class
    inherit MethodInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Public MustInherit Class MethodBuilder
Inherits MethodInfo
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder
Herencia
Atributos
Implementaciones

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.

ContainsGenericParameters

Obtiene un valor que indica si un método genérico contiene parámetros de tipo genérico sin asignar.

(Heredado de MethodInfo)
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.

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.

IsGenericMethod

Obtiene un valor que indica si el método actual es genérico.

(Heredado de MethodInfo)
IsGenericMethodDefinition

Obtiene un valor que indica si el objeto MethodBuilder actual representa la definición de un método genérico.

IsGenericMethodDefinition

Obtiene un valor que indica si el MethodInfo actual representa la definición de un método genérico.

(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.

(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

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.

(Heredado de MethodBase)
IsSecuritySafeCritical

Devuelve NotSupportedException en todos los casos

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.

(Heredado de MethodBase)
IsSecurityTransparent

Devuelve NotSupportedException en todos los casos

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.

(Heredado de MethodBase)
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.

MetadataToken

Obtiene un valor que identifica un elemento de metadatos.

(Heredado de MemberInfo)
MethodHandle

Recupera el identificador interno para el método. Use este identificador para tener acceso al identificador de metadatos subyacente.

MethodHandle

Obtiene un identificador para la representación interna de metadatos de un método.

(Heredado de MethodBase)
MethodImplementationFlags

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

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.

Module

Obtiene el módulo en el que el tipo que declara el miembro representado por el objeto MemberInfo actual está definido.

(Heredado de MemberInfo)
Name

Recupera el nombre de este método.

ReflectedType

Recupera la clase que se usó en la reflexión para obtener este método.

ReflectedType

Obtiene el objeto de la clase utilizado para obtener esta instancia de MemberInfo.

(Heredado de MemberInfo)
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.

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.

(Heredado de MethodInfo)
ReturnType

Obtiene el tipo de valor devuelto del método representando por este MethodBuilder.

ReturnType

Obtiene el tipo de valor devuelto por este método.

(Heredado de MethodInfo)
ReturnTypeCustomAttributes

Devuelve los atributos personalizados del tipo de valor devuelto del método.

ReturnTypeCustomAttributes

Obtiene los atributos personalizados del tipo de valor devuelto.

(Heredado de MethodInfo)
Signature

Recupera la firma del método.

Métodos

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Agrega seguridad declarativa a este método.

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)
CreateMethodBody(Byte[], Int32)

Crea el cuerpo del método usando una matriz de bytes suministrada de instrucciones de lenguaje intermedio (MSIL) de Microsoft.

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.

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.

(Heredado de MethodInfo)
GetCustomAttributes(Boolean)

Devuelve todos los atributos personalizados definidos para este método.

GetCustomAttributes(Boolean)

Cuando se reemplaza en una clase derivada, devuelve una matriz de todos los atributos personalizados aplicados a este miembro.

(Heredado de MemberInfo)
GetCustomAttributes(Type, Boolean)

Devuelve los atributos personalizados identificados por el tipo proporcionado.

GetCustomAttributes(Type, Boolean)

Cuando se invalida en una clase derivada, devuelve una matriz de atributos personalizados aplicados a este miembro e identificado por Type.

(Heredado de MemberInfo)
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.

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.

(Heredado de MethodInfo)
GetGenericMethodDefinition()

Devuelve este método.

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.

(Heredado de MethodInfo)
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.

GetMethodImplementationFlags()

Cuando se reemplaza en una clase derivada, devuelve las marcas MethodImplAttributes.

(Heredado de MethodBase)
GetModule()

Devuelve una referencia al módulo que contiene este método.

GetParameters()

Devuelve los parámetros de este método.

GetToken()

Devuelve el MethodToken que representa el token para 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, BindingFlags, Binder, Object[], CultureInfo)

Cuando se reemplaza en una clase derivada, invoca el método o constructor reflejado con los parámetros especificados.

(Heredado de MethodBase)
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.

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.

(Heredado de MemberInfo)
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.

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.

(Heredado de MethodInfo)
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.

SetMarshal(UnmanagedMarshal)
Obsoletos.

Establece la información de cálculo de referencias para el tipo de valor devuelto del método.

SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)

Crea el cuerpo del método usando una matriz de bytes especificada de instrucciones de lenguaje intermedio de Microsoft (MSIL).

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.

SetSymCustomAttribute(String, Byte[])

Establezca un atributo personalizado simbólico mediante un blob.

ToString()

Devuelve esta instancia MethodBuilder como cadena.

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.

(Heredado de MemberInfo)
_MemberInfo.GetType()

Objeto Type que representa la clase MemberInfo.

(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.

(Heredado de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 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.

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

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.

(Heredado de MethodBase)
_MethodBase.GetType()

Para obtener una descripción de este miembro, vea 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.

(Heredado de MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 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.

(Heredado de MethodBase)
_MethodBase.IsAbstract

Para obtener una descripción de este miembro, vea IsAbstract.

(Heredado de MethodBase)
_MethodBase.IsAssembly

Para obtener una descripción de este miembro, vea IsAssembly.

(Heredado de MethodBase)
_MethodBase.IsConstructor

Para obtener una descripción de este miembro, vea IsConstructor.

(Heredado de MethodBase)
_MethodBase.IsFamily

Para obtener una descripción de este miembro, vea IsFamily.

(Heredado de MethodBase)
_MethodBase.IsFamilyAndAssembly

Para obtener una descripción de este miembro, vea IsFamilyAndAssembly.

(Heredado de MethodBase)
_MethodBase.IsFamilyOrAssembly

Para obtener una descripción de este miembro, vea IsFamilyOrAssembly.

(Heredado de MethodBase)
_MethodBase.IsFinal

Para obtener una descripción de este miembro, vea IsFinal.

(Heredado de MethodBase)
_MethodBase.IsHideBySig

Para obtener una descripción de este miembro, vea IsHideBySig.

(Heredado de MethodBase)
_MethodBase.IsPrivate

Para obtener una descripción de este miembro, vea IsPrivate.

(Heredado de MethodBase)
_MethodBase.IsPublic

Para obtener una descripción de este miembro, vea IsPublic.

(Heredado de MethodBase)
_MethodBase.IsSpecialName

Para obtener una descripción de este miembro, vea IsSpecialName.

(Heredado de MethodBase)
_MethodBase.IsStatic

Para obtener una descripción de este miembro, vea IsStatic.

(Heredado de MethodBase)
_MethodBase.IsVirtual

Para obtener una descripción de este miembro, vea IsVirtual.

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

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.

_MethodBuilder.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.

_MethodBuilder.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1).

_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.

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

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.

(Heredado de MethodInfo)
_MethodInfo.GetType()

Proporciona acceso al método GetType() desde 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.

(Heredado de MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 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.

(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.

(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.

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

Indica si una o más instancias de attributeType se definen en este miembro.

(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.

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.

Se aplica a