ConstructorBuilder 클래스

정의

동적 클래스의 생성자를 정의하고 나타냅니다.Defines and represents a constructor of a dynamic class.

public ref class ConstructorBuilder sealed : 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
    interface _ConstructorBuilder
Public NotInheritable Class ConstructorBuilder
Inherits ConstructorInfo
Implements _ConstructorBuilder
상속
특성
구현

예제

다음 코드 샘플에서는 ConstructorBuilder의 상황별 사용을 보여 줍니다.The following code sample illustrates the contextual usage of a 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 중간 언어)의 생성자를 완전히 설명 하는 데 사용 됩니다.ConstructorBuilder is used to fully describe a constructor in Microsoft intermediate language (MSIL), including the name, attributes, signature, and constructor body. 런타임에 클래스를 만들기 위해 TypeBuilder 클래스와 함께 사용 됩니다.It is used in conjunction with the TypeBuilder class to create classes at run time. DefineConstructor를 호출 하 여 ConstructorBuilder의 인스턴스를 가져옵니다.Call DefineConstructor to get an instance of ConstructorBuilder.

동적 형식에 대 한 생성자를 정의 하지 않은 경우에는 매개 변수가 없는 생성자가 자동으로 제공 되며 기본 클래스의 매개 변수가 없는 생성자를 호출 합니다.If you do not define a constructor for your dynamic type, a parameterless constructor is provided automatically, and it calls the parameterless constructor of the base class.

ConstructorBuilder를 사용 하 여 동적 형식에 대 한 생성자를 정의 하는 경우 매개 변수가 없는 생성자가 제공 되지 않습니다.If you use ConstructorBuilder to define a constructor for your dynamic type, a parameterless constructor is not provided. 정의한 생성자 외에도 매개 변수가 없는 생성자를 제공 하기 위해 다음과 같은 옵션이 있습니다.You have the following options for providing a parameterless constructor in addition to the constructor you defined:

  • 기본 클래스의 매개 변수가 없는 생성자를 단순히 호출 하는 매개 변수가 없는 생성자를 사용 하려면 TypeBuilder.DefineDefaultConstructor 메서드를 사용 하 여 해당 생성자를 만들고 필요에 따라 액세스를 제한할 수 있습니다.If you want a parameterless constructor that simply calls the parameterless constructor of the base class, you can use the TypeBuilder.DefineDefaultConstructor method to create one (and optionally restrict access to it). 이 매개 변수가 없는 생성자에 대 한 구현을 제공 하지 마십시오.Do not provide an implementation for this parameterless constructor. 이렇게 하면 생성자를 사용 하려고 할 때 예외가 throw 됩니다.If you do, an exception is thrown when you try to use the constructor. TypeBuilder.CreateType 메서드를 호출 하면 예외가 throw 되지 않습니다.No exception is thrown when the TypeBuilder.CreateType method is called.

  • 단순히 기본 클래스의 매개 변수가 없는 생성자를 호출 하거나 기본 클래스의 다른 생성자를 호출 하거나 다른 작업을 수행 하는 매개 변수가 없는 생성자를 사용 하려면 TypeBuilder.DefineConstructor 메서드를 사용 하 여 ConstructorBuilder을 만들고 고유한 구현을 제공 해야 합니다.If you want a parameterless constructor that does something more than simply calling the parameterless constructor of the base class, or that calls another constructor of the base class, or that does something else entirely, you must use the TypeBuilder.DefineConstructor method to create a ConstructorBuilder, and provide your own implementation.

속성

Attributes

이 생성자에 대한 특성을 가져옵니다.Gets the attributes for this constructor.

CallingConvention

선언 형식이 제네릭 형식인지 여부에 따라 달라지는 CallingConventions 값을 가져옵니다.Gets a CallingConventions value that depends on whether the declaring type is generic.

ContainsGenericParameters

제네릭 메서드에 할당 되지 않은 제네릭 형식 매개 변수를 포함 되는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the generic method contains unassigned generic type parameters.

(다음에서 상속됨 MethodBase)
CustomAttributes

이 멤버의 사용자 지정 특성이 포함 된 컬렉션을 가져옵니다.Gets a collection that contains this member's custom attributes.

(다음에서 상속됨 MemberInfo)
DeclaringType

이 멤버를 선언하는 형식의 Type 개체에 대한 참조를 가져옵니다.Gets a reference to the Type object for the type that declares this member.

InitLocals

이 생성자의 로컬 변수를 0으로 초기화해야 하는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets whether the local variables in this constructor should be zero-initialized.

IsAbstract

이 메서드가 추상 메서드인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is abstract.

(다음에서 상속됨 MethodBase)
IsAssembly

Assembly에서 이 메서드나 생성자의 잠재적 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 같은 어셈블리의 다른 형식에만 표시되고 어셈블리 외부의 파생 형식에는 표시되지 않습니다.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(다음에서 상속됨 MethodBase)
IsCollectible

MemberInfo 개체가 수집 가능한 AssemblyLoadContext에 보관된 어셈블리의 일부인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(다음에서 상속됨 MemberInfo)
IsConstructedGenericMethod (다음에서 상속됨 MethodBase)
IsConstructor

메서드가 생성자 인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is a constructor.

(다음에서 상속됨 MethodBase)
IsFamily

Family에서 이 메서드나 생성자의 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 해당 클래스 및 파생 클래스에만 표시됩니다.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(다음에서 상속됨 MethodBase)
IsFamilyAndAssembly

FamANDAssem에서 이 메서드나 생성자의 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 같은 어셈블리에 있는 경우에만 파생 클래스에서 호출할 수 있습니다.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

(다음에서 상속됨 MethodBase)
IsFamilyOrAssembly

FamORAssem에서 이 메서드나 생성자의 잠재적 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 파생 클래스(있는 경우) 및 같은 어셈블리의 클래스에서 호출할 수 있습니다.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(다음에서 상속됨 MethodBase)
IsFinal

이 메서드가 final인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this method is final.

(다음에서 상속됨 MethodBase)
IsGenericMethod

메서드가 제네릭 메서드인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is generic.

(다음에서 상속됨 MethodBase)
IsGenericMethodDefinition

메서드가 제네릭 메서드 정의인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is a generic method definition.

(다음에서 상속됨 MethodBase)
IsHideBySig

파생된 클래스에서 동일한 시그니처가 있는 동일한 종류의 멤버만 숨길지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(다음에서 상속됨 MethodBase)
IsPrivate

이 멤버가 프라이빗인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this member is private.

(다음에서 상속됨 MethodBase)
IsPublic

이 메서드가 public 메서드인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this is a public method.

(다음에서 상속됨 MethodBase)
IsSecurityCritical

현재 메서드나 생성자를 현재 신뢰 수준에서 보안에 중요 하거나 보안 안전에 중요 한은 및 이어서 중요 한 작업을 수행할 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

(다음에서 상속됨 MethodBase)
IsSecuritySafeCritical

인지 여부를 나타내는 현재 메서드나 생성자를 보안 안전에 중요 한 현재 신뢰 수준에서 값을 가져옵니다. 즉, 여부 중요 한 작업을 수행할 수 있습니다 하 고 투명 코드로 액세스할 수 있습니다.Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(다음에서 상속됨 MethodBase)
IsSecurityTransparent

현재 신뢰 수준에서, 즉 중요 한 작업을 수행할 수 없습니다 현재 메서드나 생성자에 투명 한지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

(다음에서 상속됨 MethodBase)
IsSpecialName

이 메서드의 이름이 특수 한지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this method has a special name.

(다음에서 상속됨 MethodBase)
IsStatic

메서드가 static인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is static.

(다음에서 상속됨 MethodBase)
IsVirtual

메서드가 virtual인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is virtual.

(다음에서 상속됨 MethodBase)
MemberType

이 멤버가 생성자임을 나타내는 MemberTypes 값을 가져옵니다.Gets a MemberTypes value indicating that this member is a constructor.

(다음에서 상속됨 ConstructorInfo)
MetadataToken

메타데이터 요소를 식별하는 값을 가져옵니다.Gets a value that identifies a metadata element.

(다음에서 상속됨 MemberInfo)
MethodHandle

메서드에 대한 내부 핸들을 가져옵니다.Gets the internal handle for the method. 이 핸들을 사용하여 내부 메타데이터 핸들에 액세스할 수 있습니다.Use this handle to access the underlying metadata handle.

MethodImplementationFlags

메서드 구현의 특성을 지정하는 MethodImplAttributes 플래그를 가져옵니다.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

Module

이 생성자가 정의된 동적 모듈을 가져옵니다.Gets the dynamic module in which this constructor is defined.

Name

이 생성자의 이름을 검색합니다.Retrieves the name of this constructor.

ReflectedType

해당 개체를 얻어온 Type 개체에 대한 참조가 들어 있습니다.Holds a reference to the Type object from which this object was obtained.

ReturnType

null를 가져옵니다.Gets null.

Signature

필드의 서명을 문자열 형태로 가져옵니다.Retrieves the signature of the field in the form of a string.

메서드

AddDeclarativeSecurity(SecurityAction, PermissionSet)

이 생성자에 선언적 보안을 추가합니다.Adds declarative security to this constructor.

DefineParameter(Int32, ParameterAttributes, String)

해당 생성자의 매개 변수를 정의합니다.Defines a parameter of this constructor.

Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether this instance is equal to a specified object.

(다음에서 상속됨 ConstructorInfo)
GetCustomAttributes(Boolean)

이 생성자에 대해 정의된 모든 사용자 지정 특성을 반환합니다.Returns all the custom attributes defined for this constructor.

GetCustomAttributes(Type, Boolean)

지정된 형식으로 식별되는 사용자 지정 특성을 반환합니다.Returns the custom attributes identified by the given type.

GetCustomAttributesData()

대상 멤버에 적용된 특성에 대한 데이터를 나타내는 CustomAttributeData 개체의 목록을 반환합니다.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(다음에서 상속됨 MemberInfo)
GetGenericArguments()

제네릭 메서드의 형식 인수나 제네릭 메서드 정의의 형식 매개 변수를 나타내는 Type 개체의 배열을 반환합니다.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(다음에서 상속됨 MethodBase)
GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.Returns the hash code for this instance.

(다음에서 상속됨 ConstructorInfo)
GetILGenerator()

해당 생성자에 대한 ILGenerator를 가져옵니다.Gets an ILGenerator for this constructor.

GetILGenerator(Int32)

지정된 MSIL 스트림 크기를 사용하여 이 생성자의 메서드 본문을 만드는 데 사용할 수 있는 ILGenerator 개체를 가져옵니다.Gets an ILGenerator object, with the specified MSIL stream size, that can be used to build a method body for this constructor.

GetMethodBody()

파생 클래스에서 재정의된 경우, 현재 메서드의 MSIL 스트림, 지역 변수 및 예외에 액세스할 수 있도록 하는 MethodBody 개체를 가져옵니다.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

(다음에서 상속됨 MethodBase)
GetMethodImplementationFlags()

이 생성자에 대한 메서드 구현 플래그를 반환합니다.Returns the method implementation flags for this constructor.

GetModule()

이 생성자를 포함하는 모듈에 대한 참조를 반환합니다.Returns a reference to the module that contains this constructor.

GetParameters()

이 생성자의 매개 변수를 반환합니다.Returns the parameters of this constructor.

GetToken()

해당 생성자의 토큰을 나타내는 MethodToken을 반환합니다.Returns the MethodToken that represents the token for this constructor.

GetType() (다음에서 상속됨 ConstructorInfo)
HasSameMetadataDefinitionAs(MemberInfo) (다음에서 상속됨 MemberInfo)
Invoke(BindingFlags, Binder, Object[], CultureInfo)

지정된 바인더의 제약 조건에 따라 지정한 매개 변수를 전달하여 지정된 개체에 있는 이 인스턴스로 나타나는 생성자를 동적으로 호출합니다.Dynamically invokes the constructor represented by this instance on the given object, passing along the specified parameters, and under the constraints of the given binder.

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

지정된 Binder의 제약 조건 하에서 지정된 인수를 사용하여 이 인스턴스에 의해 리플렉션된 생성자를 동적으로 호출합니다.Dynamically invokes the constructor reflected by this instance with the specified arguments, under the constraints of the specified Binder.

Invoke(Object, Object[])

지정된 매개 변수를 사용하여 현재 인스턴스로 나타낸 메서드 또는 생성자를 호출합니다.Invokes the method or constructor represented by the current instance, using the specified parameters.

(다음에서 상속됨 MethodBase)
Invoke(Object[])

지정된 매개 변수가 있는 인스턴스에서 리플렉트된 생성자를 호출하고 일반적으로 사용되지 않는 매개 변수에 대해 기본값을 제공합니다.Invokes the constructor reflected by the instance that has the specified parameters, providing default values for the parameters not commonly used.

(다음에서 상속됨 ConstructorInfo)
IsDefined(Type, Boolean)

지정된 사용자 지정 특성 유형이 정의되었는지 확인합니다.Checks if the specified custom attribute type is defined.

MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
SetCustomAttribute(ConstructorInfo, Byte[])

지정된 사용자 지정 특성 blob을 사용하여 사용자 지정 특성을 설정합니다.Set a custom attribute using a specified custom attribute blob.

SetCustomAttribute(CustomAttributeBuilder)

사용자 지정 특성 작성기를 사용하여 사용자 지정 특성을 설정합니다.Set a custom attribute using a custom attribute builder.

SetImplementationFlags(MethodImplAttributes)

이 생성자에 대한 메서드 구현 플래그를 설정합니다.Sets the method implementation flags for this constructor.

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

Microsoft MSIL (intermediate language) 명령의 지정 된 바이트 배열을 사용 하 여 생성자의 본문을 만듭니다.Creates the body of the constructor by using a specified byte array of Microsoft intermediate language (MSIL) instructions.

SetSymCustomAttribute(String, Byte[])

기호 정보에 연결된 해당 생성자의 사용자 지정 특성을 설정합니다.Sets this constructor's custom attribute associated with symbolic information.

ToString()

해당 ConstructorBuilder 인스턴스를 String으로 반환합니다.Returns this ConstructorBuilder instance as a String.

명시적 인터페이스 구현

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

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

_ConstructorBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_ConstructorBuilder.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

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

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

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

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.GetType()

Type 형식을 나타내는 ConstructorInfo 개체를 가져옵니다.Gets a Type object representing the ConstructorInfo type.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.Invoke_2(Object, BindingFlags, Binder, Object[], CultureInfo)

버전에 관계없이 Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) 메서드에 액세스할 수 있는 COM 개체를 제공합니다.Provides COM objects with version-independent access to the Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) method.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.Invoke_3(Object, Object[])

버전에 관계없이 Invoke(Object, Object[]) 메서드에 액세스할 수 있는 COM 개체를 제공합니다.Provides COM objects with version-independent access to the Invoke(Object, Object[]) method.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.Invoke_4(BindingFlags, Binder, Object[], CultureInfo)

버전에 관계없이 Invoke(BindingFlags, Binder, Object[], CultureInfo) 메서드에 액세스할 수 있는 COM 개체를 제공합니다.Provides COM objects with version-independent access to the Invoke(BindingFlags, Binder, Object[], CultureInfo) method.

(다음에서 상속됨 ConstructorInfo)
_ConstructorInfo.Invoke_5(Object[])

버전에 관계없이 Invoke(Object[]) 메서드에 액세스할 수 있는 COM 개체를 제공합니다.Provides COM objects with version-independent access to the Invoke(Object[]) method.

(다음에서 상속됨 ConstructorInfo)
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 MemberInfo)
_MemberInfo.GetType()

Type 클래스를 나타내는 MemberInfo 개체를 가져옵니다.Gets a Type object representing the MemberInfo class.

(다음에서 상속됨 MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(다음에서 상속됨 MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 MethodBase)
_MethodBase.GetType()

이 멤버에 대한 설명은 GetType()를 참조하세요.For a description of this member, see GetType().

(다음에서 상속됨 MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(다음에서 상속됨 MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 MethodBase)
_MethodBase.IsAbstract

이 멤버에 대한 설명은 IsAbstract를 참조하세요.For a description of this member, see IsAbstract.

(다음에서 상속됨 MethodBase)
_MethodBase.IsAssembly

이 멤버에 대한 설명은 IsAssembly를 참조하세요.For a description of this member, see IsAssembly.

(다음에서 상속됨 MethodBase)
_MethodBase.IsConstructor

이 멤버에 대한 설명은 IsConstructor를 참조하세요.For a description of this member, see IsConstructor.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFamily

이 멤버에 대한 설명은 IsFamily를 참조하세요.For a description of this member, see IsFamily.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFamilyAndAssembly

이 멤버에 대한 설명은 IsFamilyAndAssembly를 참조하세요.For a description of this member, see IsFamilyAndAssembly.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFamilyOrAssembly

이 멤버에 대한 설명은 IsFamilyOrAssembly를 참조하세요.For a description of this member, see IsFamilyOrAssembly.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFinal

이 멤버에 대한 설명은 IsFinal를 참조하세요.For a description of this member, see IsFinal.

(다음에서 상속됨 MethodBase)
_MethodBase.IsHideBySig

이 멤버에 대한 설명은 IsHideBySig를 참조하세요.For a description of this member, see IsHideBySig.

(다음에서 상속됨 MethodBase)
_MethodBase.IsPrivate

이 멤버에 대한 설명은 IsPrivate를 참조하세요.For a description of this member, see IsPrivate.

(다음에서 상속됨 MethodBase)
_MethodBase.IsPublic

이 멤버에 대한 설명은 IsPublic를 참조하세요.For a description of this member, see IsPublic.

(다음에서 상속됨 MethodBase)
_MethodBase.IsSpecialName

이 멤버에 대한 설명은 IsSpecialName를 참조하세요.For a description of this member, see IsSpecialName.

(다음에서 상속됨 MethodBase)
_MethodBase.IsStatic

이 멤버에 대한 설명은 IsStatic를 참조하세요.For a description of this member, see IsStatic.

(다음에서 상속됨 MethodBase)
_MethodBase.IsVirtual

이 멤버에 대한 설명은 IsVirtual를 참조하세요.For a description of this member, see IsVirtual.

(다음에서 상속됨 MethodBase)
ICustomAttributeProvider.GetCustomAttributes(Boolean) (다음에서 상속됨 MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (다음에서 상속됨 MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean) (다음에서 상속됨 MemberInfo)

확장 메서드

GetCustomAttribute(MemberInfo, Type)

지정된 된 멤버에 적용 되는 지정 된 형식의 사용자 지정 특성을 검색 합니다.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

지정된 된 멤버에 적용 되는 지정 된 형식의 사용자 지정 특성을 검색 합니다.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

지정된 멤버에 적용된 사용자 지정 특성 컬렉션을 검색합니다.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

지정된 된 멤버에 적용 되는 사용자 지정 특성의 컬렉션을 검색 하 고 필요에 따라 해당 멤버의 상위 항목을 검사 합니다.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성 컬렉션을 검색합니다.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성 컬렉션을 검색합니다.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지 여부를 나타냅니다.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지, 또는 선택적으로 상위 항목에 적용되었는지 여부를 결정합니다.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

사용 가능한 경우 지정된 멤버의 메타데이터 토큰을 가져옵니다.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

지정된 멤버에 대해 메타데이터 토큰을 사용할 수 있는지를 나타내는 값을 반환합니다.Returns a value that indicates whether a metadata token is available for the specified member.

적용 대상