ConstructorBuilder 클래스

정의

네임스페이스:

System.Reflection.Emit

어셈블리:

System.Reflection.Emit.dll

Source:

ConstructorBuilder.cs

동적 클래스의 생성자를 정의하고 나타냅니다.

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

상속

Object

MemberInfo

MethodBase

ConstructorInfo

ConstructorBuilder

예제

다음 코드 샘플에서는 의 컨텍스트 사용량을 보여 줍니다 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

설명

ConstructorBuilder 는 이름, 특성, 서명 및 생성자 본문을 포함하여 MSIL(Microsoft Intermediate Language)의 생성자를 완전히 설명하는 데 사용됩니다. 클래스와 함께 런타임에 TypeBuilder 클래스를 만드는 데 사용됩니다. 를 호출 DefineConstructor 하여 의 ConstructorBuilderinstance 가져옵니다.

동적 형식에 대한 생성자를 정의하지 않으면 매개 변수가 없는 생성자가 자동으로 제공되고 기본 클래스의 매개 변수가 없는 생성자를 호출합니다.

를 사용하여 ConstructorBuilder 동적 형식에 대한 생성자를 정의하는 경우 매개 변수가 없는 생성자가 제공되지 않습니다. 정의한 생성자 외에도 매개 변수가 없는 생성자를 제공하기 위한 다음 옵션이 있습니다.

• 기본 클래스의 매개 변수 없는 생성자를 호출하는 매개 변수가 없는 생성자를 원하는 경우 메서드를 사용하여 TypeBuilder.DefineDefaultConstructor 생성하고 필요에 따라 액세스를 제한할 수 있습니다. 이 매개 변수가 없는 생성자에 대한 구현을 제공하지 마세요. 이렇게 하면 생성자를 사용하려고 할 때 예외가 throw됩니다. 메서드가 호출되면 예외가 TypeBuilder.CreateType throw되지 않습니다.

• 단순히 기본 클래스의 매개 변수 없는 생성자를 호출하는 것 이상의 작업을 수행하거나 기본 클래스의 다른 생성자를 호출하거나 완전히 다른 작업을 수행하는 매개 변수 없는 생성자를 원하는 경우 메서드를 사용하여 TypeBuilder.DefineConstructor 를 만들고 ConstructorBuilder고유한 구현을 제공해야 합니다.

생성자

ConstructorBuilder()

ConstructorBuilder 클래스의 새 인스턴스를 초기화합니다.

속성

Attributes	이 생성자에 대한 특성을 가져옵니다.
CallingConvention	선언 형식이 제네릭인지에 따라 CallingConventions 값을 가져옵니다.
ContainsGenericParameters	제네릭 메서드에 할당되지 않은 제네릭 형식 매개 변수가 포함되어 있는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
CustomAttributes	이 멤버의 사용자 지정 특성을 포함하는 컬렉션을 가져옵니다. (다음에서 상속됨 MemberInfo)
DeclaringType	이 멤버를 선언하는 형식의 Type 개체에 대한 참조를 가져옵니다.
InitLocals	이 생성자의 로컬 변수를 0으로 초기화해야 하는지 여부를 나타내는 값을 가져오거나 설정합니다.
InitLocalsCore	파생 클래스에서 재정의되는 경우 이 생성자의 지역 변수를 0으로 초기화해야 하는지 여부를 나타내는 값을 가져오거나 설정합니다.
IsAbstract	이 메서드가 추상 메서드인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsAssembly	Assembly에서 이 메서드나 생성자의 잠재적 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 같은 어셈블리의 다른 형식에만 표시되고 어셈블리 외부의 파생 형식에는 표시되지 않습니다. (다음에서 상속됨 MethodBase)
IsCollectible	이 MemberInfo 개체가 수집 가능한 AssemblyLoadContext에 보관된 어셈블리의 일부인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MemberInfo)
IsConstructedGenericMethod	동적 클래스의 생성자를 정의하고 나타냅니다. (다음에서 상속됨 MethodBase)
IsConstructor	메서드가 생성자인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsFamily	Family에서 이 메서드나 생성자의 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 해당 클래스 및 파생 클래스에만 표시됩니다. (다음에서 상속됨 MethodBase)
IsFamilyAndAssembly	FamANDAssem에서 이 메서드나 생성자의 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 같은 어셈블리에 있는 경우에만 파생 클래스에서 호출할 수 있습니다. (다음에서 상속됨 MethodBase)
IsFamilyOrAssembly	FamORAssem에서 이 메서드나 생성자의 잠재적 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 파생 클래스(있는 경우) 및 같은 어셈블리의 클래스에서 호출할 수 있습니다. (다음에서 상속됨 MethodBase)
IsFinal	이 메서드가 final인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsGenericMethod	메서드가 제네릭 메서드인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsGenericMethodDefinition	메서드가 제네릭 메서드 정의인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsHideBySig	동일한 시그니처가 있는 동일한 종류의 멤버만을 파생 클래스에서 숨길 수 있는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsPrivate	이 멤버가 프라이빗인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsPublic	이 메서드가 public 메서드인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsSecurityCritical	현재 메서드나 생성자가 현재 신뢰 수준에서 보안에 중요한 형식이거나 보안 안전에 중요한 형식이어서 중요한 작업을 수행할 수 있는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsSecuritySafeCritical	현재 메서드나 생성자가 현재 신뢰 수준에서 보안 안전에 중요한 형식인지 즉, 중요한 작업을 수행할 수 있고 투명 코드로 액세스할 수 있는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsSecurityTransparent	현재 메서드나 생성자가 현재 신뢰 수준에서 투명하여 중요한 작업을 수행할 수 없는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsSpecialName	이 메서드의 이름이 특수한지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsStatic	메서드가 static인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
IsVirtual	메서드가 virtual인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MethodBase)
MemberType	이 멤버가 생성자임을 나타내는 MemberTypes 값을 가져옵니다. (다음에서 상속됨 ConstructorInfo)
MetadataToken	메타데이터에서 현재 동적 모듈을 식별하는 토큰을 가져옵니다.
MethodHandle	메서드에 대한 내부 핸들을 가져옵니다. 이 핸들을 사용하여 내부 메타데이터 핸들에 액세스할 수 있습니다.
MethodImplementationFlags	메서드 구현의 특성을 지정하는 MethodImplAttributes 플래그를 가져옵니다. (다음에서 상속됨 MethodBase)
Module	이 생성자가 정의된 동적 모듈을 가져옵니다.
Name	이 생성자의 이름을 검색합니다.
ReflectedType	이 개체를 가져온 원본 Type 개체에 대한 참조를 보유합니다.

메서드

DefineParameter(Int32, ParameterAttributes, String)	이 생성자의 매개 변수를 정의합니다.
DefineParameterCore(Int32, ParameterAttributes, String)	파생 클래스에서 재정의되는 경우 이 생성자의 매개 변수를 정의합니다.
Equals(Object)	이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다. (다음에서 상속됨 ConstructorInfo)
GetCustomAttributes(Boolean)	이 생성자에 대해 정의된 모든 사용자 지정 특성을 반환합니다.
GetCustomAttributes(Type, Boolean)	지정된 형식으로 식별되는 사용자 지정 특성을 반환합니다.
GetCustomAttributesData()	대상 멤버에 적용된 특성에 대한 데이터를 나타내는 CustomAttributeData 개체의 목록을 반환합니다. (다음에서 상속됨 MemberInfo)
GetGenericArguments()	제네릭 메서드의 형식 인수나 제네릭 메서드 정의의 형식 매개 변수를 나타내는 Type 개체의 배열을 반환합니다. (다음에서 상속됨 MethodBase)
GetHashCode()	이 인스턴스의 해시 코드를 반환합니다. (다음에서 상속됨 ConstructorInfo)
GetILGenerator()	이 생성자에 대한 ILGenerator 를 가져옵니다.
GetILGenerator(Int32)	지정한 MSIL 스트림 크기를 가지며, 이 생성자에 대한 메서드 본문을 작성하는 데 사용할 수 있는 ILGenerator 개체를 가져옵니다.
GetILGeneratorCore(Int32)	파생 클래스에서 재정의되는 경우 이 생성자에 대한 메서드 본문을 내보내는 데 사용할 수 있는 을 가져옵니다 ILGenerator .
GetMethodBody()	파생 클래스에서 재정의된 경우, 현재 메서드의 MSIL 스트림, 지역 변수 및 예외에 액세스할 수 있도록 하는 MethodBody 개체를 가져옵니다. (다음에서 상속됨 MethodBase)
GetMethodImplementationFlags()	해당 생성자에 대한 메서드 구현 플래그를 반환합니다.
GetParameters()	이 생성자의 매개 변수를 반환합니다.
GetType()	클래스 생성자의 특성을 검색하고 생성자 메타데이터에 액세스할 수 있도록 합니다. (다음에서 상속됨 ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo)	동적 클래스의 생성자를 정의하고 나타냅니다. (다음에서 상속됨 MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)	지정된 바인더의 제약 조건에 따라 지정한 매개 변수를 전달하여 지정된 개체에 있는 이 인스턴스로 나타나는 생성자를 동적으로 호출합니다.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	지정된 Binder의 제약 조건에 따라, 지정된 인수를 사용하여 이 인스턴스에 의해 리플렉션된 생성자를 동적으로 호출합니다.
Invoke(Object, Object[])	지정된 매개 변수를 사용하여 현재 인스턴스로 나타낸 메서드 또는 생성자를 호출합니다. (다음에서 상속됨 MethodBase)
Invoke(Object[])	지정된 매개 변수가 있는 인스턴스에서 리플렉트된 생성자를 호출하고 일반적으로 사용되지 않는 매개 변수에 대해 기본값을 제공합니다. (다음에서 상속됨 ConstructorInfo)
IsDefined(Type, Boolean)	지정된 사용자 지정 특성 유형이 정의되었는지 확인합니다.
MemberwiseClone()	현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object)
SetCustomAttribute(ConstructorInfo, Byte[])	지정된 사용자 지정 특성 blob을 사용하여 사용자 지정 특성을 설정합니다.
SetCustomAttribute(CustomAttributeBuilder)	사용자 지정 특성 작성기를 사용하여 사용자 지정 특성을 설정합니다.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	파생 클래스에서 재정의되는 경우 이 생성자에서 사용자 지정 특성을 설정합니다.
SetImplementationFlags(MethodImplAttributes)	이 생성자에 대한 메서드 구현 플래그를 설정합니다.
SetImplementationFlagsCore(MethodImplAttributes)	파생 클래스에서 재정의되는 경우 이 생성자에 대한 메서드 구현 플래그를 설정합니다.
ToString()	이 ConstructorBuilder 인스턴스를 String으로 반환합니다.

확장 메서드

GetCustomAttribute(MemberInfo, Type)	지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성을 검색합니다.
GetCustomAttribute(MemberInfo, Type, Boolean)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.
GetCustomAttribute<T>(MemberInfo)	지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성을 검색합니다.
GetCustomAttribute<T>(MemberInfo, Boolean)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.
GetCustomAttributes(MemberInfo)	지정된 멤버에 적용된 사용자 지정 특성 컬렉션을 검색합니다.
GetCustomAttributes(MemberInfo, Boolean)	사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.
GetCustomAttributes(MemberInfo, Type)	지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성 컬렉션을 검색합니다.
GetCustomAttributes(MemberInfo, Type, Boolean)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.
GetCustomAttributes<T>(MemberInfo)	지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성 컬렉션을 검색합니다.
GetCustomAttributes<T>(MemberInfo, Boolean)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.
IsDefined(MemberInfo, Type)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지 여부를 나타냅니다.
IsDefined(MemberInfo, Type, Boolean)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지, 또는 선택적으로 상위 항목에 적용되었는지 여부를 결정합니다.
GetMetadataToken(MemberInfo)	사용 가능한 경우 지정된 멤버의 메타데이터 토큰을 가져옵니다.
HasMetadataToken(MemberInfo)	지정된 멤버에 대해 메타데이터 토큰을 사용할 수 있는지를 나타내는 값을 반환합니다.