GenericTypeParameterBuilder Klasa

Definicja

Przestrzeń nazw:

System.Reflection.Emit

Zestaw:

System.Reflection.Emit.dll

Źródło:

GenericTypeParameterBuilder.cs

Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.

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

Dziedziczenie

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Przykłady

Poniższy przykład kodu tworzy typ ogólny z dwoma parametrami typu i zapisuje je w zestawie GenericEmitExample1.dll. Aby wyświetlić wygenerowane typy, można użyć Ildasm.exe (dezasembler IL). Aby uzyskać bardziej szczegółowe wyjaśnienie kroków związanych z definiowaniem dynamicznego typu ogólnego, zobacz How to: Define a Generic Type with Reflection Emit.

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

Uwagi

Tablicę obiektów GenericTypeParameterBuilder można uzyskać przy użyciu metody TypeBuilder.DefineGenericParameters w celu dodania parametrów typu do typu dynamicznego, co czyni go typem ogólnym lub za pomocą metody MethodBuilder.DefineGenericParameters dodawania parametrów typu do metody dynamicznej. Użyj obiektów GenericTypeParameterBuilder, aby dodać ograniczenia do parametrów typu. Ograniczenia mają trzy rodzaje:

• Ograniczenie typu podstawowego określa, że każdy typ przypisany do parametru typu ogólnego musi pochodzić z określonego typu podstawowego. Ustaw to ograniczenie przy użyciu metody SetBaseTypeConstraint.

• Ograniczenie interfejsu określa, że dowolny typ przypisany do parametru typu ogólnego musi implementować określony interfejs. Ustaw ograniczenia interfejsu przy użyciu metody SetInterfaceConstraints.

• Ograniczenia specjalne określają, że dowolny typ przypisany do parametru typu ogólnego musi mieć konstruktor bez parametrów, musi być typem odwołania lub musi być typem wartości. Ustaw specjalne ograniczenia dla parametru typu przy użyciu metody SetGenericParameterAttributes.

Nie można pobrać ograniczeń interfejsu i specjalnych ograniczeń przy użyciu metod klasy GenericTypeParameterBuilder. Po utworzeniu typu ogólnego zawierającego parametry typu można użyć jego Type obiektu, aby odzwierciedlić ograniczenia. Użyj metody Type.GetGenericArguments, aby uzyskać parametry typu, a dla każdego parametru typu użyj metody Type.GetGenericParameterConstraints, aby uzyskać ograniczenie typu podstawowego i ograniczenia interfejsu oraz właściwość Type.GenericParameterAttributes, aby uzyskać specjalne ograniczenia.

Konstruktory

GenericTypeParameterBuilder()

Inicjuje nowe wystąpienie klasy GenericTypeParameterBuilder.

Właściwości

Assembly	Pobiera obiekt Assembly reprezentujący zestaw dynamiczny zawierający definicję typu ogólnego, do którego należy bieżący parametr typu.
AssemblyQualifiedName	Pobiera null we wszystkich przypadkach.
Attributes	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
BaseType	Pobiera ograniczenie typu podstawowego bieżącego parametru typu ogólnego.
ContainsGenericParameters	Pobiera true we wszystkich przypadkach.
CustomAttributes	Pobiera kolekcję zawierającą atrybuty niestandardowe tego elementu członkowskiego. (Odziedziczone po MemberInfo)
DeclaredConstructors	Pobiera kolekcję konstruktorów zadeklarowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaredEvents	Pobiera kolekcję zdarzeń zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaredFields	Pobiera kolekcję pól zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaredMembers	Pobiera kolekcję elementów członkowskich zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaredMethods	Pobiera kolekcję metod zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaredNestedTypes	Pobiera kolekcję zagnieżdżonych typów zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaredProperties	Pobiera kolekcję właściwości zdefiniowanych przez bieżący typ. (Odziedziczone po TypeInfo)
DeclaringMethod	Pobiera MethodInfo reprezentującą metodę deklaratora, jeśli bieżąca GenericTypeParameterBuilder reprezentuje parametr typu metody ogólnej.
DeclaringType	Pobiera definicję typu ogólnego lub definicję metody ogólnej, do której należy parametr typu ogólnego.
FullName	Pobiera null we wszystkich przypadkach.
GenericParameterAttributes	Pobiera kombinację flag GenericParameterAttributes opisujących kowariancję i specjalne ograniczenia bieżącego parametru typu ogólnego.
GenericParameterPosition	Pobiera pozycję parametru typu na liście parametrów typu typu lub metody, która zadeklarowała parametr.
GenericTypeArguments	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GenericTypeParameters	Pobiera tablicę parametrów typu ogólnego bieżącego wystąpienia. (Odziedziczone po TypeInfo)
GUID	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
HasElementType	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
ImplementedInterfaces	Pobiera kolekcję interfejsów implementowanych przez bieżący typ. (Odziedziczone po TypeInfo)
IsAbstract	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsAnsiClass	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsArray	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsAutoClass	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsAutoLayout	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsByRef	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsByRefLike	Pobiera wartość wskazującą, czy typ jest strukturą przypominającą byref.
IsClass	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsCollectible	Pobiera wartość wskazującą, czy ten obiekt MemberInfo jest częścią zestawu przechowywanego w zbieralnej AssemblyLoadContext. (Odziedziczone po MemberInfo)
IsCOMObject	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsConstructedGenericType	Pobiera wartość wskazującą, czy ten obiekt reprezentuje skonstruowany typ ogólny.
IsContextful	Pobiera wartość wskazującą, czy Type może być hostowana w kontekście. (Odziedziczone po Type)
IsEnum	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsExplicitLayout	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsFunctionPointer	Pobiera wartość wskazującą, czy bieżący Type jest wskaźnikiem funkcji. (Odziedziczone po Type)
IsGenericMethodParameter	Pobiera wartość wskazującą, czy bieżąca Type reprezentuje parametr typu w definicji metody ogólnej. (Odziedziczone po Type)
IsGenericParameter	Pobiera true we wszystkich przypadkach.
IsGenericType	Zwraca false we wszystkich przypadkach.
IsGenericTypeDefinition	Pobiera false we wszystkich przypadkach.
IsGenericTypeParameter	Pobiera wartość wskazującą, czy bieżący Type reprezentuje parametr typu w definicji typu ogólnego. (Odziedziczone po Type)
IsImport	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsInterface	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsLayoutSequential	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsMarshalByRef	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNested	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNestedAssembly	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNestedFamANDAssem	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNestedFamily	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNestedFamORAssem	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNestedPrivate	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNestedPublic	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsNotPublic	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsPointer	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsPrimitive	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsPublic	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsSealed	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsSecurityCritical	Pobiera wartość wskazującą, czy bieżący typ ma krytyczne znaczenie dla zabezpieczeń, czy bezpieczeństwo krytyczne dla bieżącego poziomu zaufania, a w związku z tym może wykonywać operacje krytyczne. (Odziedziczone po Type)
IsSecuritySafeCritical	Pobiera wartość wskazującą, czy bieżący typ ma krytyczne znaczenie dla bezpieczeństwa na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskać do niego dostęp za pomocą przezroczystego kodu. (Odziedziczone po Type)
IsSecurityTransparent	Pobiera wartość wskazującą, czy bieżący typ jest niewidoczny na bieżącym poziomie zaufania i dlatego nie może wykonywać operacji krytycznych. (Odziedziczone po Type)
IsSerializable	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsSignatureType	Pobiera wartość wskazującą, czy typ jest typem podpisu. (Odziedziczone po Type)
IsSpecialName	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsSZArray	Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tylko jednowymiarową tablicę z zerową dolną granicą.
IsTypeDefinition	Pobiera wartość wskazującą, czy typ jest definicją typu.
IsUnicodeClass	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsUnmanagedFunctionPointer	Pobiera wartość wskazującą, czy bieżący Type jest niezarządzanym wskaźnikiem funkcji. (Odziedziczone po Type)
IsValueType	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsVariableBoundArray	Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tablicę wielowymiarową, czy tablicę z dowolną dolną granicą. (Odziedziczone po Type)
IsVisible	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
MemberType	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
MetadataToken	Pobiera token identyfikujący bieżący moduł dynamiczny w metadanych.
Module	Pobiera moduł dynamiczny zawierający parametr typu ogólnego.
Name	Pobiera nazwę parametru typu ogólnego.
Namespace	Pobiera null we wszystkich przypadkach.
ReflectedType	Pobiera obiekt Type, który został użyty do uzyskania GenericTypeParameterBuilder.
StructLayoutAttribute	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
TypeHandle	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
TypeInitializer	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
UnderlyingSystemType	Pobiera bieżący parametr typu ogólnego.

Metody

AsType()	Zwraca bieżący typ jako obiekt Type. (Odziedziczone po TypeInfo)
Equals(Object)	Sprawdza, czy dany obiekt jest wystąpieniem EventToken i jest równe bieżącemu wystąpieniu.
Equals(Type)	Określa, czy podstawowy typ systemu bieżącej Type jest taki sam jak podstawowy typ systemu określonego Type. (Odziedziczone po Type)
FindInterfaces(TypeFilter, Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetArrayRank()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetAttributeFlagsImpl()	Po zastąpieniu w klasie pochodnej implementuje właściwość Attributes i pobiera bitową kombinację wartości wyliczenia, które wskazują atrybuty skojarzone z Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązań i określonej konwencji wywoływania. (Odziedziczone po Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetConstructor(BindingFlags, Type[])	Wyszukuje konstruktor, którego parametry są zgodne z określonymi typami argumentów, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetConstructor(Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetConstructors()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetConstructors(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetCustomAttributes(Boolean)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetCustomAttributes(Type, Boolean)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetCustomAttributesData()	Zwraca listę obiektów CustomAttributeData reprezentujących dane dotyczące atrybutów zastosowanych do elementu członkowskiego docelowego. (Odziedziczone po MemberInfo)
GetDeclaredEvent(String)	Zwraca obiekt reprezentujący określone zdarzenie zadeklarowane przez bieżący typ. (Odziedziczone po TypeInfo)
GetDeclaredField(String)	Zwraca obiekt reprezentujący określone pole zadeklarowane przez bieżący typ. (Odziedziczone po TypeInfo)
GetDeclaredMethod(String)	Zwraca obiekt reprezentujący określoną metodę zadeklarowaną przez bieżący typ. (Odziedziczone po TypeInfo)
GetDeclaredMethods(String)	Zwraca kolekcję zawierającą wszystkie metody zadeklarowane w bieżącym typie, który jest zgodny z określoną nazwą. (Odziedziczone po TypeInfo)
GetDeclaredNestedType(String)	Zwraca obiekt reprezentujący określony typ zagnieżdżony zadeklarowany przez bieżący typ. (Odziedziczone po TypeInfo)
GetDeclaredProperty(String)	Zwraca obiekt reprezentujący określoną właściwość zadeklarowaną przez bieżący typ. (Odziedziczone po TypeInfo)
GetDefaultMembers()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetElementType()	Zgłasza NotSupportedException we wszystkich przypadkach.
GetEnumName(Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetEnumNames()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetEnumUnderlyingType()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetEnumValues()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetEnumValuesAsUnderlyingType()	Pobiera tablicę wartości stałych typu bazowego tego typu. (Odziedziczone po Type)
GetEvent(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetEvent(String, BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetEvents()	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetEvents(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetField(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetField(String, BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetFields()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetFields(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetFunctionPointerCallingConventions()	Po zastąpieniu w klasie pochodnej zwraca konwencje wywoływania bieżącego wskaźnika funkcji Type. (Odziedziczone po Type)
GetFunctionPointerParameterTypes()	Po zastąpieniu w klasie pochodnej zwraca typy parametrów bieżącego wskaźnika funkcji Type. (Odziedziczone po Type)
GetFunctionPointerReturnType()	Po przesłonięciu w klasie pochodnej zwracany typ wskaźnika bieżącej funkcji Type. (Odziedziczone po Type)
GetGenericArguments()	Nieprawidłowy dla parametrów typu ogólnego.
GetGenericParameterConstraints()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetGenericTypeDefinition()	Nieprawidłowy dla parametrów typu ogólnego.
GetHashCode()	Zwraca 32-bitowy kod skrótu liczby całkowitej dla bieżącego wystąpienia.
GetInterface(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetInterface(String, Boolean)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetInterfaceMap(Type)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetInterfaces()	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetMember(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMember(String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetMembers()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMembers(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Wyszukuje MemberInfo w bieżącym Type zgodnym z określonym MemberInfo. (Odziedziczone po Type)
GetMethod(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMethod(String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązań i określonej konwencji wywoływania. (Odziedziczone po Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetMethod(String, BindingFlags, Type[])	Wyszukuje określoną metodę, której parametry są zgodne z określonymi typami argumentów, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetMethod(String, Int32, BindingFlags, Type[])	Wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów i typami argumentów, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetMethod(String, Int32, Type[])	Wyszukuje określoną metodę publiczną, której parametry są zgodne z określoną ogólną liczbą parametrów i typami argumentów. (Odziedziczone po Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Wyszukuje określoną metodę publiczną, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami. (Odziedziczone po Type)
GetMethod(String, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Po zastąpieniu w klasie pochodnej wyszukuje określoną metodę, której parametry są zgodne z określoną ogólną liczbą parametrów, typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania i określonej konwencji wywoływania. (Odziedziczone po Type)
GetMethods()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetMethods(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetNestedType(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetNestedType(String, BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetNestedTypes()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetNestedTypes(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetOptionalCustomModifiers()	Po zastąpieniu w klasie pochodnej zwraca opcjonalne modyfikatory niestandardowe bieżącego Type. (Odziedziczone po Type)
GetProperties()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetProperties(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetProperty(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetProperty(String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Wyszukuje określoną właściwość, której parametry są zgodne z określonymi typami argumentów i modyfikatorami, przy użyciu określonych ograniczeń powiązania. (Odziedziczone po Type)
GetProperty(String, Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetProperty(String, Type, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetProperty(String, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetRequiredCustomModifiers()	Po zastąpieniu w klasie pochodnej zwraca wymagane modyfikatory niestandardowe bieżącego Type. (Odziedziczone po Type)
GetType()	Pobiera bieżący Type. (Odziedziczone po Type)
GetTypeCodeImpl()	Zwraca kod typu bazowego tego wystąpienia Type. (Odziedziczone po Type)
HasElementTypeImpl()	Po zastąpieniu w klasie pochodnej implementuje właściwość HasElementType i określa, czy bieżący Type obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżąca Type jest tablicą, wskaźnikiem, czy jest przekazywana przez odwołanie.
HasSameMetadataDefinitionAs(MemberInfo)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Wywołuje określony element członkowski przy użyciu określonych ograniczeń powiązania i dopasowywania określonej listy argumentów. (Odziedziczone po Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Wywołuje określony element członkowski przy użyciu określonych ograniczeń powiązania i dopasowywania określonej listy argumentów i kultury. (Odziedziczone po Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
IsArrayImpl()	Podczas zastępowania w klasie pochodnej implementuje właściwość IsArray i określa, czy Type jest tablicą.
IsAssignableFrom(Type)	Zgłasza wyjątek NotSupportedException we wszystkich przypadkach.
IsAssignableFrom(TypeInfo)	Zgłasza wyjątek NotSupportedException we wszystkich przypadkach.
IsAssignableTo(Type)	Określa, czy bieżący typ można przypisać do zmiennej określonego targetType. (Odziedziczone po Type)
IsByRefImpl()	Po zastąpieniu w klasie pochodnej implementuje właściwość IsByRef i określa, czy Type jest przekazywany przez odwołanie.
IsCOMObjectImpl()	Podczas zastępowania w klasie pochodnej implementuje właściwość IsCOMObject i określa, czy Type jest obiektem COM.
IsContextfulImpl()	Implementuje właściwość IsContextful i określa, czy Type może być hostowana w kontekście. (Odziedziczone po Type)
IsDefined(Type, Boolean)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
IsEnumDefined(Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsEquivalentTo(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsInstanceOfType(Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć. (Odziedziczone po TypeInfo)
IsMarshalByRefImpl()	Implementuje właściwość IsMarshalByRef i określa, czy Type jest marshalowana przez odwołanie. (Odziedziczone po Type)
IsPointerImpl()	Podczas zastępowania w klasie pochodnej implementuje właściwość IsPointer i określa, czy Type jest wskaźnikiem.
IsPrimitiveImpl()	Podczas zastępowania w klasie pochodnej implementuje właściwość IsPrimitive i określa, czy Type jest jednym z typów pierwotnych.
IsSubclassOf(Type)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
IsValueTypeImpl()	Implementuje właściwość IsValueType i określa, czy Type jest typem wartości; oznacza to, że nie jest to klasa ani interfejs.
MakeArrayType()	Zwraca typ tablicy jednowymiarowej, której typ elementu jest parametrem typu ogólnego.
MakeArrayType(Int32)	Zwraca typ tablicy, której typ elementu jest parametrem typu ogólnego z określoną liczbą wymiarów.
MakeByRefType()	Zwraca obiekt Type, który reprezentuje bieżący parametr typu ogólnego po przekazaniu jako parametr odwołania.
MakeGenericType(Type[])	Nieprawidłowe w przypadku niekompletnych parametrów typu ogólnego.
MakePointerType()	Zwraca obiekt Type reprezentujący wskaźnik do bieżącego parametru typu ogólnego.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
SetBaseTypeConstraint(Type)	Ustawia typ podstawowy, który typ musi dziedziczyć, aby zastąpić parametr type.
SetBaseTypeConstraintCore(Type)	Po zastąpieniu w klasie pochodnej ustawia typ podstawowy, który typ musi dziedziczyć, aby zastąpić parametr typu.
SetCustomAttribute(ConstructorInfo, Byte[])	Ustawia atrybut niestandardowy przy użyciu określonego obiektu blob atrybutu niestandardowego.
SetCustomAttribute(CustomAttributeBuilder)	Ustaw atrybut niestandardowy przy użyciu konstruktora atrybutów niestandardowych.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Po zastąpieniu w klasie pochodnej ustawia atrybut niestandardowy dla tego zestawu.
SetGenericParameterAttributes(GenericParameterAttributes)	Ustawia charakterystyki wariancji i specjalne ograniczenia parametru ogólnego, takie jak ograniczenie konstruktora bez parametrów.
SetGenericParameterAttributesCore(GenericParameterAttributes)	Po zastąpieniu w klasie pochodnej ustawia właściwości wariancji i specjalne ograniczenia parametru ogólnego, takie jak ograniczenie konstruktora bez parametru.
SetInterfaceConstraints(Type[])	Ustawia interfejsy, które musi implementować typ, aby zastąpić parametr type.
SetInterfaceConstraintsCore(Type[])	Po zastąpieniu w klasie pochodnej ustawia interfejsy, które musi implementować typ, aby zastąpić parametr type.
ToString()	Zwraca reprezentację ciągu bieżącego parametru typu ogólnego.

Jawne implementacje interfejsu

IReflectableType.GetTypeInfo()

Zwraca reprezentację bieżącego typu jako obiekt TypeInfo. (Odziedziczone po TypeInfo)

Metody rozszerzania

GetCustomAttribute(MemberInfo, Type)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.
GetCustomAttribute(MemberInfo, Type, Boolean)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.
GetCustomAttribute<T>(MemberInfo)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego.
GetCustomAttribute<T>(MemberInfo, Boolean)	Pobiera atrybut niestandardowy określonego typu, który jest stosowany do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.
GetCustomAttributes(MemberInfo)	Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego.
GetCustomAttributes(MemberInfo, Boolean)	Pobiera kolekcję atrybutów niestandardowych, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.
GetCustomAttributes(MemberInfo, Type)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.
GetCustomAttributes(MemberInfo, Type, Boolean)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.
GetCustomAttributes<T>(MemberInfo)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego.
GetCustomAttributes<T>(MemberInfo, Boolean)	Pobiera kolekcję atrybutów niestandardowych określonego typu, które są stosowane do określonego elementu członkowskiego, i opcjonalnie sprawdza przodków tego elementu członkowskiego.
IsDefined(MemberInfo, Type)	Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego.
IsDefined(MemberInfo, Type, Boolean)	Wskazuje, czy atrybuty niestandardowe określonego typu są stosowane do określonego elementu członkowskiego, a opcjonalnie stosowane do jego elementów nadrzędnych.
GetTypeInfo(Type)	Zwraca TypeInfo reprezentację określonego typu.
GetMetadataToken(MemberInfo)	Pobiera token metadanych dla danego elementu członkowskiego, jeśli jest dostępny.
HasMetadataToken(MemberInfo)	Zwraca wartość wskazującą, czy token metadanych jest dostępny dla określonego elementu członkowskiego.
GetRuntimeEvent(Type, String)	Pobiera obiekt reprezentujący określone zdarzenie.
GetRuntimeEvents(Type)	Pobiera kolekcję reprezentującą wszystkie zdarzenia zdefiniowane w określonym typie.
GetRuntimeField(Type, String)	Pobiera obiekt reprezentujący określone pole.
GetRuntimeFields(Type)	Pobiera kolekcję reprezentującą wszystkie pola zdefiniowane w określonym typie.
GetRuntimeInterfaceMap(TypeInfo, Type)	Zwraca mapowanie interfejsu dla określonego typu i określonego interfejsu.
GetRuntimeMethod(Type, String, Type[])	Pobiera obiekt reprezentujący określoną metodę.
GetRuntimeMethods(Type)	Pobiera kolekcję reprezentującą wszystkie metody zdefiniowane w określonym typie.
GetRuntimeProperties(Type)	Pobiera kolekcję reprezentującą wszystkie właściwości zdefiniowane w określonym typie.
GetRuntimeProperty(Type, String)	Pobiera obiekt reprezentujący określoną właściwość.
GetConstructor(Type, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetConstructors(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetDefaultMembers(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetEvent(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetField(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetInterfaces(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetMember(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetMembers(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetMethod(Type, String, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetNestedType(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetProperties(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetProperties(Type, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetProperty(Type, String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetProperty(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetProperty(Type, String, Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
GetProperty(Type, String, Type, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
IsAssignableFrom(Type, Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.
IsInstanceOfType(Type, Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Tej klasy nie można dziedziczyć.

Zobacz też

• DefineGenericParameters(String[])
• Instrukcje: definiowanie typu ogólnego z emisją odbicia