MethodBuilder Clase

Definición

Espacio de nombres:: System.Reflection.Emit

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

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

public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder

public ref class MethodBuilder sealed : 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

public sealed class MethodBuilder : System.Reflection.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

type MethodBuilder = class
    inherit MethodInfo

Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder

Public NotInheritable Class MethodBuilder
Inherits MethodInfo

Herencia: Object

MemberInfo

MethodBase

MethodInfo
MethodBuilder

Atributos: ClassInterfaceAttribute ComVisibleAttribute

Implementaciones: _MethodBuilder

Ejemplos

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


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.

Propiedades

Nombre	Description
Attributes	Recupera los atributos de 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`.
IsAbstract	Obtiene un valor que indica si el método es abstracto. (Heredado de MethodBase)
IsAssembly	Obtiene un valor que indica si la posible visibilidad de este método o constructor se describe mediante Assembly; es decir, el método o constructor es visible como máximo para otros tipos del mismo ensamblado y no es visible para los tipos derivados fuera del ensamblado. (Heredado de MethodBase)
IsConstructedGenericMethod	Define y representa un método (o constructor) en una clase dinámica.
IsConstructor	Obtiene un valor que indica si el método es un constructor. (Heredado de MethodBase)
IsFamily	Obtiene un valor que indica si la visibilidad de este método o constructor se describe mediante Family; es decir, el método o constructor solo está visible dentro de su clase y clases derivadas. (Heredado de MethodBase)
IsFamilyAndAssembly	Obtiene un valor que indica si la visibilidad de este método o constructor se describe mediante FamANDAssem; es decir, las clases derivadas pueden llamar al método o constructor, pero solo si están en el mismo ensamblado. (Heredado de MethodBase)
IsFamilyOrAssembly	Obtiene un valor que indica si la posible visibilidad de este método o constructor se describe mediante FamORAssem; es decir, las clases derivadas pueden llamar al método o constructor dondequiera que estén y por 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 un método genérico.
IsGenericMethodDefinition	Obtiene un valor que indica si el objeto actual MethodBuilder representa la definición de un método genérico.
IsHideBySig	Obtiene un valor que indica si solo un miembro del mismo tipo con exactamente la misma firma está 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 se trata de un método público. (Heredado de MethodBase)
IsSecurityCritical	Produce una NotSupportedException excepción en todos los casos.
IsSecurityCritical	Obtiene un valor que indica si el método o constructor actual es crítico para la seguridad o crítico para la seguridad en el nivel de confianza actual y, por tanto, puede realizar operaciones críticas. (Heredado de MethodBase)
IsSecuritySafeCritical	Produce una NotSupportedException excepción en todos los casos.
IsSecuritySafeCritical	Obtiene un valor que indica si el método o constructor actual es crítico para la seguridad en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y se puede acceder a ellas mediante código transparente. (Heredado de MethodBase)
IsSecurityTransparent	Produce una NotSupportedException excepción en todos los casos.
IsSecurityTransparent	Obtiene un valor que indica si el método o 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 MemberTypes valor que indica que este miembro es un método. (Heredado de MethodInfo)
MetadataToken	Obtiene un valor que identifica un elemento de metadatos. (Heredado de MemberInfo)
MethodHandle	Recupera el identificador interno del método . Use este identificador para acceder al identificador de metadatos subyacente.
MethodImplementationFlags	Obtiene las MethodImplAttributes marcas que especifican los atributos de una implementación de método. (Heredado de MethodBase)
Module	Obtiene el módulo en el que se está definiendo 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 objeto.
ReturnParameter	Obtiene un ParameterInfo objeto que contiene información sobre el tipo de valor devuelto del método, como si el tipo de valor devuelto tiene modificadores personalizados.
ReturnType	Obtiene el tipo de valor devuelto del método representado por este MethodBuilder.
ReturnType	Obtiene el tipo de valor devuelto de este método. (Heredado de MethodInfo)
ReturnTypeCustomAttributes	Devuelve los atributos personalizados del tipo de valor devuelto del método.
Signature	Recupera la firma del método .

Métodos

Nombre	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Agrega seguridad declarativa a este método.
CreateDelegate(Type, Object)	Crea un delegado del tipo especificado con el destino especificado a partir de este método. (Heredado de MethodInfo)
CreateDelegate(Type)	Crea un delegado del tipo especificado a partir de este método. (Heredado de MethodInfo)
CreateMethodBody(Byte[], Int32)	Crea el cuerpo del método mediante una matriz de bytes proporcionada de Microsoft instrucciones de lenguaje intermedio (MSIL).
DefineGenericParameters(String[])	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.
Equals(Object)	Determina si el objeto especificado es igual a esta instancia.
GetBaseDefinition()	Devuelve la implementación base de 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 especificado.
GetCustomAttributesData()	Devuelve una lista de CustomAttributeData objetos que representan datos sobre los atributos que se han aplicado al miembro de destino. (Heredado de MemberInfo)
GetGenericArguments()	Devuelve una matriz de GenericTypeParameterBuilder objetos 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 un tamaño de flujo de lenguaje intermedio (MSIL) predeterminado Microsoft de 64 bytes.
GetILGenerator(Int32)	Devuelve un `ILGenerator` para este método con el tamaño de flujo de lenguaje intermedio (MSIL) especificado Microsoft.
GetMethodBody()	Cuando se reemplaza en una clase derivada, obtiene un MethodBody objeto que proporciona acceso a la secuencia de MSIL, las variables locales y las excepciones para el método actual. (Heredado de MethodBase)
GetMethodImplementationFlags()	Devuelve las marcas de implementación del método .
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` objeto que representa el token de este método.
GetType()	Detecta los atributos de un método y proporciona acceso a los metadatos del método. (Heredado de MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Define y representa un método (o constructor) en 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 especificado, pasando los parámetros especificados y bajo las restricciones del enlazador especificado.
Invoke(Object, Object[])	Invoca el método o constructor representado por la instancia actual mediante 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 Objectactual. (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 personalizados.
SetImplementationFlags(MethodImplAttributes)	Establece las marcas de implementación para este método.
SetMarshal(UnmanagedMarshal)	Obsoletos. Establece la información de serialización del tipo de valor devuelto de este método.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Crea el cuerpo del método mediante una matriz de bytes especificada de Microsoft instrucciones de lenguaje intermedio (MSIL).
SetParameters(Type[])	Establece el número y los tipos de parámetros de un método.
SetReturnType(Type)	Establece el tipo de valor 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ámetro y los modificadores personalizados obligatorios 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 `MethodBuilder` instancia como una cadena.

Implementaciones de interfaz explícitas

Nombre	Description
_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()	Obtiene un Type objeto que representa la MemberInfo clase . (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 propiedades y 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 propiedades y 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 propiedades y 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 GetType() método desde COM. (Heredado de MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Recupera la información de tipo de un objeto, que se puede usar para obtener la información de tipo 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 propiedades y métodos expuestos por un objeto . (Heredado de MethodInfo)

Métodos de extensión

Nombre	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttribute(MemberInfo, Type)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttribute<T>(MemberInfo, Boolean)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttribute<T>(MemberInfo)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttributes(MemberInfo, Boolean)	Recupera una colección de atributos personalizados que se aplican a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttributes(MemberInfo, Type, Boolean)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttributes(MemberInfo, Type)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttributes(MemberInfo)	Recupera una colección de atributos personalizados que se aplican a un miembro especificado.
GetCustomAttributes<T>(MemberInfo, Boolean)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttributes<T>(MemberInfo)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado.
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.
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.
IsDefined(MemberInfo, Type)	Indica si los atributos personalizados de un tipo especificado se aplican a un miembro especificado.

Se aplica a

Comentarios

¿Le ha resultado útil esta página?