GenericTypeParameterBuilder 클래스

정의

네임스페이스:

System.Reflection.Emit

어셈블리:

System.Reflection.Emit.dll

Source:

GenericTypeParameterBuilder.cs

동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.

public ref class GenericTypeParameterBuilder abstract : System::Reflection::TypeInfo

public abstract class GenericTypeParameterBuilder : System.Reflection.TypeInfo

type GenericTypeParameterBuilder = class
    inherit TypeInfo

Public MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo

상속

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

예제

다음 코드 예제에서는 두 개의 형식 매개 변수를 사용하여 제네릭 형식을 만들고 어셈블리 GenericEmitExample1.dll 저장합니다. Ildasm.exe(IL 디스어셈블러)를 사용하여 생성된 형식을 볼 수 있습니다. 동적 제네릭 형식 정의와 관련된 단계에 대한 자세한 설명은 방법: 리플렉션 내보내기를 사용하여 제네릭 형식 정의를 참조하세요.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Collections::Generic;

// Dummy class to satisfy TFirst constraints.
//
public ref class Example {};

// Define a trivial base class and two trivial interfaces 
// to use when demonstrating constraints.
//
public ref class ExampleBase {};
public interface class IExampleA {};
public interface class IExampleB {};

// Define a trivial type that can substitute for type parameter 
// TSecond.
//
public ref class ExampleDerived : ExampleBase, IExampleA, IExampleB {};

// List the constraint flags. The GenericParameterAttributes
// enumeration contains two sets of attributes, variance and
// constraints. For this example, only constraints are used.
//
static void ListConstraintAttributes( Type^ t )
{
   // Mask off the constraint flags. 
   GenericParameterAttributes constraints = 
       t->GenericParameterAttributes & 
       GenericParameterAttributes::SpecialConstraintMask;

   if ((constraints & GenericParameterAttributes::ReferenceTypeConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    ReferenceTypeConstraint");

   if ((constraints & GenericParameterAttributes::NotNullableValueTypeConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    NotNullableValueTypeConstraint");

   if ((constraints & GenericParameterAttributes::DefaultConstructorConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    DefaultConstructorConstraint");
}

static void DisplayGenericParameters( Type^ t )
{
   if (!t->IsGenericType)
   {
       Console::WriteLine( L"Type '{0}' is not generic." );
       return;
   }
   if (!t->IsGenericTypeDefinition)
       t = t->GetGenericTypeDefinition();

   array<Type^>^ typeParameters = t->GetGenericArguments();
   Console::WriteLine( L"\r\nListing {0} type parameters for type '{1}'.", 
       typeParameters->Length, t );

   for each ( Type^ tParam in typeParameters )
   {
       Console::WriteLine( L"\r\nType parameter {0}:", 
           tParam->ToString() );

       for each (Type^ c in tParam->GetGenericParameterConstraints())
       {
           if (c->IsInterface)
               Console::WriteLine( L"    Interface constraint: {0}", c);
           else
               Console::WriteLine( L"    Base type constraint: {0}", c);
       }
       ListConstraintAttributes(tParam);
   }
}

void main()
{
   // Define a dynamic assembly to contain the sample type. The
   // assembly will be run and also saved to disk, so
   // AssemblyBuilderAccess.RunAndSave is specified.
   //
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ myAsmName = gcnew AssemblyName( L"GenericEmitExample1" );
   AssemblyBuilder^ myAssembly = myDomain->DefineDynamicAssembly( 
       myAsmName, AssemblyBuilderAccess::RunAndSave );

   // An assembly is made up of executable modules. For a single-
   // module assembly, the module name and file name are the same 
   // as the assembly name. 
   //
   ModuleBuilder^ myModule = myAssembly->DefineDynamicModule( 
       myAsmName->Name, String::Concat( myAsmName->Name, L".dll" ) );

   // Get type objects for the base class trivial interfaces to
   // be used as constraints.
   //
   Type^ baseType = ExampleBase::typeid; 
   Type^ interfaceA = IExampleA::typeid; 
   Type^ interfaceB = IExampleB::typeid;
   
   // Define the sample type.
   //
   TypeBuilder^ myType = myModule->DefineType( L"Sample", 
       TypeAttributes::Public );
   
   Console::WriteLine( L"Type 'Sample' is generic: {0}", 
       myType->IsGenericType );
   
   // Define type parameters for the type. Until you do this, 
   // the type is not generic, as the preceding and following 
   // WriteLine statements show. The type parameter names are
   // specified as an array of strings. To make the code
   // easier to read, each GenericTypeParameterBuilder is placed
   // in a variable with the same name as the type parameter.
   // 
   array<String^>^typeParamNames = {L"TFirst",L"TSecond"};
   array<GenericTypeParameterBuilder^>^typeParams = 
       myType->DefineGenericParameters( typeParamNames );

   GenericTypeParameterBuilder^ TFirst = typeParams[0];
   GenericTypeParameterBuilder^ TSecond = typeParams[1];

   Console::WriteLine( L"Type 'Sample' is generic: {0}", 
       myType->IsGenericType );
   
   // Apply constraints to the type parameters.
   //
   // A type that is substituted for the first parameter, TFirst,
   // must be a reference type and must have a parameterless
   // constructor.
   TFirst->SetGenericParameterAttributes( 
       GenericParameterAttributes::DefaultConstructorConstraint | 
       GenericParameterAttributes::ReferenceTypeConstraint 
   );

   // A type that is substituted for the second type
   // parameter must implement IExampleA and IExampleB, and
   // inherit from the trivial test class ExampleBase. The
   // interface constraints are specified as an array
   // containing the interface types. 
   array<Type^>^interfaceTypes = { interfaceA, interfaceB };
   TSecond->SetInterfaceConstraints( interfaceTypes );
   TSecond->SetBaseTypeConstraint( baseType );

   // The following code adds a private field named ExampleField,
   // of type TFirst.
   FieldBuilder^ exField = 
       myType->DefineField("ExampleField", TFirst, 
           FieldAttributes::Private);

   // Define a static method that takes an array of TFirst and 
   // returns a List<TFirst> containing all the elements of 
   // the array. To define this method it is necessary to create
   // the type List<TFirst> by calling MakeGenericType on the
   // generic type definition, generic<T> List. 
   // The parameter type is created by using the
   // MakeArrayType method. 
   //
   Type^ listOf = List::typeid;
   Type^ listOfTFirst = listOf->MakeGenericType(TFirst);
   array<Type^>^ mParamTypes = { TFirst->MakeArrayType() };

   MethodBuilder^ exMethod = 
       myType->DefineMethod("ExampleMethod", 
           MethodAttributes::Public | MethodAttributes::Static, 
           listOfTFirst, 
           mParamTypes);

   // Emit the method body. 
   // The method body consists of just three opcodes, to load 
   // the input array onto the execution stack, to call the 
   // List<TFirst> constructor that takes IEnumerable<TFirst>,
   // which does all the work of putting the input elements into
   // the list, and to return, leaving the list on the stack. The
   // hard work is getting the constructor.
   // 
   // The GetConstructor method is not supported on a 
   // GenericTypeParameterBuilder, so it is not possible to get 
   // the constructor of List<TFirst> directly. There are two
   // steps, first getting the constructor of generic<T> List and then
   // calling a method that converts it to the corresponding 
   // constructor of List<TFirst>.
   //
   // The constructor needed here is the one that takes an
   // IEnumerable<T>. Note, however, that this is not the 
   // generic type definition of generic<T> IEnumerable; instead, the
   // T from generic<T> List must be substituted for the T of 
   // generic<T> IEnumerable. (This seems confusing only because both
   // types have type parameters named T. That is why this example
   // uses the somewhat silly names TFirst and TSecond.) To get
   // the type of the constructor argument, take the generic
   // type definition generic<T> IEnumerable and 
   // call MakeGenericType with the first generic type parameter
   // of generic<T> List. The constructor argument list must be passed
   // as an array, with just one argument in this case.
   // 
   // Now it is possible to get the constructor of generic<T> List,
   // using GetConstructor on the generic type definition. To get
   // the constructor of List<TFirst>, pass List<TFirst> and
   // the constructor from generic<T> List to the static
   // TypeBuilder.GetConstructor method.
   //
   ILGenerator^ ilgen = exMethod->GetILGenerator();
        
   Type^ ienumOf = IEnumerable::typeid;
   Type^ TfromListOf = listOf->GetGenericArguments()[0];
   Type^ ienumOfT = ienumOf->MakeGenericType(TfromListOf);
   array<Type^>^ ctorArgs = {ienumOfT};

   ConstructorInfo^ ctorPrep = listOf->GetConstructor(ctorArgs);
   ConstructorInfo^ ctor = 
       TypeBuilder::GetConstructor(listOfTFirst, ctorPrep);

   ilgen->Emit(OpCodes::Ldarg_0);
   ilgen->Emit(OpCodes::Newobj, ctor);
   ilgen->Emit(OpCodes::Ret);

   // Create the type and save the assembly. 
   Type^ finished = myType->CreateType();
   myAssembly->Save( String::Concat( myAsmName->Name, L".dll" ) );

   // Invoke the method.
   // ExampleMethod is not generic, but the type it belongs to is
   // generic, so in order to get a MethodInfo that can be invoked
   // it is necessary to create a constructed type. The Example 
   // class satisfies the constraints on TFirst, because it is a 
   // reference type and has a default constructor. In order to
   // have a class that satisfies the constraints on TSecond, 
   // this code example defines the ExampleDerived type. These
   // two types are passed to MakeGenericMethod to create the
   // constructed type.
   //
   array<Type^>^ typeArgs = 
       { Example::typeid, ExampleDerived::typeid };
   Type^ constructed = finished->MakeGenericType(typeArgs);
   MethodInfo^ mi = constructed->GetMethod("ExampleMethod");

   // Create an array of Example objects, as input to the generic
   // method. This array must be passed as the only element of an 
   // array of arguments. The first argument of Invoke is 
   // null, because ExampleMethod is static. Display the count
   // on the resulting List<Example>.
   // 
   array<Example^>^ input = { gcnew Example(), gcnew Example() };
   array<Object^>^ arguments = { input };

   List<Example^>^ listX = 
       (List<Example^>^) mi->Invoke(nullptr, arguments);

   Console::WriteLine(
       "\nThere are {0} elements in the List<Example>.", 
       listX->Count);

   DisplayGenericParameters(finished);
}

/* This code example produces the following output:

Type 'Sample' is generic: False
Type 'Sample' is generic: True

There are 2 elements in the List<Example>.

Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

// Define a trivial base class and two trivial interfaces
// to use when demonstrating constraints.
//
public class ExampleBase {}

public interface IExampleA {}

public interface IExampleB {}

// Define a trivial type that can substitute for type parameter
// TSecond.
//
public class ExampleDerived : ExampleBase, IExampleA, IExampleB {}

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
        AssemblyBuilder myAssembly =
            myDomain.DefineDynamicAssembly(myAsmName,
                AssemblyBuilderAccess.RunAndSave);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same
        // as the assembly name.
        //
        ModuleBuilder myModule =
            myAssembly.DefineDynamicModule(myAsmName.Name,
               myAsmName.Name + ".dll");

        // Get type objects for the base class trivial interfaces to
        // be used as constraints.
        //
        Type baseType = typeof(ExampleBase);
        Type interfaceA = typeof(IExampleA);
        Type interfaceB = typeof(IExampleB);

        // Define the sample type.
        //
        TypeBuilder myType =
            myModule.DefineType("Sample", TypeAttributes.Public);

        Console.WriteLine("Type 'Sample' is generic: {0}",
            myType.IsGenericType);

        // Define type parameters for the type. Until you do this,
        // the type is not generic, as the preceding and following
        // WriteLine statements show. The type parameter names are
        // specified as an array of strings. To make the code
        // easier to read, each GenericTypeParameterBuilder is placed
        // in a variable with the same name as the type parameter.
        //
        string[] typeParamNames = {"TFirst", "TSecond"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        GenericTypeParameterBuilder TFirst = typeParams[0];
        GenericTypeParameterBuilder TSecond = typeParams[1];

        Console.WriteLine("Type 'Sample' is generic: {0}",
            myType.IsGenericType);

        // Apply constraints to the type parameters.
        //
        // A type that is substituted for the first parameter, TFirst,
        // must be a reference type and must have a parameterless
        // constructor.
        TFirst.SetGenericParameterAttributes(
            GenericParameterAttributes.DefaultConstructorConstraint |
            GenericParameterAttributes.ReferenceTypeConstraint);

        // A type that is substituted for the second type
        // parameter must implement IExampleA and IExampleB, and
        // inherit from the trivial test class ExampleBase. The
        // interface constraints are specified as an array
        // containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType);
        Type[] interfaceTypes = {interfaceA, interfaceB};
        TSecond.SetInterfaceConstraints(interfaceTypes);

        // The following code adds a private field named ExampleField,
        // of type TFirst.
        FieldBuilder exField =
            myType.DefineField("ExampleField", TFirst,
                FieldAttributes.Private);

        // Define a static method that takes an array of TFirst and
        // returns a List<TFirst> containing all the elements of
        // the array. To define this method it is necessary to create
        // the type List<TFirst> by calling MakeGenericType on the
        // generic type definition, List<T>. (The T is omitted with
        // the typeof operator when you get the generic type
        // definition.) The parameter type is created by using the
        // MakeArrayType method.
        //
        Type listOf = typeof(List<>);
        Type listOfTFirst = listOf.MakeGenericType(TFirst);
        Type[] mParamTypes = {TFirst.MakeArrayType()};

        MethodBuilder exMethod =
            myType.DefineMethod("ExampleMethod",
                MethodAttributes.Public | MethodAttributes.Static,
                listOfTFirst,
                mParamTypes);

        // Emit the method body.
        // The method body consists of just three opcodes, to load
        // the input array onto the execution stack, to call the
        // List<TFirst> constructor that takes IEnumerable<TFirst>,
        // which does all the work of putting the input elements into
        // the list, and to return, leaving the list on the stack. The
        // hard work is getting the constructor.
        //
        // The GetConstructor method is not supported on a
        // GenericTypeParameterBuilder, so it is not possible to get
        // the constructor of List<TFirst> directly. There are two
        // steps, first getting the constructor of List<T> and then
        // calling a method that converts it to the corresponding
        // constructor of List<TFirst>.
        //
        // The constructor needed here is the one that takes an
        // IEnumerable<T>. Note, however, that this is not the
        // generic type definition of IEnumerable<T>; instead, the
        // T from List<T> must be substituted for the T of
        // IEnumerable<T>. (This seems confusing only because both
        // types have type parameters named T. That is why this example
        // uses the somewhat silly names TFirst and TSecond.) To get
        // the type of the constructor argument, take the generic
        // type definition IEnumerable<T> (expressed as
        // IEnumerable<> when you use the typeof operator) and
        // call MakeGenericType with the first generic type parameter
        // of List<T>. The constructor argument list must be passed
        // as an array, with just one argument in this case.
        //
        // Now it is possible to get the constructor of List<T>,
        // using GetConstructor on the generic type definition. To get
        // the constructor of List<TFirst>, pass List<TFirst> and
        // the constructor from List<T> to the static
        // TypeBuilder.GetConstructor method.
        //
        ILGenerator ilgen = exMethod.GetILGenerator();

        Type ienumOf = typeof(IEnumerable<>);
        Type TfromListOf = listOf.GetGenericArguments()[0];
        Type ienumOfT = ienumOf.MakeGenericType(TfromListOf);
        Type[] ctorArgs = {ienumOfT};

        ConstructorInfo ctorPrep = listOf.GetConstructor(ctorArgs);
        ConstructorInfo ctor =
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep);

        ilgen.Emit(OpCodes.Ldarg_0);
        ilgen.Emit(OpCodes.Newobj, ctor);
        ilgen.Emit(OpCodes.Ret);

        // Create the type and save the assembly.
        Type finished = myType.CreateType();
        myAssembly.Save(myAsmName.Name+".dll");

        // Invoke the method.
        // ExampleMethod is not generic, but the type it belongs to is
        // generic, so in order to get a MethodInfo that can be invoked
        // it is necessary to create a constructed type. The Example
        // class satisfies the constraints on TFirst, because it is a
        // reference type and has a default constructor. In order to
        // have a class that satisfies the constraints on TSecond,
        // this code example defines the ExampleDerived type. These
        // two types are passed to MakeGenericMethod to create the
        // constructed type.
        //
        Type[] typeArgs = {typeof(Example), typeof(ExampleDerived)};
        Type constructed = finished.MakeGenericType(typeArgs);
        MethodInfo mi = constructed.GetMethod("ExampleMethod");

        // Create an array of Example objects, as input to the generic
        // method. This array must be passed as the only element of an
        // array of arguments. The first argument of Invoke is
        // null, because ExampleMethod is static. Display the count
        // on the resulting List<Example>.
        //
        Example[] input = {new Example(), new Example()};
        object[] arguments = {input};

        List<Example> listX =
            (List<Example>) mi.Invoke(null, arguments);

        Console.WriteLine(
            "\nThere are {0} elements in the List<Example>.",
            listX.Count);

        DisplayGenericParameters(finished);
    }

    private static void DisplayGenericParameters(Type t)
    {
        if (!t.IsGenericType)
        {
            Console.WriteLine("Type '{0}' is not generic.");
            return;
        }
        if (!t.IsGenericTypeDefinition)
        {
            t = t.GetGenericTypeDefinition();
        }

        Type[] typeParameters = t.GetGenericArguments();
        Console.WriteLine("\nListing {0} type parameters for type '{1}'.",
            typeParameters.Length, t);

        foreach( Type tParam in typeParameters )
        {
            Console.WriteLine("\r\nType parameter {0}:", tParam.ToString());

            foreach( Type c in tParam.GetGenericParameterConstraints() )
            {
                if (c.IsInterface)
                {
                    Console.WriteLine("    Interface constraint: {0}", c);
                }
                else
                {
                    Console.WriteLine("    Base type constraint: {0}", c);
                }
            }

            ListConstraintAttributes(tParam);
        }
    }

    // List the constraint flags. The GenericParameterAttributes
    // enumeration contains two sets of attributes, variance and
    // constraints. For this example, only constraints are used.
    //
    private static void ListConstraintAttributes(Type t)
    {
        // Mask off the constraint flags.
        GenericParameterAttributes constraints =
            t.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;

        if ((constraints & GenericParameterAttributes.ReferenceTypeConstraint)
            != GenericParameterAttributes.None)
        {
            Console.WriteLine("    ReferenceTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.NotNullableValueTypeConstraint)
            != GenericParameterAttributes.None)
        {
            Console.WriteLine("    NotNullableValueTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.DefaultConstructorConstraint)
            !=GenericParameterAttributes.None)
        {
            Console.WriteLine("    DefaultConstructorConstraint");
        }
    }
}

/* This code example produces the following output:

Type 'Sample' is generic: False
Type 'Sample' is generic: True

There are 2 elements in the List<Example>.

Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Collections.Generic

' Define a trivial base class and two trivial interfaces 
' to use when demonstrating constraints.
'
Public Class ExampleBase
End Class

Public Interface IExampleA
End Interface

Public Interface IExampleB
End Interface

' Define a trivial type that can substitute for type parameter 
' TSecond.
'
Public Class ExampleDerived
    Inherits ExampleBase
    Implements IExampleA, IExampleB
End Class

Public Class Example
    Public Shared Sub Main()
        ' Define a dynamic assembly to contain the sample type. The
        ' assembly will not be run, but only saved to disk, so
        ' AssemblyBuilderAccess.Save is specified.
        '
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("GenericEmitExample1")
        Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
            myAsmName, _
            AssemblyBuilderAccess.RunAndSave)

        ' An assembly is made up of executable modules. For a single-
        ' module assembly, the module name and file name are the same 
        ' as the assembly name. 
        '
        Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule( _
            myAsmName.Name, _
            myAsmName.Name & ".dll")

        ' Get type objects for the base class trivial interfaces to
        ' be used as constraints.
        '
        Dim baseType As Type = GetType(ExampleBase)
        Dim interfaceA As Type = GetType(IExampleA)
        Dim interfaceB As Type = GetType(IExampleB)
                
        ' Define the sample type.
        '
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Public)

        Console.WriteLine("Type 'Sample' is generic: {0}", _
            myType.IsGenericType)

        ' Define type parameters for the type. Until you do this, 
        ' the type is not generic, as the preceding and following 
        ' WriteLine statements show. The type parameter names are
        ' specified as an array of strings. To make the code
        ' easier to read, each GenericTypeParameterBuilder is placed
        ' in a variable with the same name as the type parameter.
        ' 
        Dim typeParamNames() As String = {"TFirst", "TSecond"}
        Dim typeParams() As GenericTypeParameterBuilder = _
            myType.DefineGenericParameters(typeParamNames)

        Dim TFirst As GenericTypeParameterBuilder = typeParams(0)
        Dim TSecond As GenericTypeParameterBuilder = typeParams(1)

        Console.WriteLine("Type 'Sample' is generic: {0}", _
            myType.IsGenericType)

        ' Apply constraints to the type parameters.
        '
        ' A type that is substituted for the first parameter, TFirst,
        ' must be a reference type and must have a parameterless
        ' constructor.
        TFirst.SetGenericParameterAttributes( _
            GenericParameterAttributes.DefaultConstructorConstraint _
            Or GenericParameterAttributes.ReferenceTypeConstraint)

        ' A type that is substituted for the second type
        ' parameter must implement IExampleA and IExampleB, and
        ' inherit from the trivial test class ExampleBase. The
        ' interface constraints are specified as an array 
        ' containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType)
        Dim interfaceTypes() As Type = {interfaceA, interfaceB}
        TSecond.SetInterfaceConstraints(interfaceTypes)

        ' The following code adds a private field named ExampleField,
        ' of type TFirst.
        Dim exField As FieldBuilder = _
            myType.DefineField("ExampleField", TFirst, _
                FieldAttributes.Private)

        ' Define a Shared method that takes an array of TFirst and 
        ' returns a List(Of TFirst) containing all the elements of 
        ' the array. To define this method it is necessary to create
        ' the type List(Of TFirst) by calling MakeGenericType on the
        ' generic type definition, List(Of T). (The T is omitted with
        ' the GetType operator when you get the generic type 
        ' definition.) The parameter type is created by using the
        ' MakeArrayType method. 
        '
        Dim listOf As Type = GetType(List(Of ))
        Dim listOfTFirst As Type = listOf.MakeGenericType(TFirst)
        Dim mParamTypes() As Type = { TFirst.MakeArrayType() }

        Dim exMethod As MethodBuilder = _
            myType.DefineMethod("ExampleMethod", _
                MethodAttributes.Public Or MethodAttributes.Static, _
                listOfTFirst, _
                mParamTypes)

        ' Emit the method body. 
        ' The method body consists of just three opcodes, to load 
        ' the input array onto the execution stack, to call the 
        ' List(Of TFirst) constructor that takes IEnumerable(Of TFirst),
        ' which does all the work of putting the input elements into
        ' the list, and to return, leaving the list on the stack. The
        ' hard work is getting the constructor.
        ' 
        ' The GetConstructor method is not supported on a 
        ' GenericTypeParameterBuilder, so it is not possible to get 
        ' the constructor of List(Of TFirst) directly. There are two
        ' steps, first getting the constructor of List(Of T) and then
        ' calling a method that converts it to the corresponding 
        ' constructor of List(Of TFirst).
        '
        ' The constructor needed here is the one that takes an
        ' IEnumerable(Of T). Note, however, that this is not the 
        ' generic type definition of IEnumerable(Of T); instead, the
        ' T from List(Of T) must be substituted for the T of 
        ' IEnumerable(Of T). (This seems confusing only because both
        ' types have type parameters named T. That is why this example
        ' uses the somewhat silly names TFirst and TSecond.) To get
        ' the type of the constructor argument, take the generic
        ' type definition IEnumerable(Of T) (expressed as 
        ' IEnumerable(Of ) when you use the GetType operator) and 
        ' call MakeGenericType with the first generic type parameter
        ' of List(Of T). The constructor argument list must be passed
        ' as an array, with just one argument in this case.
        ' 
        ' Now it is possible to get the constructor of List(Of T),
        ' using GetConstructor on the generic type definition. To get
        ' the constructor of List(Of TFirst), pass List(Of TFirst) and
        ' the constructor from List(Of T) to the static
        ' TypeBuilder.GetConstructor method.
        '
        Dim ilgen As ILGenerator = exMethod.GetILGenerator()
        
        Dim ienumOf As Type = GetType(IEnumerable(Of ))
        Dim listOfTParams() As Type = listOf.GetGenericArguments()
        Dim TfromListOf As Type = listOfTParams(0)
        Dim ienumOfT As Type = ienumOf.MakeGenericType(TfromListOf)
        Dim ctorArgs() As Type = { ienumOfT }

        Dim ctorPrep As ConstructorInfo = _
            listOf.GetConstructor(ctorArgs)
        Dim ctor As ConstructorInfo = _
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep)

        ilgen.Emit(OpCodes.Ldarg_0)
        ilgen.Emit(OpCodes.Newobj, ctor)
        ilgen.Emit(OpCodes.Ret)

        ' Create the type and save the assembly. 
        Dim finished As Type = myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

        ' Invoke the method.
        ' ExampleMethod is not generic, but the type it belongs to is
        ' generic, so in order to get a MethodInfo that can be invoked
        ' it is necessary to create a constructed type. The Example 
        ' class satisfies the constraints on TFirst, because it is a 
        ' reference type and has a default constructor. In order to
        ' have a class that satisfies the constraints on TSecond, 
        ' this code example defines the ExampleDerived type. These
        ' two types are passed to MakeGenericMethod to create the
        ' constructed type.
        '
        Dim typeArgs() As Type = _
            { GetType(Example), GetType(ExampleDerived) }
        Dim constructed As Type = finished.MakeGenericType(typeArgs)
        Dim mi As MethodInfo = constructed.GetMethod("ExampleMethod")

        ' Create an array of Example objects, as input to the generic
        ' method. This array must be passed as the only element of an 
        ' array of arguments. The first argument of Invoke is 
        ' Nothing, because ExampleMethod is Shared. Display the count
        ' on the resulting List(Of Example).
        ' 
        Dim input() As Example = { New Example(), New Example() }
        Dim arguments() As Object = { input }

        Dim listX As List(Of Example) = mi.Invoke(Nothing, arguments)

        Console.WriteLine(vbLf & _
            "There are {0} elements in the List(Of Example).", _
            listX.Count _ 
        )

        DisplayGenericParameters(finished)
    End Sub

    Private Shared Sub DisplayGenericParameters(ByVal t As Type)

        If Not t.IsGenericType Then
            Console.WriteLine("Type '{0}' is not generic.")
            Return
        End If
        If Not t.IsGenericTypeDefinition Then _
            t = t.GetGenericTypeDefinition()

        Dim typeParameters() As Type = t.GetGenericArguments()
        Console.WriteLine(vbCrLf & _
            "Listing {0} type parameters for type '{1}'.", _
            typeParameters.Length, t)

        For Each tParam As Type In typeParameters

            Console.WriteLine(vbCrLf & "Type parameter {0}:", _
                tParam.ToString())

            For Each c As Type In tParam.GetGenericParameterConstraints()
                If c.IsInterface Then
                    Console.WriteLine("    Interface constraint: {0}", c)
                Else
                    Console.WriteLine("    Base type constraint: {0}", c)
                End If
            Next 

            ListConstraintAttributes(tParam)
        Next tParam
    End Sub

    ' List the constraint flags. The GenericParameterAttributes
    ' enumeration contains two sets of attributes, variance and
    ' constraints. For this example, only constraints are used.
    '
    Private Shared Sub ListConstraintAttributes(ByVal t As Type)

        ' Mask off the constraint flags. 
        Dim constraints As GenericParameterAttributes = _
            t.GenericParameterAttributes And _
            GenericParameterAttributes.SpecialConstraintMask

        If (constraints And GenericParameterAttributes.ReferenceTypeConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    ReferenceTypeConstraint")

        If (constraints And GenericParameterAttributes.NotNullableValueTypeConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    NotNullableValueTypeConstraint")

        If (constraints And GenericParameterAttributes.DefaultConstructorConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    DefaultConstructorConstraint")

    End Sub 

End Class

' This code example produces the following output:
'
'Type 'Sample' is generic: False
'Type 'Sample' is generic: True
'
'There are 2 elements in the List(Of Example).
'
'Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.
'
'Type parameter TFirst:
'    ReferenceTypeConstraint
'    DefaultConstructorConstraint
'
'Type parameter TSecond:
'    Interface constraint: IExampleA
'    Interface constraint: IExampleB
'    Base type constraint: ExampleBase

설명

메서드를 사용하여 TypeBuilder.DefineGenericParameters 형식 매개 변수를 동적 형식에 추가하여 제네릭 형식으로 만들거나 메서드를 사용하여 MethodBuilder.DefineGenericParameters 형식 매개 변수를 동적 메서드에 추가하여 개체 배열 GenericTypeParameterBuilder 을 가져올 수 있습니다. 개체를 GenericTypeParameterBuilder 사용하여 형식 매개 변수에 제약 조건을 추가합니다. 제약 조건은 세 가지 종류입니다.

• 기본 형식 제약 조건은 제네릭 형식 매개 변수에 할당된 모든 형식이 특정 기본 형식에서 파생되도록 지정합니다. 메서드를 사용하여 이 제약 조건을 SetBaseTypeConstraint 설정합니다.

• 인터페이스 제약 조건은 제네릭 형식 매개 변수에 할당된 모든 형식이 특정 인터페이스를 구현하도록 지정합니다. 메서드를 사용하여 SetInterfaceConstraints 인터페이스 제약 조건을 설정합니다.

• 특수 제약 조건은 제네릭 형식 매개 변수에 할당된 모든 형식에 매개 변수가 없는 생성자가 있거나, 참조 형식이어야 하거나, 값 형식이어야 한다고 지정합니다. 메서드를 사용하여 SetGenericParameterAttributes 형식 매개 변수에 대한 특수 제약 조건을 설정합니다.

클래스의 GenericTypeParameterBuilder 메서드를 사용하여 인터페이스 제약 조건 및 특수 제약 조건을 검색할 수 없습니다. 형식 매개 변수를 포함하는 제네릭 형식을 만든 후에는 해당 개체를 Type 사용하여 제약 조건을 반영할 수 있습니다. 메서드를 Type.GetGenericArguments 사용하여 형식 매개 변수를 가져오고 각 형식 매개 변수에 대해 메서드를 사용하여 기본 형식 제약 조건 및 인터페이스 제약 조건을 가져오고 Type.GenericParameterAttributes 속성을 사용하여 Type.GetGenericParameterConstraints 특수 제약 조건을 가져옵니다.

생성자

GenericTypeParameterBuilder()

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

속성

Assembly	현재 형식 매개 변수가 속하는 제네릭 형식 정의를 포함하는 동적 어셈블리를 나타내는 Assembly 개체를 가져옵니다.
AssemblyQualifiedName	모든 경우에 null을 가져옵니다.
Attributes	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
BaseType	현재 제네릭 형식 매개 변수의 기본 형식 제약 조건을 가져옵니다.
ContainsGenericParameters	모든 경우에 true을 가져옵니다.
CustomAttributes	이 멤버의 사용자 지정 특성을 포함하는 컬렉션을 가져옵니다. (다음에서 상속됨 MemberInfo)
DeclaredConstructors	현재 형식이 선언하는 생성자의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaredEvents	현재 형식이 정의하는 이벤트의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaredFields	현재 형식이 정의하는 필드의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaredMembers	현재 형식이 정의하는 멤버의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaredMethods	현재 형식이 정의하는 메서드의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaredNestedTypes	현재 형식이 정의하는 중첩 형식의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaredProperties	현재 형식이 정의하는 속성의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
DeclaringMethod	현재 MethodInfo가 제네릭 메서드의 형식 매개 변수를 나타내는 경우 선언 메서드를 나타내는 GenericTypeParameterBuilder를 가져옵니다.
DeclaringType	제네릭 형식 매개 변수가 속하는 제네릭 형식 정의 또는 제네릭 메서드 정의를 가져옵니다.
FullName	모든 경우에 null을 가져옵니다.
GenericParameterAttributes	현재 제네릭 형식 매개 변수의 공 분산과 특수 제약 조건을 설명하는 GenericParameterAttributes 플래그의 조합을 가져옵니다.
GenericParameterPosition	형식 매개 변수가 선언된 제네릭 형식 또는 메서드의 형식 매개 변수 목록에서 해당 형식 매개 변수가 있는 위치를 가져옵니다.
GenericTypeArguments	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GenericTypeParameters	현재 인스턴스의 제네릭 형식 매개 변수 배열을 가져옵니다. (다음에서 상속됨 TypeInfo)
GUID	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
HasElementType	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
ImplementedInterfaces	현재 형식에 의해 구현된 인터페이스의 컬렉션을 가져옵니다. (다음에서 상속됨 TypeInfo)
IsAbstract	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsAnsiClass	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsArray	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsAutoClass	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsAutoLayout	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsByRef	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsByRefLike	형식이 byref와 유사한 구조체인지 여부를 나타내는 값을 가져옵니다.
IsClass	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsCollectible	이 MemberInfo 개체가 수집 가능한 AssemblyLoadContext에 보관된 어셈블리의 일부인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 MemberInfo)
IsCOMObject	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsConstructedGenericType	이 개체가 생성된 제네릭 형식을 나타내는지를 지정하는 값을 가져옵니다.
IsContextful	Type이 컨텍스트에서 호스팅될 수 있는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsEnum	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsExplicitLayout	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsFunctionPointer	현재 Type 가 함수 포인터인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsGenericMethodParameter	현재 Type이 제네릭 메서드 정의의 형식 매개 변수를 나타내는지를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsGenericParameter	모든 경우에 true을 가져옵니다.
IsGenericType	모든 경우에 false 를 반환합니다.
IsGenericTypeDefinition	모든 경우에 false을 가져옵니다.
IsGenericTypeParameter	현재 Type이 제네릭 형식 정의의 형식 매개 변수를 나타내는지를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsImport	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsInterface	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsLayoutSequential	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsMarshalByRef	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNested	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNestedAssembly	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNestedFamANDAssem	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNestedFamily	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNestedFamORAssem	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNestedPrivate	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNestedPublic	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsNotPublic	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsPointer	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsPrimitive	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsPublic	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsSealed	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsSecurityCritical	현재 형식이 현재 신뢰 수준에서 보안에 중요한 형식이거나 보안 안전에 중요한 형식이어서 중요한 작업을 수행할 수 있는지를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsSecuritySafeCritical	현재 형식이 현재 신뢰 수준에서 보안 안전에 중요한 형식인지 즉, 중요한 작업을 수행할 수 있고 투명 코드로 액세스할 수 있는지를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsSecurityTransparent	현재 형식이 현재 신뢰 수준에서 투명하여 중요한 작업을 수행할 수 없는지를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsSerializable	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsSignatureType	형식이 시그니처 형식인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsSpecialName	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsSZArray	형식이 하한이 0인 1차원 배열만 나타낼 수 있는 배열 형식인지 여부를 나타내는 값을 가져옵니다.
IsTypeDefinition	형식이 형식 정의인지 여부를 나타내는 값을 가져옵니다.
IsUnicodeClass	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsUnmanagedFunctionPointer	현재 Type 가 관리되지 않는 함수 포인터인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsValueType	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsVariableBoundArray	형식이 하한이 임의적인 배열 또는 다차원 배열만 나타낼 수 있는 배열 형식인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Type)
IsVisible	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
MemberType	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
MetadataToken	메타데이터에서 현재 동적 모듈을 식별하는 토큰을 가져옵니다.
Module	제네릭 형식 매개 변수가 들어 있는 동적 모듈을 가져옵니다.
Name	제네릭 형식 매개 변수의 이름을 가져옵니다.
Namespace	모든 경우에 null을 가져옵니다.
ReflectedType	Type 를 얻는 데 사용된 GenericTypeParameterBuilder개체를 가져옵니다.
StructLayoutAttribute	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
TypeHandle	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
TypeInitializer	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
UnderlyingSystemType	현재 제네릭 형식 매개 변수를 가져옵니다.

메서드

AsType()	현재 형식을 Type 개체로 반환합니다. (다음에서 상속됨 TypeInfo)
Equals(Object)	지정된 개체가 EventToken 의 인스턴스이고 현재 인스턴스와 같은지 여부를 테스트합니다.
Equals(Type)	현재 Type의 내부 시스템 형식이 지정된 Type의 내부 시스템 형식과 동일한지 확인합니다. (다음에서 상속됨 Type)
FindInterfaces(TypeFilter, Object)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetArrayRank()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetAttributeFlagsImpl()	파생 클래스에서 재정의되면 Attributes 속성을 구현하고 Type과 연관된 특성을 나타내는 열거형 값의 비트 조합을 가져옵니다.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	지정된 바인딩 제약 조건 및 호출 규칙을 사용하여, 지정된 인수 형식 및 한정자와 매개 변수가 일치하는 생성자를 검색합니다. (다음에서 상속됨 Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	지정된 인수 형식 및 한정자와 일치하는 매개 변수를 가진 생성자를 지정된 바인딩 제약 조건으로 검색합니다. (다음에서 상속됨 Type)
GetConstructor(BindingFlags, Type[])	지정된 바인딩 제약 조건을 사용하여 매개 변수가 지정된 인수 형식과 일치하는 생성자를 검색합니다. (다음에서 상속됨 Type)
GetConstructor(Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetConstructors()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetConstructors(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetCustomAttributes(Boolean)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetCustomAttributes(Type, Boolean)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetCustomAttributesData()	대상 멤버에 적용된 특성에 대한 데이터를 나타내는 CustomAttributeData 개체의 목록을 반환합니다. (다음에서 상속됨 MemberInfo)
GetDeclaredEvent(String)	현재 형식으로 선언된 지정된 이벤트를 나타내는 개체를 반환합니다. (다음에서 상속됨 TypeInfo)
GetDeclaredField(String)	현재 형식으로 선언된 지정된 필드를 나타내는 개체를 반환합니다. (다음에서 상속됨 TypeInfo)
GetDeclaredMethod(String)	현재 형식으로 선언된 지정된 메서드를 나타내는 개체를 반환합니다. (다음에서 상속됨 TypeInfo)
GetDeclaredMethods(String)	지정된 이름과 일치하는 현재 형식에 선언된 모든 메서드가 포함된 컬렉션을 반환합니다. (다음에서 상속됨 TypeInfo)
GetDeclaredNestedType(String)	현재 형식으로 선언된 지정된 중첩 형식을 나타내는 개체를 반환합니다. (다음에서 상속됨 TypeInfo)
GetDeclaredProperty(String)	현재 형식으로 선언된 지정된 속성을 나타내는 개체를 반환합니다. (다음에서 상속됨 TypeInfo)
GetDefaultMembers()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetElementType()	모든 경우에 NotSupportedException을(를) throw합니다.
GetEnumName(Object)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetEnumNames()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetEnumUnderlyingType()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetEnumValues()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetEnumValuesAsUnderlyingType()	이 열거형 형식의 기본 형식 상수 값 배열을 검색합니다. (다음에서 상속됨 Type)
GetEvent(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetEvent(String, BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetEvents()	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetEvents(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetField(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetField(String, BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetFields()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetFields(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetFunctionPointerCallingConventions()	파생 클래스에서 재정의되는 경우 현재 함수 포인터 Type의 호출 규칙을 반환합니다. (다음에서 상속됨 Type)
GetFunctionPointerParameterTypes()	파생 클래스에서 재정의되는 경우 현재 함수 포인터 Type의 매개 변수 형식을 반환합니다. (다음에서 상속됨 Type)
GetFunctionPointerReturnType()	파생 클래스에서 재정의된 경우 현재 함수 포인터 Type의 반환 형식을 반환합니다. (다음에서 상속됨 Type)
GetGenericArguments()	제네릭 형식 매개 변수에는 유효하지 않습니다.
GetGenericParameterConstraints()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetGenericTypeDefinition()	제네릭 형식 매개 변수에는 유효하지 않습니다.
GetHashCode()	현재 인스턴스에 대한 32비트 정수 해시 코드를 반환합니다.
GetInterface(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetInterface(String, Boolean)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetInterfaceMap(Type)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetInterfaces()	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetMember(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMember(String, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetMembers()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMembers(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	지정된 MemberInfo에 MemberInfo 일치하는 현재 Type 에서 를 검색합니다. (다음에서 상속됨 Type)
GetMethod(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMethod(String, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	지정된 인수 형식 및 한정자와 일치하는 매개 변수를 가진 지정된 메서드를 지정된 바인딩 제약 조건과 지정된 호출 규칙으로 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	지정된 인수 형식 및 한정자와 일치하는 매개 변수를 가진 지정된 메서드를 지정된 바인딩 제약 조건으로 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, BindingFlags, Type[])	지정된 바인딩 제약 조건을 사용하여 매개 변수가 지정된 인수 형식과 일치하는 지정된 메서드를 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	지정된 바인딩 제약 조건과 지정된 호출 규칙을 활용하여, 지정된 제네릭 매개 변수의 수, 인수 형식 및 한정자와 매개 변수가 일치하는 지정된 메서드를 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	지정된 바인딩 제약 조건을 사용하여, 지정된 제네릭 매개 변수의 수, 인수 형식 및 한정자와 매개 변수가 일치하는 지정된 메서드를 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, Int32, BindingFlags, Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 Type)
GetMethod(String, Int32, Type[])	지정된 제네릭 매개 변수의 수 및 인수 형식과 매개 변수가 일치하는 지정된 공용 메서드를 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	지정된 매개 변수의 수, 인수 형식 및 한정자와 매개 변수가 일치하는 지정된 공용 메서드를 검색합니다. (다음에서 상속됨 Type)
GetMethod(String, Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	파생 클래스에서 재정의되면 지정된 바인딩 제약 조건 및 호출 규칙을 활용하여, 매개 변수가 지정된 제네릭 매개 변수의 수, 인수 형식 및 한정자와 일치하는 지정된 메서드를 검색합니다. (다음에서 상속됨 Type)
GetMethods()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetMethods(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetNestedType(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetNestedType(String, BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetNestedTypes()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetNestedTypes(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetOptionalCustomModifiers()	파생 클래스에서 재정의되는 경우 현재 Type의 선택적 사용자 지정 한정자를 반환합니다. (다음에서 상속됨 Type)
GetProperties()	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetProperties(BindingFlags)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetProperty(String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetProperty(String, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	지정된 인수 형식 및 한정자와 일치하는 매개 변수를 가진 지정된 속성을 지정된 바인딩 제약 조건으로 검색합니다. (다음에서 상속됨 Type)
GetProperty(String, Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetProperty(String, Type, Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetProperty(String, Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
GetRequiredCustomModifiers()	파생 클래스에서 재정의된 경우 현재 Type의 필수 사용자 지정 한정자를 반환합니다. (다음에서 상속됨 Type)
GetType()	현재 Type를 가져옵니다. (다음에서 상속됨 Type)
GetTypeCodeImpl()	이 Type 인스턴스에 대한 내부 형식 코드를 반환합니다. (다음에서 상속됨 Type)
HasElementTypeImpl()	파생 클래스에서 재정의되면, HasElementType 속성을 구현하고 현재 Type이 다른 형식을 포함하거나 참조하는지 여부, 즉 현재 Type이 배열 또는 포인터이거나 참조로 전달되는지를 확인합니다.
HasSameMetadataDefinitionAs(MemberInfo)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	지정된 바인딩 제약 조건과 인수 목록을 사용하여 지정된 멤버를 호출합니다. (다음에서 상속됨 Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	지정된 바인딩 제약 조건과 지정된 인수 목록 및 문화권을 사용하여 지정된 멤버를 호출합니다. (다음에서 상속됨 Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
IsArrayImpl()	파생 클래스에서 재정의되면, IsArray 속성을 구현하고 Type이 배열인지를 확인합니다.
IsAssignableFrom(Type)	모든 경우에 NotSupportedException 예외를 throw합니다.
IsAssignableFrom(TypeInfo)	모든 경우에 NotSupportedException 예외를 throw합니다.
IsAssignableTo(Type)	지정된 targetType의 변수에 현재 형식을 할당할 수 있는지 여부를 결정합니다. (다음에서 상속됨 Type)
IsByRefImpl()	파생 클래스에서 재정의되면, IsByRef 속성을 구현하고 Type이 참조로 전달되는지를 확인합니다.
IsCOMObjectImpl()	파생 클래스에서 재정의되면, IsCOMObject 속성을 구현하고 Type이 COM 개체인지를 확인합니다.
IsContextfulImpl()	IsContextful 속성을 구현하고, Type이 컨텍스트에서 호스팅될 수 있는지 여부를 확인합니다. (다음에서 상속됨 Type)
IsDefined(Type, Boolean)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
IsEnumDefined(Object)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsEquivalentTo(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsInstanceOfType(Object)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다. (다음에서 상속됨 TypeInfo)
IsMarshalByRefImpl()	IsMarshalByRef 속성을 구현하고, Type이 참조에 의해 마샬링되는지 여부를 확인합니다. (다음에서 상속됨 Type)
IsPointerImpl()	파생 클래스에서 재정의되면, IsPointer 속성을 구현하고 Type이 포인터인지를 확인합니다.
IsPrimitiveImpl()	파생 클래스에서 재정의되면, IsPrimitive 속성을 구현하고 Type이 기본 형식 중 하나인지를 확인합니다.
IsSubclassOf(Type)	불완전한 제네릭 형식 매개 변수에 대해 지원되지 않습니다.
IsValueTypeImpl()	IsValueType 속성을 구현하고 Type이 값 형식인지 여부, 즉 클래스 또는 인터페이스가 아닌지 여부를 확인합니다.
MakeArrayType()	요소 형식이 제네릭 형식 매개 변수인 1차원 배열의 형식을 반환합니다.
MakeArrayType(Int32)	지정된 차원 수를 가지며 요소 형식이 제네릭 형식 매개 변수인 배열의 형식을 반환합니다.
MakeByRefType()	참조 매개 변수로 전달될 때 현재 제네릭 형식 매개 변수를 나타내는 Type 개체를 반환합니다.
MakeGenericType(Type[])	불완전한 제네릭 형식 매개 변수에 대해 유효하지 않습니다.
MakePointerType()	현재 제네릭 형식 매개 변수에 대한 포인터를 나타내는 Type 개체를 반환합니다.
MemberwiseClone()	현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object)
SetBaseTypeConstraint(Type)	형식이 형식 매개 변수를 대체하기 위해 상속해야 하는 기본 형식을 설정합니다.
SetBaseTypeConstraintCore(Type)	파생 클래스에서 재정의되는 경우 형식 매개 변수로 대체하기 위해 형식이 상속해야 하는 기본 형식을 설정합니다.
SetCustomAttribute(ConstructorInfo, Byte[])	지정된 사용자 지정 특성 blob을 사용하여 사용자 지정 특성을 설정합니다.
SetCustomAttribute(CustomAttributeBuilder)	사용자 지정 특성 작성기를 사용하여 사용자 지정 특성을 설정합니다.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	파생 클래스에서 재정의되는 경우 이 어셈블리에서 사용자 지정 특성을 설정합니다.
SetGenericParameterAttributes(GenericParameterAttributes)	제네릭 매개 변수의 가변성 특성과 특수 제약 조건(예: 매개 변수가 없는 생성자 제약 조건)을 설정합니다.
SetGenericParameterAttributesCore(GenericParameterAttributes)	파생 클래스에서 재정의되는 경우 매개 변수가 없는 생성자 제약 조건과 같은 제네릭 매개 변수의 분산 특성 및 특수 제약 조건을 설정합니다.
SetInterfaceConstraints(Type[])	형식이 형식 매개 변수를 대체하기 위해 구현해야 하는 인터페이스를 설정합니다.
SetInterfaceConstraintsCore(Type[])	파생 클래스에서 재정의되는 경우 형식 매개 변수로 대체하기 위해 형식이 구현해야 하는 인터페이스를 설정합니다.
ToString()	현재 제네릭 형식 매개 변수의 문자열 표현을 반환합니다.

명시적 인터페이스 구현

IReflectableType.GetTypeInfo()

현재 형식의 표현을 TypeInfo 개체로 반환합니다. (다음에서 상속됨 TypeInfo)

확장 메서드

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)	지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지, 또는 선택적으로 상위 항목에 적용되었는지 여부를 결정합니다.
GetTypeInfo(Type)	지정된 형식의 TypeInfo 표현을 반환합니다.
GetMetadataToken(MemberInfo)	사용 가능한 경우 지정된 멤버의 메타데이터 토큰을 가져옵니다.
HasMetadataToken(MemberInfo)	지정된 멤버에 대해 메타데이터 토큰을 사용할 수 있는지를 나타내는 값을 반환합니다.
GetRuntimeEvent(Type, String)	지정된 이벤트를 나타내는 개체를 검색합니다.
GetRuntimeEvents(Type)	지정된 형식에서 정의된 모든 메소드를 나타내는 컬렉션을 검색합니다.
GetRuntimeField(Type, String)	지정된 필드를 나타내는 개체를 검색합니다.
GetRuntimeFields(Type)	지정된 형식에서 정의된 모든 메소드를 나타내는 컬렉션을 검색합니다.
GetRuntimeInterfaceMap(TypeInfo, Type)	지정된 형식과 지정된 인터페이스에 대한 인터페이스 매핑을 반환합니다.
GetRuntimeMethod(Type, String, Type[])	지정된 메서드를 나타내는 개체를 검색합니다.
GetRuntimeMethods(Type)	지정된 형식에 정의된 모든 메소드를 나타내는 컬렉션을 검색합니다.
GetRuntimeProperties(Type)	지정된 형식에서 정의된 모든 속성을 나타내는 컬렉션을 검색합니다.
GetRuntimeProperty(Type, String)	지정된 속성을 나타내는 개체를 검색합니다.
GetConstructor(Type, Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetConstructors(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetConstructors(Type, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetFields(Type, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetGenericArguments(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetInterfaces(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetMember(Type, String)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetMember(Type, String, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetMembers(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetMethods(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetNestedType(Type, String, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetProperties(Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetProperties(Type, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetProperty(Type, String, BindingFlags)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetProperty(Type, String, Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
GetProperty(Type, String, Type, Type[])	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
IsAssignableFrom(Type, Type)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.
IsInstanceOfType(Type, Object)	동적으로 정의된 제네릭 형식 및 메서드에 대한 제네릭 형식 매개 변수를 정의하고 만듭니다. 이 클래스는 상속될 수 없습니다.

추가 정보

• DefineGenericParameters(String[])
• 방법: 리플렉션 내보내기를 사용하여 제네릭 형식 정의