ConstructorBuilder Kelas

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

System.Reflection.Emit.dll

Sumber:

ConstructorBuilder.cs

Mendefinisikan dan mewakili konstruktor kelas dinamis.

public ref class ConstructorBuilder abstract : System::Reflection::ConstructorInfo

public abstract class ConstructorBuilder : System.Reflection.ConstructorInfo

type ConstructorBuilder = class
    inherit ConstructorInfo

Public MustInherit Class ConstructorBuilder
Inherits ConstructorInfo

Warisan

Object

MemberInfo

MethodBase

ConstructorInfo

ConstructorBuilder

Contoh

Sampel kode berikut mengilustrasikan penggunaan kontekstual dari 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

Keterangan

ConstructorBuilder digunakan untuk sepenuhnya menggambarkan konstruktor dalam bahasa perantara Microsoft (MSIL), termasuk nama, atribut, tanda tangan, dan isi konstruktor. Ini digunakan bersama dengan TypeBuilder kelas untuk membuat kelas pada durasi. Panggil DefineConstructor untuk mendapatkan instans ConstructorBuilder.

Jika Anda tidak menentukan konstruktor untuk jenis dinamis Anda, konstruktor tanpa parameter disediakan secara otomatis, dan memanggil konstruktor tanpa parameter dari kelas dasar.

Jika Anda menggunakan ConstructorBuilder untuk menentukan konstruktor untuk jenis dinamis Anda, konstruktor tanpa parameter tidak disediakan. Anda memiliki opsi berikut untuk menyediakan konstruktor tanpa parameter selain konstruktor yang Anda tentukan:

• Jika Anda menginginkan konstruktor tanpa parameter yang hanya memanggil konstruktor tanpa parameter dari kelas dasar, Anda dapat menggunakan TypeBuilder.DefineDefaultConstructor metode untuk membuatnya (dan secara opsional membatasi akses ke dalamnya). Jangan berikan implementasi untuk konstruktor tanpa parameter ini. Jika Anda melakukannya, pengecualian dilemparkan ketika Anda mencoba menggunakan konstruktor. Tidak ada pengecualian yang dilemparkan ketika TypeBuilder.CreateType metode dipanggil.

• Jika Anda menginginkan konstruktor tanpa parameter yang melakukan sesuatu lebih dari sekadar memanggil konstruktor tanpa parameter dari kelas dasar, atau yang memanggil konstruktor lain dari kelas dasar, atau yang melakukan sesuatu yang lain sepenuhnya, Anda harus menggunakan TypeBuilder.DefineConstructor metode untuk membuat ConstructorBuilder, dan menyediakan implementasi Anda sendiri.

Konstruktor

ConstructorBuilder()

Menginisialisasi instans baru kelas ConstructorBuilder.

Properti

Attributes	Mendapatkan atribut untuk konstruktor ini.
CallingConvention	CallingConventions Mendapatkan nilai yang bergantung pada apakah jenis deklarasikan bersifat generik.
ContainsGenericParameters	Mendapatkan nilai yang menunjukkan apakah metode generik berisi parameter jenis generik yang tidak ditetapkan. (Diperoleh dari MethodBase)
CustomAttributes	Mendapatkan koleksi yang berisi atribut kustom anggota ini. (Diperoleh dari MemberInfo)
DeclaringType	Mendapatkan referensi ke Type objek untuk jenis yang mendeklarasikan anggota ini.
InitLocals	Mendapatkan atau mengatur apakah variabel lokal dalam konstruktor ini harus diinisialisasi nol.
InitLocalsCore	Ketika ditimpa di kelas turunan, mendapatkan atau menetapkan nilai yang menunjukkan apakah variabel lokal dalam konstruktor ini harus diinisialisasi nol.
IsAbstract	Mendapatkan nilai yang menunjukkan apakah metodenya abstrak. (Diperoleh dari MethodBase)
IsAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas potensial dari metode atau konstruktor ini dijelaskan oleh Assembly; yaitu, metode atau konstruktor paling banyak terlihat oleh jenis lain dalam rakitan yang sama, dan tidak terlihat oleh jenis turunan di luar perakitan. (Diperoleh dari MethodBase)
IsCollectible	Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo adalah bagian dari perakitan yang dipegang dalam koleksi AssemblyLoadContext. (Diperoleh dari MemberInfo)
IsConstructedGenericMethod	Mendefinisikan dan mewakili konstruktor kelas dinamis. (Diperoleh dari MethodBase)
IsConstructor	Mendapatkan nilai yang menunjukkan apakah metode tersebut adalah konstruktor. (Diperoleh dari MethodBase)
IsFamily	Mendapatkan nilai yang menunjukkan apakah visibilitas metode atau konstruktor ini dijelaskan oleh Family; yaitu, metode atau konstruktor hanya terlihat dalam kelas dan kelas turunannya. (Diperoleh dari MethodBase)
IsFamilyAndAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas metode atau konstruktor ini dijelaskan oleh FamANDAssem; yaitu, metode atau konstruktor dapat dipanggil oleh kelas turunan, tetapi hanya jika mereka berada dalam perakitan yang sama. (Diperoleh dari MethodBase)
IsFamilyOrAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas potensial dari metode atau konstruktor ini dijelaskan oleh FamORAssem; yaitu, metode atau konstruktor dapat dipanggil oleh kelas turunan di mana pun mereka berada, dan berdasarkan kelas dalam rakitan yang sama. (Diperoleh dari MethodBase)
IsFinal	Mendapatkan nilai yang menunjukkan apakah metode ini adalah final. (Diperoleh dari MethodBase)
IsGenericMethod	Mendapatkan nilai yang menunjukkan apakah metode tersebut generik. (Diperoleh dari MethodBase)
IsGenericMethodDefinition	Mendapatkan nilai yang menunjukkan apakah metode tersebut adalah definisi metode generik. (Diperoleh dari MethodBase)
IsHideBySig	Mendapatkan nilai yang menunjukkan apakah hanya anggota dengan jenis yang sama dengan tanda tangan yang sama persis yang disembunyikan di kelas turunan. (Diperoleh dari MethodBase)
IsPrivate	Mendapatkan nilai yang menunjukkan apakah anggota ini bersifat privat. (Diperoleh dari MethodBase)
IsPublic	Mendapatkan nilai yang menunjukkan apakah ini adalah metode publik. (Diperoleh dari MethodBase)
IsSecurityCritical	Mendapatkan nilai yang menunjukkan apakah metode atau konstruktor saat ini kritis terhadap keamanan atau keamanan-aman-kritis pada tingkat kepercayaan saat ini, dan karenanya dapat melakukan operasi penting. (Diperoleh dari MethodBase)
IsSecuritySafeCritical	Mendapatkan nilai yang menunjukkan apakah metode atau konstruktor saat ini kritis keamanan-aman-kritis pada tingkat kepercayaan saat ini; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan. (Diperoleh dari MethodBase)
IsSecurityTransparent	Mendapatkan nilai yang menunjukkan apakah metode atau konstruktor saat ini transparan pada tingkat kepercayaan saat ini, dan karenanya tidak dapat melakukan operasi penting. (Diperoleh dari MethodBase)
IsSpecialName	Mendapatkan nilai yang menunjukkan apakah metode ini memiliki nama khusus. (Diperoleh dari MethodBase)
IsStatic	Mendapatkan nilai yang menunjukkan apakah metodenya adalah static. (Diperoleh dari MethodBase)
IsVirtual	Mendapatkan nilai yang menunjukkan apakah metodenya adalah virtual. (Diperoleh dari MethodBase)
MemberType	Mendapatkan nilai yang MemberTypes menunjukkan bahwa anggota ini adalah konstruktor. (Diperoleh dari ConstructorInfo)
MetadataToken	Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.
MethodHandle	Mendapatkan handel internal untuk metode . Gunakan handel ini untuk mengakses handel metadata yang mendasar.
MethodImplementationFlags	MethodImplAttributes Mendapatkan bendera yang menentukan atribut implementasi metode. (Diperoleh dari MethodBase)
Module	Mendapatkan modul dinamis tempat konstruktor ini didefinisikan.
Name	Mengambil nama konstruktor ini.
ReflectedType	Menyimpan referensi ke Type objek tempat objek ini diperoleh.

Metode

DefineParameter(Int32, ParameterAttributes, String)	Mendefinisikan parameter konstruktor ini.
DefineParameterCore(Int32, ParameterAttributes, String)	Ketika ditimpa dalam kelas turunan, menentukan parameter konstruktor ini.
Equals(Object)	Mengembalikan nilai yang menunjukkan apakah instans ini sama dengan objek tertentu. (Diperoleh dari ConstructorInfo)
GetCustomAttributes(Boolean)	Mengembalikan semua atribut kustom yang ditentukan untuk konstruktor ini.
GetCustomAttributes(Type, Boolean)	Mengembalikan atribut kustom yang diidentifikasi oleh jenis yang diberikan.
GetCustomAttributesData()	Mengembalikan daftar CustomAttributeData objek yang mewakili data tentang atribut yang telah diterapkan ke anggota target. (Diperoleh dari MemberInfo)
GetGenericArguments()	Mengembalikan array Type objek yang mewakili argumen jenis metode generik atau parameter jenis definisi metode generik. (Diperoleh dari MethodBase)
GetHashCode()	Mengembalikan kode hash untuk instans ini. (Diperoleh dari ConstructorInfo)
GetILGenerator()	ILGenerator Mendapatkan untuk konstruktor ini.
GetILGenerator(Int32)	ILGenerator Mendapatkan objek, dengan ukuran aliran MSIL yang ditentukan, yang dapat digunakan untuk membangun isi metode untuk konstruktor ini.
GetILGeneratorCore(Int32)	Ketika ditimpa di kelas turunan ILGenerator , mendapatkan yang dapat digunakan untuk memancarkan isi metode untuk konstruktor ini.
GetMethodBody()	Ketika ditimpa di kelas turunan, mendapatkan MethodBody objek yang menyediakan akses ke aliran MSIL, variabel lokal, dan pengecualian untuk metode saat ini. (Diperoleh dari MethodBase)
GetMethodImplementationFlags()	Mengembalikan bendera implementasi metode untuk konstruktor ini.
GetParameters()	Mengembalikan parameter konstruktor ini.
GetType()	Menemukan atribut konstruktor kelas dan menyediakan akses ke metadata konstruktor. (Diperoleh dari ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Mendefinisikan dan mewakili konstruktor kelas dinamis. (Diperoleh dari MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)	Secara dinamis memanggil konstruktor yang diwakili oleh instans ini pada objek yang diberikan, melewati parameter yang ditentukan, dan di bawah batasan pengikat yang diberikan.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Secara dinamis memanggil konstruktor yang tercermin oleh instans ini dengan argumen yang ditentukan, di bawah batasan yang ditentukan Binder.
Invoke(Object, Object[])	Memanggil metode atau konstruktor yang diwakili oleh instans saat ini, menggunakan parameter yang ditentukan. (Diperoleh dari MethodBase)
Invoke(Object[])	Memanggil konstruktor yang tercermin oleh instans yang memiliki parameter yang ditentukan, menyediakan nilai default untuk parameter yang tidak umum digunakan. (Diperoleh dari ConstructorInfo)
IsDefined(Type, Boolean)	Memeriksa apakah jenis atribut kustom yang ditentukan ditentukan.
MemberwiseClone()	Membuat salinan dangkal dari saat ini Object. (Diperoleh dari Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Atur atribut kustom menggunakan blob atribut kustom tertentu.
SetCustomAttribute(CustomAttributeBuilder)	Atur atribut kustom menggunakan penyusun atribut kustom.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Saat ditimpa di kelas turunan, mengatur atribut kustom pada konstruktor ini.
SetImplementationFlags(MethodImplAttributes)	Mengatur bendera implementasi metode untuk konstruktor ini.
SetImplementationFlagsCore(MethodImplAttributes)	Ketika ditimpa di kelas turunan, mengatur bendera implementasi metode untuk konstruktor ini.
ToString()	Mengembalikan instans ini ConstructorBuilder sebagai String.

Metode Ekstensi

GetCustomAttribute(MemberInfo, Type)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute(MemberInfo, Type, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute<T>(MemberInfo)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute<T>(MemberInfo, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Type, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes<T>(MemberInfo)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes<T>(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
IsDefined(MemberInfo, Type)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.
IsDefined(MemberInfo, Type, Boolean)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.
GetMetadataToken(MemberInfo)	Mendapatkan token metadata untuk anggota tertentu, jika tersedia.
HasMetadataToken(MemberInfo)	Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.