Compartir a través de


ConstructorBuilder Clase

Definición

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

public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder abstract : System::Reflection::ConstructorInfo
public ref class ConstructorBuilder sealed : System::Reflection::ConstructorInfo, System::Runtime::InteropServices::_ConstructorBuilder
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo
public abstract class ConstructorBuilder : System.Reflection.ConstructorInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
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)]
public sealed class ConstructorBuilder : System.Reflection.ConstructorInfo, System.Runtime.InteropServices._ConstructorBuilder
type ConstructorBuilder = class
    inherit ConstructorInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type ConstructorBuilder = class
    inherit ConstructorInfo
    interface _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
Public MustInherit Class ConstructorBuilder
Inherits ConstructorInfo
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
Herencia
Atributos
Implementaciones

Ejemplos

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

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ DynamicPointTypeGen()
{
   Type^ pointType = nullptr;
   array<Type^>^temp0 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^ctorParams = temp0;
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew 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", int::typeid, FieldAttributes::Public );
   FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
   FieldBuilder^ zField = pointTypeBld->DefineField( "z", int::typeid, FieldAttributes::Public );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<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 bject 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 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.
   array<String^>^temp1 = {"GetX","GetY","GetZ"};
   array<String^>^mthdNames = temp1;
   System::Collections::IEnumerator^ myEnum = mthdNames->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ mthdName = safe_cast<String^>(myEnum->Current);
      MethodBuilder^ getFieldMthd = pointTypeBld->DefineMethod( mthdName, MethodAttributes::Public, int::typeid, nullptr );
      ILGenerator^ mthdIL = getFieldMthd->GetILGenerator();
      mthdIL->Emit( OpCodes::Ldarg_0 );
      if ( mthdName->Equals( "GetX" ) )
            mthdIL->Emit( OpCodes::Ldfld, xField );
      else
      if ( mthdName->Equals( "GetY" ) )
            mthdIL->Emit( OpCodes::Ldfld, yField );
      else
      if ( mthdName->Equals( "GetZ" ) )
            mthdIL->Emit( OpCodes::Ldfld, zField );



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

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

int main()
{
   Type^ myDynamicType = nullptr;
   Object^ aPoint = nullptr;
   array<Type^>^temp2 = {int::typeid,int::typeid,int::typeid};
   array<Type^>^aPtypes = temp2;
   array<Object^>^temp3 = {4,5,6};
   array<Object^>^aPargs = temp3;
   
   // 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: " );
   System::Collections::IEnumerator^ myEnum = myDynamicType->GetMembers()->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      MemberInfo^ member = safe_cast<MemberInfo^>(myEnum->Current);
      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 );
   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, nullptr, aPoint, gcnew array<Object^>(0) ) );
   Console::WriteLine( "aPoint.y = {0}", myDynamicType->InvokeMember( "GetY", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<Object^>(0) ) );
   Console::WriteLine( "aPoint.z = {0}", myDynamicType->InvokeMember( "GetZ", BindingFlags::InvokeMethod, nullptr, aPoint, gcnew array<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
}

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 el lenguaje intermedio de Microsoft (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 ha definido:

  • 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 por completo, debe usar el TypeBuilder.DefineConstructor método para crear un ConstructorBuildery proporcionar su propia implementación.

Constructores

ConstructorBuilder()

Inicializa una nueva instancia de la clase ConstructorBuilder.

Propiedades

Attributes

Obtiene los atributos de este constructor.

CallingConvention

Obtiene un valor CallingConventions que depende de si el tipo declarativo es genérico.

CallingConvention

Obtiene un valor que indica las convenciones de llamada de este método.

(Heredado de MethodBase)
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 objeto Type para el tipo que declara este miembro.

InitLocals

Obtiene o establece si las variables locales de este constructor deben inicializarse en cero.

InitLocalsCore

Cuando se invalida en una clase derivada, obtiene o establece un valor que indica 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 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 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.

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

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

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

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

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

Obtiene 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

Obtiene las marcas MethodImplAttributes que especifican los atributos de una implementación de método.

MethodImplementationFlags

Obtiene las marcas MethodImplAttributes 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.

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

ReflectedType

Contiene una referencia al objeto Type del que se obtuvo este objeto.

ReflectedType

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

(Heredado de MemberInfo)
ReturnType
Obsoletos.

Obtiene null.

Signature

Recupera la firma del campo en el formulario de una cadena.

Métodos

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Agrega seguridad declarativa a este constructor.

DefineParameter(Int32, ParameterAttributes, String)

Define un parámetro de este constructor.

DefineParameterCore(Int32, ParameterAttributes, String)

Cuando se reemplaza en una clase derivada, define un parámetro de este constructor.

Equals(Object)

Devuelve un valor que indica si esta instancia es igual que un objeto especificado.

(Heredado de ConstructorInfo)
GetCustomAttributes(Boolean)

Devuelve todos los atributos personalizados definidos para este constructor.

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 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 MethodBase)
GetHashCode()

Devuelve el código hash de esta instancia.

(Heredado de ConstructorInfo)
GetILGenerator()

Obtiene un ILGenerator para este constructor.

GetILGenerator(Int32)

Obtiene un objeto ILGenerator, con el tamaño de secuencia MSIL especificado, que puede usarse para crear un cuerpo de método para este constructor.

GetILGeneratorCore(Int32)

Cuando se reemplaza en una clase derivada, obtiene un ILGenerator que se puede usar para emitir un cuerpo de método para este constructor.

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 los marcadores de implementación del método para este constructor.

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

GetParameters()

Devuelve los parámetros de este constructor.

GetToken()

Devuelve el MethodToken que representa el token para este constructor.

GetType()

Detecta los atributos de un constructor de clase y proporciona acceso a los metadatos del constructor.

(Heredado de ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo)

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

(Heredado de MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)

Invoca dinámicamente al constructor representado por esta instancia en el objeto dado, pasando los parámetros especificados y considerando las restricciones del enlazador facilitado.

Invoke(BindingFlags, Binder, Object[], CultureInfo)

Al implementarse en una clase derivada, invoca al constructor reflejado por esta instancia de ConstructorInfo con los argumentos especificados, bajo las restricciones del enlazador (Binder) especificado.

(Heredado de ConstructorInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Invoca dinámicamente el constructor reflejado por esta instancia con los argumentos especificados, bajo las restricciones del objeto Binder especificado.

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 MethodBase)
Invoke(Object[])

Invoca al constructor reflejado por la instancia que tiene los parámetros especificados, proporcionando valores predeterminados para los parámetros que no se usan habitualmente.

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

SetImplementationFlags(MethodImplAttributes)

Establece las marcas de implementación de método para este constructor.

SetImplementationFlagsCore(MethodImplAttributes)

Cuando se invalida en una clase derivada, 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 con una matriz de bytes especificada de instrucciones de Lenguaje intermedio de Microsoft (MSIL).

SetSymCustomAttribute(String, Byte[])

Establece el atributo personalizado de este constructor asociado a la información simbólica.

ToString()

Devuelve esta instancia de ConstructorBuilder como String.

Implementaciones de interfaz explícitas

_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 las propiedades y los 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 objeto Type que representa el tipo de ConstructorInfo.

(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(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

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

(Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(Object, BindingFlags, Binder, Object[], CultureInfo).

(Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(Object, Object[]).

(Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(BindingFlags, Binder, Object[], CultureInfo).

(Heredado de ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

Proporciona el acceso independiente de la versión de los objetos COM al método Invoke(Object[]).

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

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

Se aplica a