GenericTypeParameterBuilder Kelas

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

System.Reflection.Emit.dll

Sumber:

GenericTypeParameterBuilder.cs

Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

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

Warisan

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Contoh

Contoh kode berikut membuat jenis generik dengan dua parameter jenis, dan menyimpannya di GenericEmitExample1.dll perakitan. Anda dapat menggunakan Ildasm.exe (Il Disassembler) untuk melihat jenis yang dihasilkan. Untuk penjelasan yang lebih rinci tentang langkah-langkah yang terlibat dalam menentukan jenis generik dinamis, lihat Cara: Menentukan Jenis Generik dengan Pancaran.

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

Keterangan

Anda bisa mendapatkan array GenericTypeParameterBuilder objek dengan menggunakan TypeBuilder.DefineGenericParameters metode untuk menambahkan parameter jenis ke jenis dinamis, sehingga menjadikannya jenis generik, atau dengan menggunakan MethodBuilder.DefineGenericParameters metode untuk menambahkan parameter jenis ke metode dinamis. GenericTypeParameterBuilder Gunakan objek untuk menambahkan batasan ke parameter jenis. Batasannya adalah tiga jenis:

• Batasan jenis dasar menentukan bahwa jenis apa pun yang ditetapkan ke parameter jenis generik harus berasal dari jenis dasar tertentu. Atur SetBaseTypeConstraint batasan ini dengan menggunakan metode .

• Batasan antarmuka menentukan bahwa jenis apa pun yang ditetapkan ke parameter jenis generik harus menerapkan antarmuka tertentu. Atur batasan antarmuka dengan menggunakan SetInterfaceConstraints metode .

• Batasan khusus menentukan bahwa jenis apa pun yang ditetapkan ke parameter jenis generik harus memiliki konstruktor tanpa parameter, harus merupakan jenis referensi, atau harus merupakan jenis nilai. Atur batasan khusus untuk parameter jenis dengan menggunakan SetGenericParameterAttributes metode .

Batasan antarmuka dan batasan khusus tidak dapat diambil menggunakan metode GenericTypeParameterBuilder kelas . Setelah Anda membuat jenis generik yang berisi parameter jenis, Anda dapat menggunakan objeknya Type untuk mencerminkan batasan. Type.GetGenericArguments Gunakan metode untuk mendapatkan parameter jenis, dan untuk setiap parameter jenis gunakan Type.GetGenericParameterConstraints metode untuk mendapatkan batasan jenis dasar dan batasan antarmuka, dan Type.GenericParameterAttributes properti untuk mendapatkan batasan khusus.

Konstruktor

GenericTypeParameterBuilder()

Menginisialisasi instans GenericTypeParameterBuilder kelas baru.

Properti

Assembly	Mendapatkan objek yang Assembly mewakili rakitan dinamis yang berisi definisi jenis generik yang dimiliki parameter jenis saat ini.
AssemblyQualifiedName	null Mendapatkan dalam semua kasus.
Attributes	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
BaseType	Mendapatkan batasan jenis dasar dari parameter jenis generik saat ini.
ContainsGenericParameters	true Mendapatkan dalam semua kasus.
CustomAttributes	Mendapatkan koleksi yang berisi atribut kustom anggota ini. (Diperoleh dari MemberInfo)
DeclaredConstructors	Mendapatkan koleksi konstruktor yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredEvents	Mendapatkan kumpulan peristiwa yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredFields	Mendapatkan kumpulan bidang yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredMembers	Mendapatkan kumpulan anggota yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredMethods	Mendapatkan kumpulan metode yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredNestedTypes	Mendapatkan kumpulan jenis berlapis yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaredProperties	Mendapatkan kumpulan properti yang ditentukan oleh jenis saat ini. (Diperoleh dari TypeInfo)
DeclaringMethod	MethodInfo Mendapatkan yang mewakili metode deklarasi, jika saat ini GenericTypeParameterBuilder mewakili parameter jenis metode generik.
DeclaringType	Mendapatkan definisi jenis generik atau definisi metode generik tempat parameter jenis generik berada.
FullName	null Mendapatkan dalam semua kasus.
GenericParameterAttributes	Mendapatkan kombinasi GenericParameterAttributes bendera yang menjelaskan kovariansi dan batasan khusus dari parameter jenis generik saat ini.
GenericParameterPosition	Mendapatkan posisi parameter jenis dalam daftar parameter jenis jenis atau metode generik yang mendeklarasikan parameter.
GenericTypeArguments	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GenericTypeParameters	Mendapatkan array parameter jenis generik dari instans saat ini. (Diperoleh dari TypeInfo)
GUID	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
HasElementType	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
ImplementedInterfaces	Mendapatkan koleksi antarmuka yang diimplementasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
IsAbstract	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsAnsiClass	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsArray	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsAutoClass	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsAutoLayout	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsByRef	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsByRefLike	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah struktur seperti byref.
IsClass	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsCollectible	Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo adalah bagian dari perakitan yang dipegang dalam koleksi AssemblyLoadContext. (Diperoleh dari MemberInfo)
IsCOMObject	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsConstructedGenericType	Mendapatkan nilai yang menunjukkan apakah objek ini mewakili jenis generik yang dibangun.
IsContextful	Mendapatkan nilai yang menunjukkan apakah Type dapat dihosting dalam konteks. (Diperoleh dari Type)
IsEnum	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsExplicitLayout	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsFunctionPointer	Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi. (Diperoleh dari Type)
IsGenericMethodParameter	Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi metode generik. (Diperoleh dari Type)
IsGenericParameter	true Mendapatkan dalam semua kasus.
IsGenericType	Mengembalikan false dalam semua kasus.
IsGenericTypeDefinition	false Mendapatkan dalam semua kasus.
IsGenericTypeParameter	Mendapatkan nilai yang menunjukkan apakah saat ini Type mewakili parameter jenis dalam definisi jenis generik. (Diperoleh dari Type)
IsImport	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsInterface	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsLayoutSequential	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsMarshalByRef	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNested	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNestedAssembly	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNestedFamANDAssem	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNestedFamily	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNestedFamORAssem	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNestedPrivate	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNestedPublic	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsNotPublic	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsPointer	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsPrimitive	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsPublic	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsSealed	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsSecurityCritical	Mendapatkan nilai yang menunjukkan apakah jenis saat ini kritis terhadap keamanan atau keamanan-aman-kritis pada tingkat kepercayaan saat ini, dan karenanya dapat melakukan operasi penting. (Diperoleh dari Type)
IsSecuritySafeCritical	Mendapatkan nilai yang menunjukkan apakah jenis saat ini adalah keamanan-aman-kritis pada tingkat kepercayaan saat ini; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan. (Diperoleh dari Type)
IsSecurityTransparent	Mendapatkan nilai yang menunjukkan apakah jenis saat ini transparan pada tingkat kepercayaan saat ini, dan karenanya tidak dapat melakukan operasi penting. (Diperoleh dari Type)
IsSerializable	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsSignatureType	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis tanda tangan. (Diperoleh dari Type)
IsSpecialName	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsSZArray	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang hanya dapat mewakili array dimensi tunggal dengan batas nol yang lebih rendah.
IsTypeDefinition	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah definisi jenis.
IsUnicodeClass	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsUnmanagedFunctionPointer	Mendapatkan nilai yang menunjukkan apakah saat ini Type adalah penunjuk fungsi yang tidak dikelola. (Diperoleh dari Type)
IsValueType	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsVariableBoundArray	Mendapatkan nilai yang menunjukkan apakah jenisnya adalah jenis array yang dapat mewakili array multi-dimensi atau array dengan batas bawah arbitrer. (Diperoleh dari Type)
IsVisible	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
MemberType	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
MetadataToken	Mendapatkan token yang mengidentifikasi modul dinamis saat ini dalam metadata.
Module	Mendapatkan modul dinamis yang berisi parameter jenis generik.
Name	Mendapatkan nama parameter jenis generik.
Namespace	null Mendapatkan dalam semua kasus.
ReflectedType	Type Mendapatkan objek yang digunakan untuk mendapatkan GenericTypeParameterBuilder.
StructLayoutAttribute	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
TypeHandle	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
TypeInitializer	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
UnderlyingSystemType	Mendapatkan parameter jenis generik saat ini.

Metode

AsType()	Mengembalikan tipe saat ini sebagai Type objek. (Diperoleh dari TypeInfo)
Equals(Object)	Menguji apakah objek yang diberikan adalah instans EventToken dan sama dengan instans saat ini.
Equals(Type)	Menentukan apakah jenis sistem yang mendasar dari saat ini Type sama dengan jenis sistem yang mendasar dari yang ditentukan Type. (Diperoleh dari Type)
FindInterfaces(TypeFilter, Object)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetArrayRank()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetAttributeFlagsImpl()	Ketika ditimpa di kelas turunan, terapkan Attributes properti dan dapatkan kombinasi bitwise dari nilai enumerasi yang menunjukkan atribut yang terkait dengan Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetConstructor(BindingFlags, Type[])	Mencari konstruktor yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetConstructor(Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetConstructors()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetConstructors(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetCustomAttributes(Boolean)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetCustomAttributes(Type, Boolean)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetCustomAttributesData()	Mengembalikan daftar CustomAttributeData objek yang mewakili data tentang atribut yang telah diterapkan ke anggota target. (Diperoleh dari MemberInfo)
GetDeclaredEvent(String)	Mengembalikan objek yang mewakili peristiwa yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredField(String)	Mengembalikan objek yang mewakili bidang yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredMethod(String)	Mengembalikan objek yang mewakili metode yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredMethods(String)	Mengembalikan koleksi yang berisi semua metode yang dideklarasikan pada tipe saat ini yang cocok dengan nama yang ditentukan. (Diperoleh dari TypeInfo)
GetDeclaredNestedType(String)	Mengembalikan objek yang mewakili tipe berlapis yang ditentukan yang dideklarasikan oleh jenis saat ini. (Diperoleh dari TypeInfo)
GetDeclaredProperty(String)	Mengembalikan objek yang mewakili properti yang ditentukan yang dideklarasikan oleh tipe saat ini. (Diperoleh dari TypeInfo)
GetDefaultMembers()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetElementType()	NotSupportedException Melempar dalam semua kasus.
GetEnumName(Object)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetEnumNames()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetEnumUnderlyingType()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetEnumValues()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetEnumValuesAsUnderlyingType()	Mengambil array nilai dari konstanta jenis dasar dari jenis enumerasi ini. (Diperoleh dari Type)
GetEvent(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetEvent(String, BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetEvents()	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetEvents(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetField(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetField(String, BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetFields()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetFields(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetFunctionPointerCallingConventions()	Saat ditimpa di kelas turunan, mengembalikan konvensi panggilan dari penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetFunctionPointerParameterTypes()	Saat ditimpa dalam kelas turunan, mengembalikan jenis parameter penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetFunctionPointerReturnType()	Saat ditimpa di kelas turunan, mengembalikan jenis pengembalian dari penunjuk Typefungsi saat ini . (Diperoleh dari Type)
GetGenericArguments()	Tidak valid untuk parameter jenis generik.
GetGenericParameterConstraints()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetGenericTypeDefinition()	Tidak valid untuk parameter jenis generik.
GetHashCode()	Mengembalikan kode hash bilangan bulat 32-bit untuk instans saat ini.
GetInterface(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetInterface(String, Boolean)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetInterfaceMap(Type)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetInterfaces()	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetMember(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMember(String, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetMembers()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMembers(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	MemberInfo Mencari pada saat ini Type yang cocok dengan yang ditentukanMemberInfo. (Diperoleh dari Type)
GetMethod(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, BindingFlags, Type[])	Mencari metode yang ditentukan yang parameternya cocok dengan jenis argumen yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Mencari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, BindingFlags, Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari Type)
GetMethod(String, Int32, Type[])	Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik dan jenis argumen yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Mencari metode publik yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan. (Diperoleh dari Type)
GetMethod(String, Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Saat ditimpa dalam kelas turunan, cari metode yang ditentukan yang parameternya cocok dengan jumlah parameter generik, jenis argumen, dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan konvensi panggilan yang ditentukan. (Diperoleh dari Type)
GetMethods()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetMethods(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetNestedType(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetNestedType(String, BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetNestedTypes()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetNestedTypes(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetOptionalCustomModifiers()	Saat ditimpa di kelas turunan, mengembalikan pengubah kustom opsional dari saat ini Type. (Diperoleh dari Type)
GetProperties()	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetProperties(BindingFlags)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetProperty(String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Mencari properti yang ditentukan yang parameternya cocok dengan jenis argumen dan pengubah yang ditentukan, menggunakan batasan pengikatan yang ditentukan. (Diperoleh dari Type)
GetProperty(String, Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetProperty(String, Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
GetRequiredCustomModifiers()	Ketika ditimpa di kelas turunan, mengembalikan pengubah kustom yang diperlukan dari saat ini Type. (Diperoleh dari Type)
GetType()	Mendapatkan saat ini Type. (Diperoleh dari Type)
GetTypeCodeImpl()	Mengembalikan kode jenis yang mendasar dari instans ini Type . (Diperoleh dari Type)
HasElementTypeImpl()	Ketika ditimpa di kelas turunan, terapkan HasElementType properti dan tentukan apakah saat ini Type mencakup atau mengacu pada jenis lain; yaitu, apakah saat ini Type adalah array, penunjuk, atau diteruskan oleh referensi.
HasSameMetadataDefinitionAs(MemberInfo)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan cocok dengan daftar argumen yang ditentukan. (Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Memanggil anggota yang ditentukan, menggunakan batasan pengikatan yang ditentukan dan mencocokkan daftar argumen dan budaya yang ditentukan. (Diperoleh dari Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
IsArrayImpl()	Saat ditimpa di kelas turunan, terapkan IsArray properti dan tentukan Type apakah itu array.
IsAssignableFrom(Type)	NotSupportedException Memberikan pengecualian dalam semua kasus.
IsAssignableFrom(TypeInfo)	NotSupportedException Memberikan pengecualian dalam semua kasus.
IsAssignableTo(Type)	Menentukan apakah jenis saat ini dapat ditetapkan ke variabel dari yang ditentukan targetType. (Diperoleh dari Type)
IsByRefImpl()	Ketika ditimpa di kelas turunan, terapkan IsByRef properti dan tentukan apakah Type diteruskan oleh referensi.
IsCOMObjectImpl()	Ketika ditimpa di kelas turunan, terapkan IsCOMObject properti dan tentukan Type apakah itu objek COM.
IsContextfulImpl()	IsContextful Menerapkan properti dan menentukan apakah Type dapat dihosting dalam konteks. (Diperoleh dari Type)
IsDefined(Type, Boolean)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
IsEnumDefined(Object)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsEquivalentTo(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsInstanceOfType(Object)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan. (Diperoleh dari TypeInfo)
IsMarshalByRefImpl()	IsMarshalByRef Mengimplementasikan properti dan menentukan apakah Type marshaled by reference. (Diperoleh dari Type)
IsPointerImpl()	Ketika ditimpa di kelas turunan, terapkan IsPointer properti dan tentukan Type apakah itu penunjuk.
IsPrimitiveImpl()	Ketika ditimpa dalam kelas turunan, terapkan IsPrimitive properti dan tentukan apakah Type itu salah satu jenis primitif.
IsSubclassOf(Type)	Tidak didukung untuk parameter jenis generik yang tidak lengkap.
IsValueTypeImpl()	IsValueType Mengimplementasikan properti dan menentukan apakah Type adalah jenis nilai; yaitu, bukan kelas atau antarmuka.
MakeArrayType()	Mengembalikan jenis array satu dimensi yang jenis elemennya adalah parameter jenis generik.
MakeArrayType(Int32)	Mengembalikan jenis array yang jenis elemennya adalah parameter jenis generik, dengan jumlah dimensi yang ditentukan.
MakeByRefType()	Mengembalikan Type objek yang mewakili parameter jenis generik saat ini saat diteruskan sebagai parameter referensi.
MakeGenericType(Type[])	Tidak valid untuk parameter jenis generik yang tidak lengkap.
MakePointerType()	Mengembalikan Type objek yang mewakili penunjuk ke parameter jenis generik saat ini.
MemberwiseClone()	Membuat salinan dangkal dari yang saat ini Object. (Diperoleh dari Object)
SetBaseTypeConstraint(Type)	Mengatur jenis dasar yang harus diwarisi jenis agar diganti dengan parameter jenis.
SetBaseTypeConstraintCore(Type)	Saat ditimpa di kelas turunan, mengatur jenis dasar yang harus diwarisi jenis agar diganti dengan parameter jenis.
SetCustomAttribute(ConstructorInfo, Byte[])	Mengatur atribut kustom menggunakan blob atribut kustom tertentu.
SetCustomAttribute(CustomAttributeBuilder)	Atur atribut kustom menggunakan penyusun atribut kustom.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Saat ditimpa di kelas turunan, mengatur atribut kustom pada rakitan ini.
SetGenericParameterAttributes(GenericParameterAttributes)	Mengatur karakteristik varians dan batasan khusus dari parameter generik, seperti batasan konstruktor tanpa parameter.
SetGenericParameterAttributesCore(GenericParameterAttributes)	Ketika ditimpa dalam kelas turunan, mengatur karakteristik varians dan batasan khusus dari parameter generik, seperti batasan konstruktor tanpa parameter.
SetInterfaceConstraints(Type[])	Mengatur antarmuka yang harus diimplementasikan jenis agar diganti dengan parameter jenis.
SetInterfaceConstraintsCore(Type[])	Ketika ditimpa di kelas turunan, mengatur antarmuka yang harus diterapkan jenis agar diganti dengan parameter jenis.
ToString()	Mengembalikan representasi string dari parameter jenis generik saat ini.

Implementasi Antarmuka Eksplisit

IReflectableType.GetTypeInfo()

Mengembalikan representasi dari jenis saat ini sebagai TypeInfo objek. (Diperoleh dari TypeInfo)

Metode Ekstensi

GetCustomAttribute(MemberInfo, Type)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute(MemberInfo, Type, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute<T>(MemberInfo)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute<T>(MemberInfo, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Type, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes<T>(MemberInfo)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes<T>(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
IsDefined(MemberInfo, Type)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.
IsDefined(MemberInfo, Type, Boolean)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.
GetTypeInfo(Type)	Mengembalikan TypeInfo representasi dari jenis yang ditentukan.
GetMetadataToken(MemberInfo)	Mendapatkan token metadata untuk anggota tertentu, jika tersedia.
HasMetadataToken(MemberInfo)	Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.
GetRuntimeEvent(Type, String)	Mengambil objek yang mewakili peristiwa yang ditentukan.
GetRuntimeEvents(Type)	Mengambil koleksi yang mewakili semua peristiwa yang ditentukan pada jenis tertentu.
GetRuntimeField(Type, String)	Mengambil objek yang mewakili bidang tertentu.
GetRuntimeFields(Type)	Mengambil koleksi yang mewakili semua bidang yang ditentukan pada jenis tertentu.
GetRuntimeInterfaceMap(TypeInfo, Type)	Mengembalikan pemetaan antarmuka untuk jenis yang ditentukan dan antarmuka yang ditentukan.
GetRuntimeMethod(Type, String, Type[])	Mengambil objek yang mewakili metode tertentu.
GetRuntimeMethods(Type)	Mengambil koleksi yang mewakili semua metode yang ditentukan pada jenis tertentu.
GetRuntimeProperties(Type)	Mengambil koleksi yang mewakili semua properti yang ditentukan pada jenis tertentu.
GetRuntimeProperty(Type, String)	Mengambil objek yang mewakili properti tertentu.
GetConstructor(Type, Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetConstructors(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetConstructors(Type, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetFields(Type, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetGenericArguments(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetInterfaces(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetMember(Type, String)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetMember(Type, String, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetMembers(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetMethods(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetNestedType(Type, String, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetProperties(Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetProperties(Type, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetProperty(Type, String, BindingFlags)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetProperty(Type, String, Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
GetProperty(Type, String, Type, Type[])	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
IsAssignableFrom(Type, Type)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.
IsInstanceOfType(Type, Object)	Menentukan dan membuat parameter jenis generik untuk jenis dan metode generik yang ditentukan secara dinamis. Kelas ini tidak dapat diwariskan.

Lihat juga

• DefineGenericParameters(String[])
• Petunjuk: Menentukan Jenis Generik dengan Pancaran Refleksi