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. Klasa ta nie może być dziedziczona.

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 GenericEmitExample1.dll zestawu. 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 (Jak zdefiniować typ ogólny z emitem odbicia).

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ę GenericTypeParameterBuilder obiektów można uzyskać przy użyciu TypeBuilder.DefineGenericParameters metody dodawania parametrów typu do typu dynamicznego, co czyni go typem ogólnym lub za pomocą MethodBuilder.DefineGenericParameters metody dodawania parametrów typu do metody dynamicznej. GenericTypeParameterBuilder Użyj obiektów, aby dodać ograniczenia do parametrów typu. Ograniczenia to 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 SetBaseTypeConstraint metody .

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

• Ograniczenia specjalne określają, że każdy 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 SetGenericParameterAttributes metody .

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

Konstruktory

GenericTypeParameterBuilder()

Inicjuje nowe wystąpienie klasy GenericTypeParameterBuilder.

Właściwości

Assembly	Assembly Pobiera obiekt 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. Klasa ta nie może być dziedziczona. (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 obiekt MethodInfo reprezentujący metodę deklaratowania, jeśli bieżący 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ę GenericParameterAttributes flag 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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsAnsiClass	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsArray	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsAutoClass	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsAutoLayout	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsByRef	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsCollectible	Pobiera wartość wskazującą, czy ten MemberInfo obiekt jest częścią zestawu przechowywanego w obiekcie zbieralnym AssemblyLoadContext. (Odziedziczone po MemberInfo)
IsCOMObject	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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ć hostowany w kontekście. (Odziedziczone po Type)
IsEnum	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsExplicitLayout	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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żący Type reprezentuje parametr typu w definicji metody ogólnej. (Odziedziczone po Type)
IsGenericParameter	Pobiera true we wszystkich przypadkach.
IsGenericType	Zwraca wartość 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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsInterface	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsLayoutSequential	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsMarshalByRef	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNested	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNestedAssembly	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNestedFamANDAssem	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNestedFamily	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNestedFamORAssem	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNestedPrivate	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNestedPublic	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsNotPublic	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsPointer	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsPrimitive	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsPublic	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsSealed	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsSecurityCritical	Pobiera wartość wskazującą, czy bieżący typ jest krytyczny dla zabezpieczeń, czy krytyczny pod względem zabezpieczeń na bieżącym poziomie zaufania, a zatem może wykonywać operacje krytyczne. (Odziedziczone po Type)
IsSecuritySafeCritical	Pobiera wartość wskazującą, czy bieżący typ jest krytyczny pod względem zabezpieczeń na bieżącym poziomie zaufania; oznacza to, czy może wykonywać operacje krytyczne i można uzyskiwać do niego dostęp za pomocą przezroczystego kodu. (Odziedziczone po Type)
IsSecurityTransparent	Pobiera wartość wskazującą, czy bieżący typ jest przezroczysty 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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsSZArray	Pobiera wartość wskazującą, czy typ jest typem tablicy, który może reprezentować tylko tablicę jednowymiarową 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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsUnmanagedFunctionPointer	Pobiera wartość wskazującą, czy bieżący Type jest wskaźnikiem funkcji niezarządzanej. (Odziedziczone po Type)
IsValueType	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
MemberType	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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	Type Pobiera obiekt, który został użyty do uzyskania obiektu GenericTypeParameterBuilder.
StructLayoutAttribute	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
UnderlyingSystemType	Pobiera bieżący parametr typu ogólnego.

Metody

AsType()	Zwraca bieżący typ jako Type obiekt. (Odziedziczone po TypeInfo)
Equals(Object)	Sprawdza, czy dany obiekt jest wystąpieniem EventToken elementu i jest równe bieżącemu wystąpieniu.
Equals(Type)	Określa, czy podstawowy typ systemu bieżącego 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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetArrayRank()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetAttributeFlagsImpl()	Po zastąpieniu w klasie pochodnej implementuje Attributes właściwość i pobiera bitową kombinację wartości wyliczenia, które wskazują atrybuty skojarzone z Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Wyszukuje konstruktora, 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 konstruktora, 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 konstruktora, 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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (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ę CustomAttributeData obiektów reprezentujących dane dotyczące atrybutów, które zostały zastosowane do elementu 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 dla bieżącego typu zgodnego 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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetElementType()	Zgłasza wartość NotSupportedException we wszystkich przypadkach.
GetEnumName(Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetEnumNames()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetEnumUnderlyingType()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetEnumValues()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetEnumValuesAsUnderlyingType()	Pobiera tablicę wartości stałych typu bazowego tego typu wyliczenia. (Odziedziczone po Type)
GetEvent(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetFields(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetFunctionPointerCallingConventions()	Po przesłonięciu w klasie pochodnej zwraca konwencje wywoływania bieżącego wskaźnika Typefunkcji . (Odziedziczone po Type)
GetFunctionPointerParameterTypes()	Po zastąpieniu w klasie pochodnej zwraca typy parametrów bieżącego wskaźnika Typefunkcji . (Odziedziczone po Type)
GetFunctionPointerReturnType()	Po zastąpieniu w klasie pochodnej zwraca zwracany typ bieżącego wskaźnika Typefunkcji . (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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetMember(String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetMembers(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	MemberInfo Wyszukuje element w bieżącymType, który jest zgodny z określonym MemberInfoelementem . (Odziedziczone po Type)
GetMethod(String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetMethod(String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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[])	Podczas zastępowania 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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetNestedTypes(BindingFlags)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetOptionalCustomModifiers()	Po przesłonięciu w klasie pochodnej zwraca opcjonalne modyfikatory niestandardowe bieżącego Typeelementu . (Odziedziczone po Type)
GetProperties()	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetProperty(String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetProperty(String, Type, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetProperty(String, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
GetRequiredCustomModifiers()	Po przesłonięciu w klasie pochodnej zwraca wymagane modyfikatory niestandardowe bieżącego Typeelementu . (Odziedziczone po Type)
GetType()	Pobiera bieżący Typeelement . (Odziedziczone po Type)
GetTypeCodeImpl()	Zwraca podstawowy kod typu tego Type wystąpienia. (Odziedziczone po Type)
HasElementTypeImpl()	Podczas zastępowania w klasie pochodnej implementuje HasElementType właściwość i określa, czy bieżący Type obejmuje lub odwołuje się do innego typu; oznacza to, czy bieżący Type jest tablicą, wskaźnikiem, czy jest przekazywany przez odwołanie.
HasSameMetadataDefinitionAs(MemberInfo)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (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 dopasowania do 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 dopasowania 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 IsArray właściwość i określa, czy Type jest tablicą.
IsAssignableFrom(Type)	Zgłasza NotSupportedException wyjątek we wszystkich przypadkach.
IsAssignableFrom(TypeInfo)	Zgłasza NotSupportedException wyjątek we wszystkich przypadkach.
IsAssignableTo(Type)	Określa, czy bieżący typ można przypisać do zmiennej określonego targetType. (Odziedziczone po Type)
IsByRefImpl()	Podczas zastępowania w klasie pochodnej implementuje IsByRef właściwość i określa, czy Type element jest przekazywany przez odwołanie.
IsCOMObjectImpl()	Podczas zastępowania w klasie pochodnej implementuje IsCOMObject właściwość i określa, czy Type obiekt COM jest obiektem COM.
IsContextfulImpl()	Implementuje IsContextful właściwość i określa, czy Type obiekt może być hostowany 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. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsEquivalentTo(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsInstanceOfType(Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona. (Odziedziczone po TypeInfo)
IsMarshalByRefImpl()	Implementuje IsMarshalByRef właściwość i określa, czy obiekt Type jest marshaledowany przez odwołanie. (Odziedziczone po Type)
IsPointerImpl()	Podczas zastępowania w klasie pochodnej implementuje IsPointer właściwość i określa, czy Type element jest wskaźnikiem.
IsPrimitiveImpl()	Podczas zastępowania w klasie pochodnej implementuje IsPrimitive właściwość i określa, czy Type jest to jeden z typów pierwotnych.
IsSubclassOf(Type)	Nieobsługiwane w przypadku niekompletnych parametrów typu ogólnego.
IsValueTypeImpl()	Implementuje IsValueType właściwość i określa, czy Type jest to typ wartości, czyli, a nie klasa lub 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()	Type Zwraca obiekt, który reprezentuje bieżący parametr typu ogólnego po przekazaniu jako parametr odwołania.
MakeGenericType(Type[])	Nieprawidłowy dla niekompletnych parametrów typu ogólnego.
MakePointerType()	Type Zwraca obiekt reprezentujący wskaźnik do bieżącego parametru typu ogólnego.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
SetBaseTypeConstraint(Type)	Ustawia typ podstawowy, który typ musi dziedziczyć w celu zastąpienia parametru typu.
SetBaseTypeConstraintCore(Type)	Po zastąpieniu w klasie pochodnej ustawia typ podstawowy, który typ musi dziedziczyć, aby zastąpić parametr type.
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 przesłonięciu w klasie pochodnej ustawia właściwości wariancji i specjalne ograniczenia parametru ogólnego, takie jak ograniczenie konstruktora bez parametrów.
SetInterfaceConstraints(Type[])	Ustawia interfejsy typu musi implementować w celu zastąpienia parametru type.
SetInterfaceConstraintsCore(Type[])	Po przesłonięciu w klasie pochodnej ustawia interfejsy, które typ musi implementować, 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 TypeInfo obiektu. (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 i, opcjonalnie, stosowane do jego elementów nadrzędnych.
GetTypeInfo(Type)	Zwraca reprezentację TypeInfo 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. Klasa ta nie może być dziedziczona.
GetConstructors(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetConstructors(Type, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetFields(Type, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetGenericArguments(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetInterfaces(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetMember(Type, String)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetMember(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetMembers(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetMethods(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetNestedType(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetProperties(Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetProperties(Type, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetProperty(Type, String, BindingFlags)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetProperty(Type, String, Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
GetProperty(Type, String, Type, Type[])	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
IsAssignableFrom(Type, Type)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.
IsInstanceOfType(Type, Object)	Definiuje i tworzy ogólne parametry typu dla dynamicznie zdefiniowanych typów ogólnych i metod. Klasa ta nie może być dziedziczona.

Zobacz też

• DefineGenericParameters(String[])
• Instrukcje: Definiowanie typu ogólnego przy użyciu emisji odbicia