ConstructorBuilder Classe

Definição

Define e representa um construtor de uma classe 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
Herança
Atributos
Implementações

Exemplos

O exemplo de código a seguir ilustra o uso contextual de um 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

Comentários

ConstructorBuilder é usado para descrever totalmente um construtor na MSIL (Linguagem Intermediária da Microsoft), incluindo o nome, os atributos, a assinatura e o corpo do construtor. Ele é usado em conjunto com a TypeBuilder classe para criar classes em tempo de execução. Chame DefineConstructor para obter uma instância de ConstructorBuilder.

Se você não definir um construtor para seu tipo dinâmico, um construtor sem parâmetros será fornecido automaticamente e ele chamará o construtor sem parâmetros da classe base.

Se você usar ConstructorBuilder para definir um construtor para seu tipo dinâmico, um construtor sem parâmetros não será fornecido. Você tem as seguintes opções para fornecer um construtor sem parâmetros, além do construtor que você definiu:

  • Se você quiser um construtor sem parâmetros que simplesmente chame o construtor sem parâmetros da classe base, poderá usar o método para criar um (e, opcionalmente, restringir o TypeBuilder.DefineDefaultConstructor acesso a ele). Não forneça uma implementação para esse construtor sem parâmetros. Se você fizer isso, uma exceção será gerada quando você tentar usar o construtor . Nenhuma exceção é gerada quando o TypeBuilder.CreateType método é chamado.

  • Se você quiser um construtor sem parâmetros que faça algo mais do que simplesmente chamar o construtor sem parâmetros da classe base ou que chame outro construtor da classe base ou que faça algo totalmente diferente, você deverá usar o TypeBuilder.DefineConstructor método para criar um ConstructorBuildere fornecer sua própria implementação.

Construtores

ConstructorBuilder()

Inicializa uma nova instância da classe ConstructorBuilder.

Propriedades

Attributes

Obtém os atributos para esse construtor.

CallingConvention

Obtém um valor CallingConventions que depende de se o tipo declarativo é genérico.

CallingConvention

Obtém um valor que indica as convenções de chamada deste método.

(Herdado de MethodBase)
ContainsGenericParameters

Obtém um valor que indica se o método genérico contém parâmetros de tipo genérico não atribuídos.

(Herdado de MethodBase)
CustomAttributes

Obtém uma coleção que contém os atributos personalizados desse membro.

(Herdado de MemberInfo)
DeclaringType

Obtém uma referência para o objeto Type para o tipo que declara esse membro.

InitLocals

Obtém ou define se as variáveis locais neste construtor devem ser inicializadas do zero.

InitLocalsCore

Quando substituído em uma classe derivada, obtém ou define um valor que indica se as variáveis locais neste construtor devem ser inicializadas por zero.

IsAbstract

Obtém um valor que indica se o método é abstrato.

(Herdado de MethodBase)
IsAssembly

Obtém um valor que indica se a visibilidade potencial deste método ou construtor é descrita por Assembly; ou seja, o construtor ou método é visível no máximo para outros tipos no mesmo assembly e não é visível a tipos derivados fora do assembly.

(Herdado de MethodBase)
IsCollectible

Obtém um valor que indica se este objeto MemberInfo faz parte de um assembly mantido em uma coleção AssemblyLoadContext.

(Herdado de MemberInfo)
IsConstructedGenericMethod

Define e representa um construtor de uma classe dinâmica.

(Herdado de MethodBase)
IsConstructor

Obtém um valor que indica se o método é um construtor.

(Herdado de MethodBase)
IsFamily

Obtém um valor que indica se a visibilidade deste método ou construtor é descrita por Family; ou seja, o método ou o construtor é visível somente dentro de sua classe e de classes derivadas.

(Herdado de MethodBase)
IsFamilyAndAssembly

Obtém um valor que indica se a visibilidade deste método ou construtor é descrita por FamANDAssem; ou seja, o método ou o construtor pode ser chamado por classes derivadas, mas apenas se estiverem no mesmo assembly.

(Herdado de MethodBase)
IsFamilyOrAssembly

Obtém um valor que indica se a visibilidade potencial deste método ou construtor é descrita por FamORAssem; ou seja, o método ou o construtor pode ser chamado por classes derivadas, não importa em que lugar elas estejam e por classes no mesmo assembly.

(Herdado de MethodBase)
IsFinal

Obtém um valor que indica se esse método é final.

(Herdado de MethodBase)
IsGenericMethod

Obtém um valor que indica se o método é genérico.

(Herdado de MethodBase)
IsGenericMethodDefinition

Obtém um valor que indica se o método é uma definição de método genérica.

(Herdado de MethodBase)
IsHideBySig

Obtém um valor que indica se apenas um membro do mesmo tipo, com exatamente a mesma assinatura, está oculto na classe derivada.

(Herdado de MethodBase)
IsPrivate

Obtém um valor que indica se este membro é privado.

(Herdado de MethodBase)
IsPublic

Obtém um valor que indica se este é um método público.

(Herdado de MethodBase)
IsSecurityCritical

Obtém um valor que indica se o método ou o construtor atual é crítico para segurança ou crítico para segurança e disponível no código transparente no nível de confiança atual e, portanto, pode realizar operações críticas.

(Herdado de MethodBase)
IsSecuritySafeCritical

Obtém um valor que indica se o método ou o construtor atual é crítico para segurança e disponível no código transparente no nível de confiança atual; ou seja, se ele pode realizar operações críticas e ser acessado pelo código transparente.

(Herdado de MethodBase)
IsSecurityTransparent

Obtém um valor que indica que se o método ou o construtor atual é transparente no nível de confiança atual e, portanto, não é pode realizar operações críticas.

(Herdado de MethodBase)
IsSpecialName

Obtém um valor que indica se esse método tem um nome especial.

(Herdado de MethodBase)
IsStatic

Obtém um valor que indica se o método é static.

(Herdado de MethodBase)
IsVirtual

Obtém um valor que indica se o método é virtual.

(Herdado de MethodBase)
MemberType

Obtém um valor MemberTypes que indica que esse membro é um construtor.

(Herdado de ConstructorInfo)
MetadataToken

Obtém um token que identifica o módulo dinâmico atual nos metadados.

MetadataToken

Obtém um valor que identifica um elemento de metadados.

(Herdado de MemberInfo)
MethodHandle

Obtém o identificador interno para o método. Use esse identificador para acessar o identificador de metadados subjacente.

MethodHandle

Obtém um identificador para a representação interna de metadados de um método.

(Herdado de MethodBase)
MethodImplementationFlags

Obtém os sinalizadores MethodImplAttributes que especificam os atributos de uma implementação de método.

MethodImplementationFlags

Obtém os sinalizadores MethodImplAttributes que especificam os atributos de uma implementação de método.

(Herdado de MethodBase)
Module

Obtém o módulo dinâmico no qual este construtor é definido.

Module

Obtém o módulo no qual o tipo que declara o membro representado pelo MemberInfo atual está definido.

(Herdado de MemberInfo)
Name

Recupera o nome desse construtor.

ReflectedType

Contém uma referência para o objeto Type do qual esse objeto foi definido.

ReflectedType

Obtém o objeto de classe que foi usado para obter esta instância de MemberInfo.

(Herdado de MemberInfo)
ReturnType
Obsoleto.

Obtém null.

Signature

Recupera a assinatura do campo na forma de uma cadeia de caracteres.

Métodos

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Adiciona a segurança declarativa a esse construtor.

DefineParameter(Int32, ParameterAttributes, String)

Define um parâmetro deste construtor.

DefineParameterCore(Int32, ParameterAttributes, String)

Quando substituído em uma classe derivada, define um parâmetro desse construtor.

Equals(Object)

Retorna um valor que indica se essa instância é igual a um objeto especificado.

(Herdado de ConstructorInfo)
GetCustomAttributes(Boolean)

Retorna todos os atributos personalizados definidos para esse construtor.

GetCustomAttributes(Boolean)

Quando substituído em uma classe derivada, retorna uma matriz de todos os atributos personalizados aplicados a esse membro.

(Herdado de MemberInfo)
GetCustomAttributes(Type, Boolean)

Retorna os atributos personalizados identificados pelo tipo determinado.

GetCustomAttributes(Type, Boolean)

Quando substituído em uma classe derivada, retorna uma matriz de atributos personalizados aplicados a esse membro e identificados por Type.

(Herdado de MemberInfo)
GetCustomAttributesData()

Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao membro de destino.

(Herdado de MemberInfo)
GetGenericArguments()

Retorna uma matriz de objetos Type que representam os argumentos de tipo de um método genérico ou os parâmetros de tipo de uma definição de método genérico.

(Herdado de MethodBase)
GetHashCode()

Retorna o código hash para a instância.

(Herdado de ConstructorInfo)
GetILGenerator()

Obtém um ILGenerator para esse construtor.

GetILGenerator(Int32)

Obtém um objeto ILGenerator, com o tamanho de fluxo MSIL especificado, que pode ser usado para criar um corpo de método para esse construtor.

GetILGeneratorCore(Int32)

Quando substituído em uma classe derivada, obtém um ILGenerator que pode ser usado para emitir um corpo de método para esse construtor.

GetMethodBody()

Quando substituído em uma classe derivada, obtém um objeto MethodBody que fornece acesso ao fluxo MSIL, variáveis locais e exceções para o método atual.

(Herdado de MethodBase)
GetMethodImplementationFlags()

Retorna os sinalizadores de implementação de método para esse construtor.

GetMethodImplementationFlags()

Quando substituído em uma classe derivada, retorna os sinalizadores MethodImplAttributes.

(Herdado de MethodBase)
GetModule()

Retorna uma referência para o módulo que contém este construtor.

GetParameters()

Retorna os parâmetros desse construtor.

GetToken()

Retorna o MethodToken que representa o token para esse construtor.

GetType()

Descobre os atributos de um construtor de classe e fornece acesso aos metadados do construtor.

(Herdado de ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo)

Define e representa um construtor de uma classe dinâmica.

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

Invoca o construtor dinamicamente representado por esta instância no objeto determinado, passando os parâmetros especificados e sob as restrições do associador determinado.

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

Quando implementado em uma classe derivada, invoca o construtor refletido por este ConstructorInfo com os argumentos especificados, sob as restrições do Binder especificado.

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

Invoca dinamicamente o construtor refletido por esta instância com os argumentos especificados, sob as restrições do Binder especificado.

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

Quando substituído em uma classe derivada, invoca o método ou o construtor refletido com parâmetros especificados.

(Herdado de MethodBase)
Invoke(Object, Object[])

Invoca o método ou o construtor representado pela instância atual, usando os parâmetros especificados.

(Herdado de MethodBase)
Invoke(Object[])

Invoca o construtor refletido pela instância que tem os parâmetros especificados, fornecendo valores padrão para os parâmetros que não são usados normalmente.

(Herdado de ConstructorInfo)
IsDefined(Type, Boolean)

Verifica se o tipo de atributo personalizado especificado é definido.

IsDefined(Type, Boolean)

Quando substituído em uma classe derivada, indica se um ou mais atributos do tipo especificado ou de seus tipos derivados são aplicados a esse membro.

(Herdado de MemberInfo)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Define um atributo personalizado usando um blob de atributo personalizado especificado.

SetCustomAttribute(CustomAttributeBuilder)

Defina um atributo personalizado usando um construtor de atributos personalizados.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Quando substituído em uma classe derivada, define um atributo personalizado nesse construtor.

SetImplementationFlags(MethodImplAttributes)

Define os sinalizadores de implementação de método para esse construtor.

SetImplementationFlagsCore(MethodImplAttributes)

Quando substituído em uma classe derivada, define os sinalizadores de implementação do método para esse construtor.

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

Cria o corpo do construtor usando uma matriz de bytes especificada de instruções do MSIL (Microsoft Intermediate Language).

SetSymCustomAttribute(String, Byte[])

Define o atributo personalizado desse construtor associado às informações simbólicas.

ToString()

Retorna essa instância ConstructorBuilder como um String.

Implantações explícitas de interface

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

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).

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

Fornece acesso a propriedades e métodos expostos por um objeto.

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

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.

(Herdado de ConstructorInfo)
_ConstructorInfo.GetType()

Obtém um objeto Type que representa o tipo ConstructorInfo.

(Herdado de ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.

(Herdado de ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).

(Herdado de ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornece acesso a propriedades e métodos expostos por um objeto.

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

Fornece objetos COM com acesso independente de versão para o método Invoke(Object, BindingFlags, Binder, Object[], CultureInfo).

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

Fornece objetos COM com acesso independente de versão para o método Invoke(Object, Object[]).

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

Fornece objetos COM com acesso independente de versão para o método Invoke(BindingFlags, Binder, Object[], CultureInfo).

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

Fornece objetos COM com acesso independente de versão para o método Invoke(Object[]).

(Herdado de ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.

(Herdado de MemberInfo)
_MemberInfo.GetType()

Obtém um objeto Type que representa a classe MemberInfo.

(Herdado de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.

(Herdado de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).

(Herdado de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornece acesso a propriedades e métodos expostos por um objeto.

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

Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição.

(Herdado de MethodBase)
_MethodBase.GetType()

Para obter uma descrição desse membro, confira GetType().

(Herdado de MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface.

(Herdado de MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1).

(Herdado de MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornece acesso a propriedades e métodos expostos por um objeto.

(Herdado de MethodBase)
_MethodBase.IsAbstract

Para obter uma descrição desse membro, confira IsAbstract.

(Herdado de MethodBase)
_MethodBase.IsAssembly

Para obter uma descrição desse membro, confira IsAssembly.

(Herdado de MethodBase)
_MethodBase.IsConstructor

Para obter uma descrição desse membro, confira IsConstructor.

(Herdado de MethodBase)
_MethodBase.IsFamily

Para obter uma descrição desse membro, confira IsFamily.

(Herdado de MethodBase)
_MethodBase.IsFamilyAndAssembly

Para obter uma descrição desse membro, confira IsFamilyAndAssembly.

(Herdado de MethodBase)
_MethodBase.IsFamilyOrAssembly

Para obter uma descrição desse membro, confira IsFamilyOrAssembly.

(Herdado de MethodBase)
_MethodBase.IsFinal

Para obter uma descrição desse membro, confira IsFinal.

(Herdado de MethodBase)
_MethodBase.IsHideBySig

Para obter uma descrição desse membro, confira IsHideBySig.

(Herdado de MethodBase)
_MethodBase.IsPrivate

Para obter uma descrição desse membro, confira IsPrivate.

(Herdado de MethodBase)
_MethodBase.IsPublic

Para obter uma descrição desse membro, confira IsPublic.

(Herdado de MethodBase)
_MethodBase.IsSpecialName

Para obter uma descrição desse membro, confira IsSpecialName.

(Herdado de MethodBase)
_MethodBase.IsStatic

Para obter uma descrição desse membro, confira IsStatic.

(Herdado de MethodBase)
_MethodBase.IsVirtual

Para obter uma descrição desse membro, confira IsVirtual.

(Herdado de MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Retorna uma matriz de todos os atributos personalizados definidos neste membro, exceto atributos nomeados ou então uma matriz vazia, se não houver nenhum atributo personalizado.

(Herdado de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Retorna uma matriz de atributos personalizados definidos neste membro, identificados por tipo ou então uma matriz vazia, se não houver nenhum atributo personalizado desse tipo.

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

Indica se uma ou mais instâncias de attributeType estão definidas nesse membro.

(Herdado de MemberInfo)

Métodos de Extensão

GetCustomAttribute(MemberInfo, Type)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.

GetCustomAttribute(MemberInfo, Type, Boolean)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttribute<T>(MemberInfo)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.

GetCustomAttribute<T>(MemberInfo, Boolean)

Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttributes(MemberInfo)

Recupera uma coleção de atributos personalizados que são aplicados a um membro especificado.

GetCustomAttributes(MemberInfo, Boolean)

Recupera uma coleção de atributos personalizados aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttributes(MemberInfo, Type)

Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.

GetCustomAttributes(MemberInfo, Type, Boolean)

Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

GetCustomAttributes<T>(MemberInfo)

Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.

GetCustomAttributes<T>(MemberInfo, Boolean)

Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.

IsDefined(MemberInfo, Type)

Indica se os atributos personalizados de um tipo especificados são aplicados a um membro especificado.

IsDefined(MemberInfo, Type, Boolean)

Indica se os atributos personalizados de um tipo especificado são aplicados a um membro especificado e, opcionalmente, aplicados a seus ancestrais.

GetMetadataToken(MemberInfo)

Obtém um token de metadados para o membro fornecido, se disponível.

HasMetadataToken(MemberInfo)

Retorna um valor que indica se um token de metadados está disponível para o membro especificado.

Aplica-se a