ConstructorBuilder Clase

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

mscorlib.dll

Define y representa un constructor de una clase dinámica.

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo, System.Runtime.InteropServices._ConstructorBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ConstructorBuilder = class
    inherit ConstructorInfo
    interface _ConstructorBuilder

Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder

Herencia

Object

MemberInfo

MethodBase

ConstructorInfo

ConstructorBuilder

Atributos

ClassInterfaceAttribute ComVisibleAttribute

Implementaciones

_ConstructorBuilder

Ejemplos

En el ejemplo de código siguiente se muestra el uso contextual de .ConstructorBuilder

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

class TestCtorBuilder {

    public static Type DynamicPointTypeGen() {
    
       Type pointType = null;
       Type[] ctorParams = new Type[] {typeof(int),
                        typeof(int),
                        typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "MyDynamicAssembly";
    
       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.RunAndSave);

       ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
                                    "Point.dll");

       TypeBuilder pointTypeBld = pointModule.DefineType("Point",
                                      TypeAttributes.Public);

       FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
                                                          FieldAttributes.Public);
       FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
                                                          FieldAttributes.Public);
       FieldBuilder zField = pointTypeBld.DefineField("z", typeof(int),
                                                          FieldAttributes.Public);

           Type objType = Type.GetType("System.Object");
           ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
                      MethodAttributes.Public,
                      CallingConventions.Standard,
                      ctorParams);
       ILGenerator ctorIL = pointCtor.GetILGenerator();

       // NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
       // hold the actual passed parameters. ldarg.0 is used by instance methods
       // to hold a reference to the current calling object instance. Static methods
       // do not use arg.0, since they are not instantiated and hence no reference
       // is needed to distinguish them.

           ctorIL.Emit(OpCodes.Ldarg_0);

       // Here, we wish to create an instance of System.Object by invoking its
       // constructor, as specified above.

           ctorIL.Emit(OpCodes.Call, objCtor);

       // Now, we'll load the current instance ref in arg 0, along
       // with the value of parameter "x" stored in arg 1, into stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField);

       // Now, we store arg 2 "y" in the current instance with stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField);

       // Last of all, arg 3 "z" gets stored in the current instance.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField);

           // Our work complete, we return.

       ctorIL.Emit(OpCodes.Ret);

       // Now, let's create three very simple methods so we can see our fields.

       string[] mthdNames = new string[] {"GetX", "GetY", "GetZ"};

           foreach (string mthdName in mthdNames) {
              MethodBuilder getFieldMthd = pointTypeBld.DefineMethod(
                           mthdName,
                           MethodAttributes.Public,
                                           typeof(int),
                                           null);
          ILGenerator mthdIL = getFieldMthd.GetILGenerator();
    
          mthdIL.Emit(OpCodes.Ldarg_0);
          switch (mthdName) {
             case "GetX": mthdIL.Emit(OpCodes.Ldfld, xField);
                  break;
             case "GetY": mthdIL.Emit(OpCodes.Ldfld, yField);
                  break;
             case "GetZ": mthdIL.Emit(OpCodes.Ldfld, zField);
                  break;
          }
          mthdIL.Emit(OpCodes.Ret);
           }
       // Finally, we create the type.

       pointType = pointTypeBld.CreateType();

       // Let's save it, just for posterity.
    
       myAsmBuilder.Save("Point.dll");
    
       return pointType;
    }

    public static void Main() {
    
       Type myDynamicType = null;
           object aPoint = null;
       Type[] aPtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aPargs = new object[] {4, 5, 6};
    
       // Call the  method to build our dynamic class.

       myDynamicType = DynamicPointTypeGen();

       Console.WriteLine("Some information about my new Type '{0}':",
                  myDynamicType.FullName);
       Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly);
       Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes);
       Console.WriteLine("Module: '{0}'", myDynamicType.Module);
       Console.WriteLine("Members: ");
       foreach (MemberInfo member in myDynamicType.GetMembers()) {
        Console.WriteLine("-- {0} {1};", member.MemberType, member.Name);
       }

           Console.WriteLine("---");

       // Let's take a look at the constructor we created.

       ConstructorInfo myDTctor = myDynamicType.GetConstructor(aPtypes);
           Console.WriteLine("Constructor: {0};", myDTctor.ToString());

           Console.WriteLine("---");
    
           // Now, we get to use our dynamically-created class by invoking the constructor.

       aPoint = myDTctor.Invoke(aPargs);
           Console.WriteLine("aPoint is type {0}.", aPoint.GetType());

       // Finally, let's reflect on the instance of our new type - aPoint - and
       // make sure everything proceeded according to plan.

       Console.WriteLine("aPoint.x = {0}",
                 myDynamicType.InvokeMember("GetX",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));
       Console.WriteLine("aPoint.y = {0}",
                 myDynamicType.InvokeMember("GetY",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));
       Console.WriteLine("aPoint.z = {0}",
                 myDynamicType.InvokeMember("GetZ",
                                BindingFlags.InvokeMethod,
                            null,
                            aPoint,
                            new object[0]));

       // +++ OUTPUT +++
       // Some information about my new Type 'Point':
       // Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
       // Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
       // Module: 'PointModule'
       // Members:
       // -- Field x;
       // -- Field y;
       // -- Field z;
           // -- Method GetHashCode;
           // -- Method Equals;
           // -- Method ToString;
           // -- Method GetType;
           // -- Constructor .ctor;
       // ---
       // Constructor: Void .ctor(Int32, Int32, Int32);
       // ---
       // aPoint is type Point.
       // aPoint.x = 4
       // aPoint.y = 5
       // aPoint.z = 6
    }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class TestCtorBuilder
   
   
   Public Shared Function DynamicPointTypeGen() As Type
      
      Dim pointType As Type = Nothing
      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
      
      Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
      
      Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", TypeAttributes.Public)
      
      Dim xField As FieldBuilder = pointTypeBld.DefineField("x", GetType(Integer), FieldAttributes.Public)
      Dim yField As FieldBuilder = pointTypeBld.DefineField("y", GetType(Integer), FieldAttributes.Public)
      Dim zField As FieldBuilder = pointTypeBld.DefineField("z", GetType(Integer), FieldAttributes.Public)
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type() {})
      
      Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
      
      ' NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
      ' hold the actual passed parameters. ldarg.0 is used by instance methods
      ' to hold a reference to the current calling object instance. Static methods
      ' do not use arg.0, since they are not instantiated and hence no reference
      ' is needed to distinguish them. 
      ctorIL.Emit(OpCodes.Ldarg_0)
      
      ' Here, we wish to create an instance of System.Object by invoking its
      ' constructor, as specified above.
      ctorIL.Emit(OpCodes.Call, objCtor)
      
      ' Now, we'll load the current instance ref in arg 0, along
      ' with the value of parameter "x" stored in arg 1, into stfld.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      
      ' Now, we store arg 2 "y" in the current instance with stfld.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      
      ' Last of all, arg 3 "z" gets stored in the current instance.
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_3)
      ctorIL.Emit(OpCodes.Stfld, zField)
      
      ' Our work complete, we return.
      ctorIL.Emit(OpCodes.Ret)
      
      ' Now, let's create three very simple methods so we can see our fields.
      Dim mthdNames() As String = {"GetX", "GetY", "GetZ"}
      
      Dim mthdName As String
      For Each mthdName In  mthdNames
         Dim getFieldMthd As MethodBuilder = pointTypeBld.DefineMethod(mthdName, MethodAttributes.Public, GetType(Integer), Nothing)
         Dim mthdIL As ILGenerator = getFieldMthd.GetILGenerator()
         
         mthdIL.Emit(OpCodes.Ldarg_0)
         Select Case mthdName
            Case "GetX"
               mthdIL.Emit(OpCodes.Ldfld, xField)
            Case "GetY"
               mthdIL.Emit(OpCodes.Ldfld, yField)
            Case "GetZ"
               mthdIL.Emit(OpCodes.Ldfld, zField)
         End Select
         
         mthdIL.Emit(OpCodes.Ret)
      Next mthdName 
      ' Finally, we create the type.
      pointType = pointTypeBld.CreateType()
      
      ' Let's save it, just for posterity.
      myAsmBuilder.Save("Point.dll")
      
      Return pointType
   End Function 'DynamicPointTypeGen
    
   
   Public Shared Sub Main()
      
      Dim myDynamicType As Type = Nothing
      Dim aPoint As Object = Nothing
      Dim aPtypes() As Type = {GetType(Integer), GetType(Integer), GetType(Integer)}
      Dim aPargs() As Object = {4, 5, 6}
      
      ' Call the  method to build our dynamic class.
      myDynamicType = DynamicPointTypeGen()
      
      Console.WriteLine("Some information about my new Type '{0}':", myDynamicType.FullName)
      Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly)
      Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes)
      Console.WriteLine("Module: '{0}'", myDynamicType.Module)
      Console.WriteLine("Members: ")
      Dim member As MemberInfo
      For Each member In  myDynamicType.GetMembers()
         Console.WriteLine("-- {0} {1};", member.MemberType, member.Name)
      Next member
      
      Console.WriteLine("---")
      
      ' Let's take a look at the constructor we created.
      Dim myDTctor As ConstructorInfo = myDynamicType.GetConstructor(aPtypes)
      Console.WriteLine("Constructor: {0};", myDTctor.ToString())
      
      Console.WriteLine("---")
      
      ' Now, we get to use our dynamically-created class by invoking the constructor. 
      aPoint = myDTctor.Invoke(aPargs)
      Console.WriteLine("aPoint is type {0}.", aPoint.GetType())
      
      
      ' Finally, let's reflect on the instance of our new type - aPoint - and
      ' make sure everything proceeded according to plan.
      Console.WriteLine("aPoint.x = {0}", myDynamicType.InvokeMember("GetX", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
      Console.WriteLine("aPoint.y = {0}", myDynamicType.InvokeMember("GetY", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
      Console.WriteLine("aPoint.z = {0}", myDynamicType.InvokeMember("GetZ", BindingFlags.InvokeMethod, Nothing, aPoint, New Object() {}))
   End Sub
End Class



' +++ OUTPUT +++
' Some information about my new Type 'Point':
' Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
' Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
' Module: 'PointModule'
' Members: 
' -- Field x;
' -- Field y;
' -- Field z;
' -- Method GetHashCode;
' -- Method Equals;
' -- Method ToString;
' -- Method GetType;
' -- Constructor .ctor;
' ---
' Constructor: Void .ctor(Int32, Int32, Int32);
' ---
' aPoint is type Point.
' aPoint.x = 4
' aPoint.y = 5
' aPoint.z = 6

Comentarios

ConstructorBuilder se usa para describir completamente un constructor en Microsoft lenguaje intermedio (MSIL), incluidos el nombre, los atributos, la firma y el cuerpo del constructor. Se usa junto con la TypeBuilder clase para crear clases en tiempo de ejecución. Llame DefineConstructor a para obtener una instancia de ConstructorBuilder.

Si no define un constructor para el tipo dinámico, se proporciona automáticamente un constructor sin parámetros y llama al constructor sin parámetros de la clase base.

Si usa ConstructorBuilder para definir un constructor para el tipo dinámico, no se proporciona un constructor sin parámetros. Tiene las siguientes opciones para proporcionar un constructor sin parámetros además del constructor que definió:

• Si desea un constructor sin parámetros que simplemente llame al constructor sin parámetros de la clase base, puede usar el TypeBuilder.DefineDefaultConstructor método para crear uno (y, opcionalmente, restringir el acceso a ella). No proporcione una implementación para este constructor sin parámetros. Si lo hace, se produce una excepción al intentar usar el constructor . No se produce ninguna excepción cuando se llama al TypeBuilder.CreateType método .

• Si desea un constructor sin parámetros que haga algo más que simplemente llamar al constructor sin parámetros de la clase base, o que llame a otro constructor de la clase base, o que haga algo más completamente, debe usar el TypeBuilder.DefineConstructor método para crear un ConstructorBuildery proporcionar su propia implementación.

Propiedades

Nombre	Description
Attributes	Obtiene los atributos de este constructor.
CallingConvention	Obtiene un CallingConventions valor que depende de si el tipo declarante es genérico.
ContainsGenericParameters	Obtiene un valor que indica si el método genérico contiene parámetros de tipo genérico sin asignar. (Heredado de MethodBase)
CustomAttributes	Obtiene una colección que contiene los atributos personalizados de este miembro. (Heredado de MemberInfo)
DeclaringType	Obtiene una referencia al Type objeto para el tipo que declara este miembro.
InitLocals	Obtiene o establece si las variables locales de este constructor deben inicializarse en cero.
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)
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 genérico. (Heredado de MethodBase)
IsGenericMethodDefinition	Obtiene un valor que indica si el método es una definición de método genérico. (Heredado de MethodBase)
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	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	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	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 constructor. (Heredado de ConstructorInfo)
MetadataToken	Obtiene un valor que identifica un elemento de metadatos. (Heredado de MemberInfo)
MethodHandle	Obtiene 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 dinámico en el que se define este constructor.
Name	Recupera el nombre de este constructor.
ReflectedType	Contiene una referencia al objeto desde el Type que se obtuvo este objeto.
ReturnType	Obsoletos. Obtiene null.
Signature	Recupera la firma del campo en forma de cadena.

Métodos

Nombre	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Agrega seguridad declarativa a este constructor.
DefineParameter(Int32, ParameterAttributes, String)	Define un parámetro de este constructor.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual a un objeto especificado. (Heredado de ConstructorInfo)
GetCustomAttributes(Boolean)	Devuelve todos los atributos personalizados definidos para este constructor.
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 Type objetos 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 MethodBase)
GetHashCode()	Devuelve el código hash de esta instancia. (Heredado de ConstructorInfo)
GetILGenerator()	Obtiene un ILGenerator para este constructor.
GetILGenerator(Int32)	Obtiene un ILGenerator objeto, con el tamaño de flujo MSIL especificado, que se puede usar para compilar un cuerpo de método para este constructor.
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 para este constructor.
GetModule()	Devuelve una referencia al módulo que contiene este constructor.
GetParameters()	Devuelve los parámetros de este constructor.
GetToken()	Devuelve que MethodToken representa el token de este constructor.
Invoke(BindingFlags, Binder, Object[], CultureInfo)	Invoca dinámicamente el constructor representado por esta instancia en el objeto especificado, pasando los parámetros especificados y bajo las restricciones del enlazador especificado.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Invoca dinámicamente el constructor reflejado por esta instancia con los argumentos especificados, bajo las restricciones del especificado Binder.
Invoke(Object, Object[])	Invoca el método o constructor representado por la instancia actual mediante los parámetros especificados. (Heredado de MethodBase)
Invoke(Object[])	Invoca el constructor reflejado por la instancia de que tiene los parámetros especificados, proporcionando valores predeterminados para los parámetros que no se usan normalmente. (Heredado de ConstructorInfo)
IsDefined(Type, Boolean)	Comprueba si se define el tipo de atributo personalizado especificado.
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Establezca un atributo personalizado mediante un blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Establezca un atributo personalizado mediante un generador de atributos personalizados.
SetImplementationFlags(MethodImplAttributes)	Establece las marcas de implementación del método para este constructor.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Crea el cuerpo del constructor mediante una matriz de bytes especificada de Microsoft instrucciones de lenguaje intermedio (MSIL).
SetSymCustomAttribute(String, Byte[])	Establece el atributo personalizado de este constructor asociado a información simbólica.
ToString()	Devuelve esta ConstructorBuilder instancia como .String

Implementaciones de interfaz explícitas

Nombre	Description
_ConstructorBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.
_ConstructorBuilder.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.
_ConstructorBuilder.GetTypeInfoCount(UInt32)	Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1).
_ConstructorBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Proporciona acceso a propiedades y métodos expuestos por un objeto .
_ConstructorInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Heredado de ConstructorInfo)
_ConstructorInfo.GetType()	Obtiene un Type objeto que representa el ConstructorInfo tipo. (Heredado de ConstructorInfo)
_ConstructorInfo.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 ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)	Recupera el número de interfaces de información de tipo que proporciona un objeto (0 ó 1). (Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)	Proporciona objetos COM con acceso independiente de la versión al Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) método . (Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])	Proporciona objetos COM con acceso independiente de la versión al Invoke(Object, Object[]) método . (Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)	Proporciona objetos COM con acceso independiente de la versión al Invoke(BindingFlags, Binder, Object[], CultureInfo) método . (Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])	Proporciona objetos COM con acceso independiente de la versión al Invoke(Object[]) método . (Heredado de ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Proporciona acceso a propiedades y métodos expuestos por un objeto . (Heredado de ConstructorInfo)
_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)

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