Bagikan melalui


ConstructorBuilder Kelas

Definisi

Mendefinisikan dan mewakili konstruktor kelas dinamis.

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
Warisan
Atribut
Penerapan

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.

CallingConvention

Mendapatkan nilai yang menunjukkan konvensi panggilan untuk metode ini.

(Diperoleh dari MethodBase)
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.

MetadataToken

Mendapatkan nilai yang mengidentifikasi elemen metadata.

(Diperoleh dari MemberInfo)
MethodHandle

Mendapatkan handel internal untuk metode . Gunakan handel ini untuk mengakses handel metadata yang mendasar.

MethodHandle

Mendapatkan handel ke representasi metadata internal metode.

(Diperoleh dari MethodBase)
MethodImplementationFlags

MethodImplAttributes Mendapatkan bendera yang menentukan atribut implementasi metode.

MethodImplementationFlags

MethodImplAttributes Mendapatkan bendera yang menentukan atribut implementasi metode.

(Diperoleh dari MethodBase)
Module

Mendapatkan modul dinamis tempat konstruktor ini didefinisikan.

Module

Mendapatkan modul di mana jenis yang menyatakan anggota yang diwakili oleh saat ini MemberInfo ditentukan.

(Diperoleh dari MemberInfo)
Name

Mengambil nama konstruktor ini.

ReflectedType

Menyimpan referensi ke Type objek tempat objek ini diperoleh.

ReflectedType

Mendapatkan objek kelas yang digunakan untuk mendapatkan instans ini dari MemberInfo.

(Diperoleh dari MemberInfo)
ReturnType
Kedaluwarsa.

nullMendapatkan .

Signature

Mengambil tanda tangan bidang dalam bentuk string.

Metode

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Menambahkan keamanan deklaratif ke konstruktor ini.

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

Saat ditimpa di kelas turunan, mengembalikan array semua atribut kustom yang diterapkan ke anggota ini.

(Diperoleh dari MemberInfo)
GetCustomAttributes(Type, Boolean)

Mengembalikan atribut kustom yang diidentifikasi oleh jenis yang diberikan.

GetCustomAttributes(Type, Boolean)

Saat ditimpa di kelas turunan, mengembalikan array atribut kustom yang diterapkan ke anggota ini dan diidentifikasi oleh Type.

(Diperoleh dari MemberInfo)
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.

GetMethodImplementationFlags()

Saat ditimpa di kelas turunan, mengembalikan MethodImplAttributes bendera.

(Diperoleh dari MethodBase)
GetModule()

Mengembalikan referensi ke modul yang berisi konstruktor ini.

GetParameters()

Mengembalikan parameter konstruktor ini.

GetToken()

Mengembalikan MethodToken yang mewakili token untuk 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(BindingFlags, Binder, Object[], CultureInfo)

Ketika diimplementasikan dalam kelas turunan, memanggil konstruktor yang tercermin oleh ini ConstructorInfo dengan argumen yang ditentukan, di bawah batasan yang ditentukan Binder.

(Diperoleh dari ConstructorInfo)
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, BindingFlags, Binder, Object[], CultureInfo)

Ketika ditimpa di kelas turunan, memanggil metode atau konstruktor yang tercermin dengan parameter yang diberikan.

(Diperoleh dari MethodBase)
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.

IsDefined(Type, Boolean)

Ketika ditimpa di kelas turunan, menunjukkan apakah satu atau beberapa atribut dari jenis yang ditentukan atau jenis turunannya diterapkan kepada anggota ini.

(Diperoleh dari MemberInfo)
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.

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

Membuat isi konstruktor dengan menggunakan array byte tertentu dari instruksi bahasa perantara Microsoft (MSIL).

SetSymCustomAttribute(String, Byte[])

Mengatur atribut kustom konstruktor ini yang terkait dengan informasi simbolis.

ToString()

Mengembalikan instans ini ConstructorBuilder sebagai String.

Implementasi Antarmuka Eksplisit

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

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

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

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

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

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.GetType()

Mendapatkan objek yang Type mewakili jenis .ConstructorInfo

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

Menyediakan objek COM dengan akses independen versi ke Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) metode .

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

Menyediakan objek COM dengan akses independen versi ke Invoke(Object, Object[]) metode .

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

Menyediakan objek COM dengan akses independen versi ke Invoke(BindingFlags, Binder, Object[], CultureInfo) metode .

(Diperoleh dari ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

Menyediakan objek COM dengan akses independen versi ke Invoke(Object[]) metode .

(Diperoleh dari ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari MemberInfo)
_MemberInfo.GetType()

Mendapatkan objek yang Type mewakili MemberInfo kelas .

(Diperoleh dari MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Memetakan sekumpulan nama ke sekumpulan pengidentifikasi pengiriman yang sesuai.

(Diperoleh dari MethodBase)
_MethodBase.GetType()

Untuk deskripsi anggota ini, lihat GetType().

(Diperoleh dari MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Mengambil informasi jenis untuk objek, yang kemudian dapat digunakan untuk mendapatkan informasi jenis untuk antarmuka.

(Diperoleh dari MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Mengambil jumlah antarmuka informasi jenis yang disediakan objek (baik 0 atau 1).

(Diperoleh dari MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Menyediakan akses ke properti dan metode yang diekspos oleh objek.

(Diperoleh dari MethodBase)
_MethodBase.IsAbstract

Untuk deskripsi anggota ini, lihat IsAbstract.

(Diperoleh dari MethodBase)
_MethodBase.IsAssembly

Untuk deskripsi anggota ini, lihat IsAssembly.

(Diperoleh dari MethodBase)
_MethodBase.IsConstructor

Untuk deskripsi anggota ini, lihat IsConstructor.

(Diperoleh dari MethodBase)
_MethodBase.IsFamily

Untuk deskripsi anggota ini, lihat IsFamily.

(Diperoleh dari MethodBase)
_MethodBase.IsFamilyAndAssembly

Untuk deskripsi anggota ini, lihat IsFamilyAndAssembly.

(Diperoleh dari MethodBase)
_MethodBase.IsFamilyOrAssembly

Untuk deskripsi anggota ini, lihat IsFamilyOrAssembly.

(Diperoleh dari MethodBase)
_MethodBase.IsFinal

Untuk deskripsi anggota ini, lihat IsFinal.

(Diperoleh dari MethodBase)
_MethodBase.IsHideBySig

Untuk deskripsi anggota ini, lihat IsHideBySig.

(Diperoleh dari MethodBase)
_MethodBase.IsPrivate

Untuk deskripsi anggota ini, lihat IsPrivate.

(Diperoleh dari MethodBase)
_MethodBase.IsPublic

Untuk deskripsi anggota ini, lihat IsPublic.

(Diperoleh dari MethodBase)
_MethodBase.IsSpecialName

Untuk deskripsi anggota ini, lihat IsSpecialName.

(Diperoleh dari MethodBase)
_MethodBase.IsStatic

Untuk deskripsi anggota ini, lihat IsStatic.

(Diperoleh dari MethodBase)
_MethodBase.IsVirtual

Untuk deskripsi anggota ini, lihat IsVirtual.

(Diperoleh dari MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Mengembalikan array dari semua atribut kustom yang ditentukan pada anggota ini, tidak termasuk atribut bernama, atau array kosong jika tidak ada atribut kustom.

(Diperoleh dari MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Mengembalikan array atribut kustom yang ditentukan pada anggota ini, diidentifikasi berdasarkan jenis, atau array kosong jika tidak ada atribut kustom dari jenis tersebut.

(Diperoleh dari MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Menunjukkan apakah satu atau beberapa attributeType instans ditentukan pada anggota ini.

(Diperoleh dari MemberInfo)

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.

Berlaku untuk