GenericTypeParameterBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

System.Reflection.Emit.dll

Zdroj:

GenericTypeParameterBuilder.cs

Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.

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

Dědičnost

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Příklady

Následující příklad kódu vytvoří obecný typ se dvěma parametry typu a uloží je do sestavení GenericEmitExample1.dll. K zobrazení vygenerovaných typů můžete použít Ildasm.exe (IL Disassembler). Podrobnější vysvětlení kroků, které jsou součástí definování dynamického obecného typu, najdete v tématu Postupy: Definování obecného typu pomocí generování reflexe.

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

Poznámky

Pole GenericTypeParameterBuilder objektů můžete získat tak, že pomocí TypeBuilder.DefineGenericParameters metody přidáte parametry typu k dynamickému typu, čímž z něj uděláte obecný typ, nebo pomocí MethodBuilder.DefineGenericParameters metody pro přidání parametrů typu do dynamické metody. GenericTypeParameterBuilder Pomocí objektů přidejte omezení k parametrům typu. Omezení jsou tří druhů:

• Omezení základního typu určuje, že každý typ přiřazený parametru obecného typu musí být odvozen od konkrétního základního typu. Nastavte toto omezení pomocí SetBaseTypeConstraint metody .

• Omezení rozhraní určuje, že každý typ přiřazený parametru obecného typu musí implementovat konkrétní rozhraní. Nastavte omezení rozhraní pomocí SetInterfaceConstraints metody .

• Zvláštní omezení určují, že jakýkoli typ přiřazený parametru obecného typu musí mít konstruktor bez parametrů, musí být odkazovým typem nebo musí být hodnotovým typem. Nastavte speciální omezení pro parametr typu pomocí SetGenericParameterAttributes metody .

Omezení rozhraní a speciální omezení nelze načíst pomocí metod GenericTypeParameterBuilder třídy . Jakmile vytvoříte obecný typ, který obsahuje parametry typu, můžete použít jeho Type objekt k vyjádření omezení. Type.GetGenericArguments Pomocí metody získejte parametry typu a pro každý parametr typu použijte metodu Type.GetGenericParameterConstraints k získání omezení základního typu a omezení rozhraní a Type.GenericParameterAttributes vlastnost pro získání speciálních omezení.

Konstruktory

GenericTypeParameterBuilder()

Inicializuje novou instanci GenericTypeParameterBuilder třídy.

Vlastnosti

Assembly	Assembly Získá objekt představující dynamické sestavení, které obsahuje obecné definice typu aktuální typ parametru patří.
AssemblyQualifiedName	Získá null ve všech případech.
Attributes	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
BaseType	Získá omezení základního typu aktuálního parametru obecného typu.
ContainsGenericParameters	Získá true ve všech případech.
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo)
DeclaredConstructors	Získá kolekci konstruktorů deklarovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredEvents	Získá kolekci událostí definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredFields	Získá kolekci polí definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredMembers	Získá kolekci členů definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredMethods	Získá kolekci metod definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredNestedTypes	Získá kolekci vnořených typů definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredProperties	Získá kolekci vlastností definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaringMethod	Získá objekt MethodInfo , který představuje deklarující metodu, pokud aktuální GenericTypeParameterBuilder představuje typ parametru obecné metody.
DeclaringType	Získá definici obecného typu nebo definici obecné metody, do které patří parametr obecného typu.
FullName	Získá null ve všech případech.
GenericParameterAttributes	Získá kombinaci GenericParameterAttributes příznaků, které popisují kovarianci a speciální omezení aktuálního obecného typu parametru.
GenericParameterPosition	Získá pozici parametru typu v seznamu parametrů typu obecného typu nebo metody, která deklarovala parametr.
GenericTypeArguments	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GenericTypeParameters	Získá pole parametrů obecného typu aktuální instance. (Zděděno od TypeInfo)
GUID	Nepodporuje se pro neúplné parametry obecného typu.
HasElementType	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
ImplementedInterfaces	Získá kolekci rozhraní implementovaných aktuálním typem. (Zděděno od TypeInfo)
IsAbstract	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsAnsiClass	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsArray	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsAutoClass	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsAutoLayout	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsByRef	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsByRefLike	Získá hodnotu, která označuje, zda typ je byref-like struktury.
IsClass	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsCollectible	Získá hodnotu, která označuje, zda je tento MemberInfo objekt součástí sestavení uchovávaného v collectible AssemblyLoadContext. (Zděděno od MemberInfo)
IsCOMObject	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsConstructedGenericType	Získá hodnotu, která označuje, zda tento objekt představuje vytvořený obecný typ.
IsContextful	Získá hodnotu označující, zda Type lze hostovat v kontextu. (Zděděno od Type)
IsEnum	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsExplicitLayout	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsFunctionPointer	Získá hodnotu, která označuje, zda Type aktuální je ukazatel funkce. (Zděděno od Type)
IsGenericMethodParameter	Získá hodnotu, která označuje, zda aktuální Type představuje parametr typu v definici obecné metody. (Zděděno od Type)
IsGenericParameter	Získá true ve všech případech.
IsGenericType	Vrátí false se ve všech případech.
IsGenericTypeDefinition	Získá false ve všech případech.
IsGenericTypeParameter	Získá hodnotu, která označuje, zda aktuální Type představuje parametr typu v definici obecného typu. (Zděděno od Type)
IsImport	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsInterface	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsLayoutSequential	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsMarshalByRef	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNested	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNestedAssembly	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNestedFamANDAssem	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNestedFamily	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNestedFamORAssem	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNestedPrivate	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNestedPublic	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsNotPublic	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsPointer	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsPrimitive	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsPublic	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsSealed	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsSecurityCritical	Získá hodnotu, která označuje, zda aktuální typ je kritický zabezpečení nebo zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti, a proto může provádět kritické operace. (Zděděno od Type)
IsSecuritySafeCritical	Získá hodnotu, která označuje, zda aktuální typ je zabezpečení-kritický na aktuální úroveň důvěryhodnosti; to znamená, zda může provádět kritické operace a může být přístupný transparentním kódem. (Zděděno od Type)
IsSecurityTransparent	Získá hodnotu, která označuje, zda aktuální typ je transparentní na aktuální úrovni důvěryhodnosti, a proto nelze provádět kritické operace. (Zděděno od Type)
IsSerializable	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsSignatureType	Získá hodnotu, která označuje, zda typ je typ podpisu. (Zděděno od Type)
IsSpecialName	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsSZArray	Získá hodnotu, která označuje, zda typ je typ pole, který může představovat pouze jednorozměrné pole s nulovou dolní mez.
IsTypeDefinition	Získá hodnotu, která označuje, zda typ je definice typu.
IsUnicodeClass	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsUnmanagedFunctionPointer	Získá hodnotu, která označuje, zda Type aktuální je nespravovaný ukazatel funkce. (Zděděno od Type)
IsValueType	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsVariableBoundArray	Získá hodnotu, která označuje, zda typ je typ pole, který může představovat vícerozměrné pole nebo pole s libovolnou dolní mez. (Zděděno od Type)
IsVisible	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
MemberType	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
Module	Získá dynamický modul, který obsahuje parametr obecného typu.
Name	Získá název parametru obecného typu.
Namespace	Získá null ve všech případech.
ReflectedType	Type Získá objekt, který byl použit k získání .GenericTypeParameterBuilder
StructLayoutAttribute	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
TypeHandle	Nepodporuje se pro neúplné parametry obecného typu.
TypeInitializer	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
UnderlyingSystemType	Získá aktuální parametr obecného typu.

Metody

AsType()	Vrátí aktuální typ jako Type objekt. (Zděděno od TypeInfo)
Equals(Object)	Testuje, zda daný objekt je instancí EventToken a je roven aktuální instanci.
Equals(Type)	Určuje, zda je typ základního systému aktuálního Type systému stejný jako typ základního systému zadaného Type. (Zděděno od Type)
FindInterfaces(TypeFilter, Object)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetArrayRank()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetAttributeFlagsImpl()	Při přepsání v odvozené třídě implementuje Attributes vlastnost a získá bitové kombinace hodnot výčtu, které označují atributy přidružené k Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání. (Zděděno od Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení. (Zděděno od Type)
GetConstructor(BindingFlags, Type[])	Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů pomocí zadaných vazeb omezení. (Zděděno od Type)
GetConstructor(Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Nepodporuje se pro neúplné parametry obecného typu.
GetConstructors()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetConstructors(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetCustomAttributes(Boolean)	Nepodporuje se pro neúplné parametry obecného typu.
GetCustomAttributes(Type, Boolean)	Nepodporuje se pro neúplné parametry obecného typu.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity na cílového člena. (Zděděno od MemberInfo)
GetDeclaredEvent(String)	Vrátí objekt, který představuje zadanou událost deklarovanou aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredField(String)	Vrátí objekt, který představuje zadané pole deklarované aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredMethod(String)	Vrátí objekt, který představuje zadanou metodu deklarovanou aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredMethods(String)	Vrátí kolekci, která obsahuje všechny metody deklarované u aktuálního typu, které odpovídají zadanému názvu. (Zděděno od TypeInfo)
GetDeclaredNestedType(String)	Vrátí objekt, který představuje zadaný vnořený typ deklarovaný aktuálním typem. (Zděděno od TypeInfo)
GetDeclaredProperty(String)	Vrátí objekt, který představuje zadanou vlastnost deklarovanou aktuálním typem. (Zděděno od TypeInfo)
GetDefaultMembers()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetElementType()	Ve všech případech vyvolá chybu NotSupportedException .
GetEnumName(Object)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetEnumNames()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetEnumUnderlyingType()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetEnumValues()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetEnumValuesAsUnderlyingType()	Načte pole hodnot základních konstant typu tohoto typu výčtu. (Zděděno od Type)
GetEvent(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetEvent(String, BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetEvents()	Nepodporuje se pro neúplné parametry obecného typu.
GetEvents(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetField(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetField(String, BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetFields()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetFields(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetFunctionPointerCallingConventions()	Při přepsání v odvozené třídě vrátí konvence volání aktuálního ukazatele Typena funkci . (Zděděno od Type)
GetFunctionPointerParameterTypes()	Při přepsání v odvozené třídě vrátí typy parametrů aktuálního ukazatele Typena funkci . (Zděděno od Type)
GetFunctionPointerReturnType()	Při přepsání v odvozené třídě vrátí návratový typ aktuálního ukazatele Typena funkci . (Zděděno od Type)
GetGenericArguments()	Neplatí pro parametry obecného typu.
GetGenericParameterConstraints()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetGenericTypeDefinition()	Neplatí pro parametry obecného typu.
GetHashCode()	Vrátí 32bitový celočíselný hashový kód pro aktuální instanci.
GetInterface(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetInterface(String, Boolean)	Nepodporuje se pro neúplné parametry obecného typu.
GetInterfaceMap(Type)	Nepodporuje se pro neúplné parametry obecného typu.
GetInterfaces()	Nepodporuje se pro neúplné parametry obecného typu.
GetMember(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMember(String, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetMembers()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMembers(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Vyhledá u MemberInfo aktuálního Type , který odpovídá zadané MemberInfohodnotě . (Zděděno od Type)
GetMethod(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMethod(String, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání. (Zděděno od Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení. (Zděděno od Type)
GetMethod(String, BindingFlags, Type[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů, pomocí zadaných vazeb omezení. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných vazebních omezení. (Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od Type)
GetMethod(String, Int32, Type[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů. (Zděděno od Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům. (Zděděno od Type)
GetMethod(String, Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Nepodporuje se pro neúplné parametry obecného typu.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Při přepsání v odvozené třídě vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání. (Zděděno od Type)
GetMethods()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetMethods(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetNestedType(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetNestedType(String, BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetNestedTypes()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetNestedTypes(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetOptionalCustomModifiers()	Při přepsání v odvozené třídě vrátí volitelné vlastní modifikátory aktuálního Type. (Zděděno od Type)
GetProperties()	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetProperties(BindingFlags)	Nepodporuje se pro neúplné parametry obecného typu.
GetProperty(String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetProperty(String, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Vyhledá zadanou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení. (Zděděno od Type)
GetProperty(String, Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetProperty(String, Type, Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetProperty(String, Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Nepodporuje se pro neúplné parametry obecného typu.
GetRequiredCustomModifiers()	Při přepsání v odvozené třídě vrátí požadované vlastní modifikátory aktuálního Type. (Zděděno od Type)
GetType()	Získá aktuální Type. (Zděděno od Type)
GetTypeCodeImpl()	Vrátí kód základního typu této Type instance. (Zděděno od Type)
HasElementTypeImpl()	Při přepsání v odvozené třídě implementuje HasElementType vlastnost a určuje, zda proud Type zahrnuje nebo odkazuje na jiný typ; to znamená, zda je proud Type pole, ukazatel, nebo je předán odkazem.
HasSameMetadataDefinitionAs(MemberInfo)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Vyvolá zadaný člen pomocí omezení zadané vazby a odpovídající seznamu zadaných argumentů. (Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Vyvolá zadaný člen pomocí zadaných vazeb omezení a odpovídající zadanému seznamu argumentů a jazykové verzi. (Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Nepodporuje se pro neúplné parametry obecného typu.
IsArrayImpl()	Při přepsání v odvozené třídě implementuje IsArray vlastnost a určuje, zda Type je pole.
IsAssignableFrom(Type)	Ve všech případech vyvolá NotSupportedException výjimku.
IsAssignableFrom(TypeInfo)	Ve všech případech vyvolá NotSupportedException výjimku.
IsAssignableTo(Type)	Určuje, zda lze aktuální typ přiřadit proměnné zadaného targetTypetypu . (Zděděno od Type)
IsByRefImpl()	Při přepsání v odvozené třídě implementuje IsByRef vlastnost a určuje, zda Type je předán odkaz.
IsCOMObjectImpl()	Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt com.
IsContextfulImpl()	Implementuje IsContextful vlastnost a určuje, zda Type lze hostovat v kontextu. (Zděděno od Type)
IsDefined(Type, Boolean)	Nepodporuje se pro neúplné parametry obecného typu.
IsEnumDefined(Object)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsEquivalentTo(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsInstanceOfType(Object)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit. (Zděděno od TypeInfo)
IsMarshalByRefImpl()	Implementuje IsMarshalByRef vlastnost a určuje, zda Type je zařazován odkazem. (Zděděno od Type)
IsPointerImpl()	Při přepsání v odvozené třídě implementuje IsPointer vlastnost a určuje, zda Type je ukazatel.
IsPrimitiveImpl()	Při přepsání v odvozené třídě implementuje IsPrimitive vlastnost a určuje, zda Type je jeden z primitivních typů.
IsSubclassOf(Type)	Nepodporuje se pro neúplné parametry obecného typu.
IsValueTypeImpl()	Implementuje IsValueType vlastnost a určuje, zda Type je typ hodnoty, tj. nikoli třída nebo rozhraní.
MakeArrayType()	Vrátí typ jednorozměrného pole, jehož typ prvku je parametr obecného typu.
MakeArrayType(Int32)	Vrátí typ pole, jehož typ prvku je parametr obecného typu se zadaným počtem dimenzí.
MakeByRefType()	Type Vrátí objekt, který představuje aktuální parametr obecného typu při předání jako referenční parametr.
MakeGenericType(Type[])	Není platné pro neúplné parametry obecného typu.
MakePointerType()	Type Vrátí objekt, který představuje ukazatel na aktuální parametr obecného typu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
SetBaseTypeConstraint(Type)	Nastaví základní typ, který musí typ dědit, aby byl nahrazen parametrem typu.
SetBaseTypeConstraintCore(Type)	Při přepsání v odvozené třídě nastaví základní typ, který musí typ dědit, aby byl nahrazen parametrem typu.
SetCustomAttribute(ConstructorInfo, Byte[])	Nastaví vlastní atribut pomocí zadaného objektu blob vlastního atributu.
SetCustomAttribute(CustomAttributeBuilder)	Nastavte vlastní atribut pomocí vlastního tvůrce atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut v tomto sestavení.
SetGenericParameterAttributes(GenericParameterAttributes)	Nastaví rozptylové charakteristiky a speciální omezení obecného parametru, například omezení konstruktoru bez parametrů.
SetGenericParameterAttributesCore(GenericParameterAttributes)	Při přepsání v odvozené třídě nastaví rozptylové charakteristiky a speciální omezení obecného parametru, jako je omezení konstruktoru bez parametrů.
SetInterfaceConstraints(Type[])	Nastaví rozhraní, která musí typ implementovat, aby byl nahrazen parametrem typu.
SetInterfaceConstraintsCore(Type[])	Při přepsání v odvozené třídě nastaví rozhraní, která musí typ implementovat, aby byl nahrazen parametrem typu.
ToString()	Vrátí řetězcovou reprezentaci aktuálního parametru obecného typu.

Explicitní implementace rozhraní

IReflectableType.GetTypeInfo()

Vrátí reprezentaci aktuálního typu jako objektu TypeInfo . (Zděděno od TypeInfo)

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena.
GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.
GetCustomAttributes(MemberInfo)	Načte kolekci vlastních atributů, které jsou použity na zadaného člena.
GetCustomAttributes(MemberInfo, Boolean)	Načte kolekci vlastních atributů, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena.
GetCustomAttributes(MemberInfo, Type)	Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.
GetCustomAttributes(MemberInfo, Type, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.
GetCustomAttributes<T>(MemberInfo)	Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.
GetCustomAttributes<T>(MemberInfo, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.
IsDefined(MemberInfo, Type)	Určuje, zda jsou na zadaného člena použity vlastní atributy zadaného typu.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaného člena a volitelně se použijí na jeho předky.
GetTypeInfo(Type)	Vrátí reprezentaci TypeInfo zadaného typu.
GetMetadataToken(MemberInfo)	Získá token metadat pro daný člen, pokud je k dispozici.
HasMetadataToken(MemberInfo)	Vrátí hodnotu, která označuje, zda je token metadat k dispozici pro zadaného člena.
GetRuntimeEvent(Type, String)	Načte objekt, který představuje zadanou událost.
GetRuntimeEvents(Type)	Načte kolekci, která představuje všechny události definované na zadaném typu.
GetRuntimeField(Type, String)	Načte objekt, který představuje zadané pole.
GetRuntimeFields(Type)	Načte kolekci, která představuje všechna pole definovaná na zadaném typu.
GetRuntimeInterfaceMap(TypeInfo, Type)	Vrátí mapování rozhraní pro zadaný typ a zadané rozhraní.
GetRuntimeMethod(Type, String, Type[])	Načte objekt, který představuje zadanou metodu.
GetRuntimeMethods(Type)	Načte kolekci, která představuje všechny metody definované na zadaném typu.
GetRuntimeProperties(Type)	Načte kolekci, která představuje všechny vlastnosti definované na zadaném typu.
GetRuntimeProperty(Type, String)	Načte objekt, který představuje zadanou vlastnost.
GetConstructor(Type, Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetConstructors(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetConstructors(Type, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetFields(Type, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetGenericArguments(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetInterfaces(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetMember(Type, String)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetMember(Type, String, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetMembers(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetMethods(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetNestedType(Type, String, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetProperties(Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetProperties(Type, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetProperty(Type, String, BindingFlags)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetProperty(Type, String, Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
GetProperty(Type, String, Type, Type[])	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
IsAssignableFrom(Type, Type)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.
IsInstanceOfType(Type, Object)	Definuje a vytvoří parametry obecného typu pro dynamicky definované obecné typy a metody. Tato třída se nemůže dědit.

Viz také

• DefineGenericParameters(String[])
• Postupy: Definování obecného typu pomocí generování reflexe