GenericTypeParameterBuilder Classe

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Origem:

GenericTypeParameterBuilder.cs

Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.

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

Herança

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Exemplos

O exemplo de código a seguir cria um tipo genérico com dois parâmetros de tipo e os salva no assembly GenericEmitExample1.dll. Você pode usar o Ildasm.exe (IL Disassembler) para exibir os tipos gerados. Para obter uma explicação mais detalhada das etapas envolvidas na definição de um tipo genérico dinâmico, consulte Como definir um tipo genérico com a emissão de reflexão.

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

Comentários

Você pode obter uma matriz de GenericTypeParameterBuilder objetos usando o TypeBuilder.DefineGenericParameters método para adicionar parâmetros de tipo a um tipo dinâmico, tornando-o um tipo genérico ou usando o MethodBuilder.DefineGenericParameters método para adicionar parâmetros de tipo a um método dinâmico. Use os GenericTypeParameterBuilder objetos para adicionar restrições aos parâmetros de tipo. As restrições são de três tipos:

• A restrição de tipo base especifica que qualquer tipo atribuído ao parâmetro de tipo genérico deve derivar de um tipo base específico. Defina essa restrição usando o SetBaseTypeConstraint método .

• Uma restrição de interface especifica que qualquer tipo atribuído ao parâmetro de tipo genérico deve implementar uma interface específica. Defina as restrições de interface usando o SetInterfaceConstraints método .

• Restrições especiais especificam que qualquer tipo atribuído ao parâmetro de tipo genérico deve ter um construtor sem parâmetros, deve ser um tipo de referência ou deve ser um tipo de valor. Defina as restrições especiais para um parâmetro de tipo usando o SetGenericParameterAttributes método .

Restrições de interface e restrições especiais não podem ser recuperadas usando métodos da GenericTypeParameterBuilder classe . Depois de criar o tipo genérico que contém os parâmetros de tipo, você pode usar seu Type objeto para refletir as restrições. Use o Type.GetGenericArguments método para obter os parâmetros de tipo e, para cada parâmetro de tipo, use o Type.GetGenericParameterConstraints método para obter a restrição de tipo base e as restrições de interface e a Type.GenericParameterAttributes propriedade para obter as restrições especiais.

Construtores

GenericTypeParameterBuilder()

Inicializa uma nova instância da classe GenericTypeParameterBuilder.

Propriedades

Assembly	Obtém um objeto Assembly que representa o assembly dinâmico que contém a definição de tipo genérico à qual o parâmetro de tipo atual pertence.
AssemblyQualifiedName	Obtém null em todos os casos.
Attributes	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
BaseType	Obtém a restrição de tipo base do parâmetro de tipo genérico atual.
ContainsGenericParameters	Obtém true em todos os casos.
CustomAttributes	Obtém uma coleção que contém os atributos personalizados desse membro. (Herdado de MemberInfo)
DeclaredConstructors	Obtém uma coleção dos construtores declarados pelo tipo atual. (Herdado de TypeInfo)
DeclaredEvents	Obtém uma coleção de eventos definidos pelo tipo atual. (Herdado de TypeInfo)
DeclaredFields	Obtém uma coleção dos campos definidos pelo tipo atual. (Herdado de TypeInfo)
DeclaredMembers	Obtém uma coleção de membros definidos pelo tipo atual. (Herdado de TypeInfo)
DeclaredMethods	Obtém uma coleção dos métodos definidos pelo tipo atual. (Herdado de TypeInfo)
DeclaredNestedTypes	Obtém uma coleção dos tipos aninhados definidos pelo tipo atual. (Herdado de TypeInfo)
DeclaredProperties	Obtém uma coleção de propriedades definidas pelo tipo atual. (Herdado de TypeInfo)
DeclaringMethod	Obtém um MethodInfo que representa o método declarativo, se o GenericTypeParameterBuilder atual representa um parâmetro de tipo de um método genérico.
DeclaringType	Obtém a definição de tipo genérico ou definição de método genérico à qual o parâmetro de tipo genérico pertence.
FullName	Obtém null em todos os casos.
GenericParameterAttributes	Obtém uma combinação de GenericParameterAttributes sinalizadores que descrevem a covariância e restrições especiais do parâmetro de tipo genérico atual.
GenericParameterPosition	Obtém a posição do parâmetro de tipo na lista de parâmetros de tipo do método ou tipo genérico que declarou o parâmetro.
GenericTypeArguments	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GenericTypeParameters	Obtém uma matriz dos parâmetros de tipo genérico da instância atual. (Herdado de TypeInfo)
GUID	Sem suporte para parâmetros de tipo genérico incompletos.
HasElementType	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
ImplementedInterfaces	Obtém uma coleção das interfaces implementadas pelo tipo atual. (Herdado de TypeInfo)
IsAbstract	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsAnsiClass	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsArray	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsAutoClass	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsAutoLayout	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsByRef	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsByRefLike	Obtém um valor que indica se o tipo é uma estrutura de tipo ByRef.
IsClass	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsCollectible	Obtém um valor que indica se este objeto MemberInfo faz parte de um assembly mantido em uma coleção AssemblyLoadContext. (Herdado de MemberInfo)
IsCOMObject	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsConstructedGenericType	Obtém um valor que indica se este objeto representa um tipo genérico construído.
IsContextful	Obtém um valor que indica se o Type pode ser hospedado em um contexto. (Herdado de Type)
IsEnum	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsExplicitLayout	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsFunctionPointer	Obtém um valor que indica se o atual Type é um ponteiro de função. (Herdado de Type)
IsGenericMethodParameter	Obtém um valor que indica se o Type atual representa um parâmetro na definição de um método genérico. (Herdado de Type)
IsGenericParameter	Obtém true em todos os casos.
IsGenericType	Retorna false em todos os casos.
IsGenericTypeDefinition	Obtém false em todos os casos.
IsGenericTypeParameter	Obtém um valor que indica se o Type atual representa um parâmetro de tipo na definição de um tipo genérico. (Herdado de Type)
IsImport	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsInterface	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsLayoutSequential	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsMarshalByRef	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNested	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNestedAssembly	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNestedFamANDAssem	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNestedFamily	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNestedFamORAssem	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNestedPrivate	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNestedPublic	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsNotPublic	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsPointer	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsPrimitive	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsPublic	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsSealed	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsSecurityCritical	Obtém um valor que indica se o tipo atual é crítico para segurança ou crítico para segurança e disponível no código transparente no nível de confiança atual e, portanto, pode realizar operações críticas. (Herdado de Type)
IsSecuritySafeCritical	Obtém um valor que indica se o tipo é crítico para segurança e disponível no código transparente no nível de confiança atual, ou seja, se ele pode realizar operações críticas e ser acessado por código transparente. (Herdado de Type)
IsSecurityTransparent	Obtém um valor que indica que se o tipo atual é transparente no nível de confiança atual e, portanto, não pode realizar operações críticas. (Herdado de Type)
IsSerializable	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsSignatureType	Obtém um valor que indica se o tipo é um tipo de assinatura. (Herdado de Type)
IsSpecialName	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsSZArray	Obtém um valor que indica se o tipo é um tipo de matriz que pode representar apenas uma única matriz unidimensional com um limite inferior a zero.
IsTypeDefinition	Obtém um valor que indica se o tipo é uma definição de tipo.
IsUnicodeClass	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsUnmanagedFunctionPointer	Obtém um valor que indica se o atual Type é um ponteiro de função não gerenciado. (Herdado de Type)
IsValueType	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsVariableBoundArray	Obtém um valor que indica se o tipo é um tipo de matriz que pode representar uma matriz multidimensional ou uma matriz com um limite inferior arbitrário. (Herdado de Type)
IsVisible	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
MemberType	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
MetadataToken	Obtém um token que identifica o módulo dinâmico atual nos metadados.
Module	Obtém o módulo dinâmico que contém o parâmetro de tipo genérico.
Name	Obtém o nome do parâmetro de tipo genérico.
Namespace	Obtém null em todos os casos.
ReflectedType	Obtém o objeto Type que foi usado para obter o GenericTypeParameterBuilder.
StructLayoutAttribute	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
TypeHandle	Sem suporte para parâmetros de tipo genérico incompletos.
TypeInitializer	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
UnderlyingSystemType	Obtém o parâmetro de tipo genérico atual.

Métodos

AsType()	Retorna o tipo atual como um objeto Type. (Herdado de TypeInfo)
Equals(Object)	Testa se o objeto fornecido é uma instância de EventToken e é igual à instância atual.
Equals(Type)	Determina se o tipo de sistema subjacente do Type atual é o mesmo que o tipo de sistema subjacente do Type especificado. (Herdado de Type)
FindInterfaces(TypeFilter, Object)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetArrayRank()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetAttributeFlagsImpl()	Quando substituído em uma classe derivada, implementa a propriedade Attributes e obtém uma combinação bit a bit dos valores de enumeração que indicam os atributos associados ao Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Pesquisa por um construtor cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada. (Herdado de Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Pesquisa o construtor cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas. (Herdado de Type)
GetConstructor(BindingFlags, Type[])	Pesquisa um construtor cujos parâmetros correspondem aos tipos de argumento especificados, usando as restrições de associação especificadas. (Herdado de Type)
GetConstructor(Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Sem suporte para parâmetros de tipo genérico incompletos.
GetConstructors()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetConstructors(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetCustomAttributes(Boolean)	Sem suporte para parâmetros de tipo genérico incompletos.
GetCustomAttributes(Type, Boolean)	Sem suporte para parâmetros de tipo genérico incompletos.
GetCustomAttributesData()	Retorna uma lista de objetos CustomAttributeData que representam dados sobre os atributos que foram aplicados ao membro de destino. (Herdado de MemberInfo)
GetDeclaredEvent(String)	Retorna um objeto que representa o evento especificado declarado pelo tipo atual. (Herdado de TypeInfo)
GetDeclaredField(String)	Retorna um objeto que representa o campo especificado declarado pelo tipo atual. (Herdado de TypeInfo)
GetDeclaredMethod(String)	Retorna um objeto que representa o método especificado declarado pelo tipo atual. (Herdado de TypeInfo)
GetDeclaredMethods(String)	Retorna uma coleção que contém todos os métodos declarados no tipo atual que correspondem ao nome especificado. (Herdado de TypeInfo)
GetDeclaredNestedType(String)	Retorna um objeto que representa o tipo aninhado especificado declarado pelo tipo atual. (Herdado de TypeInfo)
GetDeclaredProperty(String)	Retorna um objeto que representa a propriedade especificada declarada pelo tipo atual. (Herdado de TypeInfo)
GetDefaultMembers()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetElementType()	Gera um NotSupportedException em todos os casos.
GetEnumName(Object)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetEnumNames()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetEnumUnderlyingType()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetEnumValues()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetEnumValuesAsUnderlyingType()	Recupera uma matriz dos valores das constantes de tipo subjacentes desse tipo de enumeração. (Herdado de Type)
GetEvent(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetEvent(String, BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetEvents()	Sem suporte para parâmetros de tipo genérico incompletos.
GetEvents(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetField(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetField(String, BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetFields()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetFields(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetFunctionPointerCallingConventions()	Quando substituído em uma classe derivada, retorna as convenções de chamada do ponteiro Typede função atual . (Herdado de Type)
GetFunctionPointerParameterTypes()	Quando substituído em uma classe derivada, retorna os tipos de parâmetro do ponteiro Typede função atual . (Herdado de Type)
GetFunctionPointerReturnType()	Quando substituído em uma classe derivada, retorna o tipo de retorno do ponteiro Typede função atual . (Herdado de Type)
GetGenericArguments()	Não é válido para parâmetros de tipo genérico.
GetGenericParameterConstraints()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetGenericTypeDefinition()	Não é válido para parâmetros de tipo genérico.
GetHashCode()	Retorna um código hash de inteiro de 32 bits para a instância atual.
GetInterface(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetInterface(String, Boolean)	Sem suporte para parâmetros de tipo genérico incompletos.
GetInterfaceMap(Type)	Sem suporte para parâmetros de tipo genérico incompletos.
GetInterfaces()	Sem suporte para parâmetros de tipo genérico incompletos.
GetMember(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMember(String, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetMembers()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMembers(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Pesquisa o MemberInfo no atual Type que corresponde ao especificado MemberInfo. (Herdado de Type)
GetMethod(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMethod(String, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Pesquisa o método especificado cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada. (Herdado de Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Pesquisa o método especificado cujos parâmetros correspondem aos tipos de argumento e modificadores especificados, usando as restrições de associação especificadas. (Herdado de Type)
GetMethod(String, BindingFlags, Type[])	Pesquisa o método especificado cujos parâmetros correspondem aos tipos de argumento especificados, usando as restrições de associação especificadas. (Herdado de Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Pesquisa o método especificado cujos parâmetros correspondem à contagem de parâmetros genéricos, aos tipos de argumento e aos modificadores, usando as restrições de associação especificadas e a convenção de chamada especificada. (Herdado de Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Pesquisa pelo método especificado cujos parâmetros correspondem à contagem de parâmetros genéricos especificada, aos tipos de argumento e aos modificadores, usando as restrições de associação especificadas. (Herdado de Type)
GetMethod(String, Int32, BindingFlags, Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de Type)
GetMethod(String, Int32, Type[])	Pesquisa o método público especificado cujos parâmetros correspondem à contagem de parâmetros genéricos e aos tipos de argumento especificados. (Herdado de Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Pesquisa o método público especificado cujos parâmetros correspondem à contagem de parâmetros genéricos, aos tipos de argumento especificados e aos modificadores. (Herdado de Type)
GetMethod(String, Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Sem suporte para parâmetros de tipo genérico incompletos.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Quando substituído em uma classe derivada, pesquisa o método especificado, cujos parâmetros correspondem à contagem de parâmetros genéricos, aos tipos de argumento e aos modificadores especificados, usando as restrições de associação especificadas e a convenção de chamada especificada. (Herdado de Type)
GetMethods()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetMethods(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetNestedType(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetNestedType(String, BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetNestedTypes()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetNestedTypes(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetOptionalCustomModifiers()	Quando substituído em uma classe derivada, retorna os modificadores personalizados opcionais do atual Type. (Herdado de Type)
GetProperties()	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetProperties(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetProperty(String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetProperty(String, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Pesquisa a propriedade especificada cujos parâmetros correspondem aos modificadores e tipos de argumento especificados, usando as restrições de associação especificadas. (Herdado de Type)
GetProperty(String, Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetProperty(String, Type, Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetProperty(String, Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Sem suporte para parâmetros de tipo genérico incompletos.
GetRequiredCustomModifiers()	Quando substituído em uma classe derivada, retorna os modificadores personalizados necessários do atual Type. (Herdado de Type)
GetType()	Obtém o Type atual. (Herdado de Type)
GetTypeCodeImpl()	Retorna o código de tipo subjacente desta instância Type. (Herdado de Type)
HasElementTypeImpl()	Quando substituído em uma classe derivada, implementa a propriedade HasElementType e determina se o Type atual abrange ou se refere a outro tipo, ou seja, se o Type atual é uma matriz, um ponteiro ou é passado por referência.
HasSameMetadataDefinitionAs(MemberInfo)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos especificada. (Herdado de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos e cultura especificadas. (Herdado de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Sem suporte para parâmetros de tipo genérico incompletos.
IsArrayImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsArray e determina se o Type é uma matriz.
IsAssignableFrom(Type)	Gera uma exceção NotSupportedException em todos os casos.
IsAssignableFrom(TypeInfo)	Gera uma exceção NotSupportedException em todos os casos.
IsAssignableTo(Type)	Determina se o tipo atual pode ser atribuído a uma variável do targetType especificado. (Herdado de Type)
IsByRefImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsByRef e determina se o Type é passado por referência.
IsCOMObjectImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsCOMObject e determina se o Type é um objeto COM.
IsContextfulImpl()	Implementa a propriedade IsContextful e determina se o Type pode ser hospedado em um contexto. (Herdado de Type)
IsDefined(Type, Boolean)	Sem suporte para parâmetros de tipo genérico incompletos.
IsEnumDefined(Object)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsEquivalentTo(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsInstanceOfType(Object)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada. (Herdado de TypeInfo)
IsMarshalByRefImpl()	Implementa a propriedade IsMarshalByRef e determina se é realizado marshal no Type por referência. (Herdado de Type)
IsPointerImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsPointer e determina se o Type é um ponteiro.
IsPrimitiveImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsPrimitive e determina se o Type é um dos tipos primitivos.
IsSubclassOf(Type)	Sem suporte para parâmetros de tipo genérico incompletos.
IsValueTypeImpl()	Implementa a propriedade IsValueType e determina se o Type é um tipo de valor, ou seja, não é uma classe nem uma interface.
MakeArrayType()	Retorna o tipo de uma matriz unidimensional cujo tipo de elemento é o parâmetro de tipo genérico.
MakeArrayType(Int32)	Retorna o tipo de uma matriz cujo tipo de elemento é o parâmetro de tipo genérico, com o número de dimensões especificado.
MakeByRefType()	Retorna um objeto Type que representa o parâmetro de tipo genérico atual quando passado como um parâmetro de referência.
MakeGenericType(Type[])	Não é válido para parâmetros de tipo genérico incompletos.
MakePointerType()	Retorna um objeto Type que representa um ponteiro para o parâmetro de tipo genérico atual.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
SetBaseTypeConstraint(Type)	Define o tipo base que um tipo deve herdar para ser substituído pelo parâmetro de tipo.
SetBaseTypeConstraintCore(Type)	Quando substituído em uma classe derivada, define o tipo base que um tipo deve herdar para ser substituído pelo parâmetro de tipo.
SetCustomAttribute(ConstructorInfo, Byte[])	Define um atributo personalizado usando um blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Defina um atributo personalizado usando um construtor de atributos personalizados.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, define um atributo personalizado neste assembly.
SetGenericParameterAttributes(GenericParameterAttributes)	Define as características de variação e restrições especiais do parâmetro genérico, tais como a restrição de construtor sem parâmetros.
SetGenericParameterAttributesCore(GenericParameterAttributes)	Quando substituído em uma classe derivada, define as características de variação e restrições especiais do parâmetro genérico, como a restrição de construtor sem parâmetros.
SetInterfaceConstraints(Type[])	Define as interfaces que um tipo deve implementar para ser substituído pelo parâmetro de tipo.
SetInterfaceConstraintsCore(Type[])	Quando substituído em uma classe derivada, define as interfaces que um tipo deve implementar para ser substituído pelo parâmetro de tipo.
ToString()	Retorna uma representação de cadeia de caracteres do parâmetro de tipo genérico atual.

Implantações explícitas de interface

IReflectableType.GetTypeInfo()

Retorna uma representação do tipo atual como um objeto TypeInfo. (Herdado de TypeInfo)

Métodos de Extensão

GetCustomAttribute(MemberInfo, Type)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.
GetCustomAttribute(MemberInfo, Type, Boolean)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttribute<T>(MemberInfo)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado.
GetCustomAttribute<T>(MemberInfo, Boolean)	Recupera um atributo personalizado de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes(MemberInfo)	Recupera uma coleção de atributos personalizados que são aplicados a um membro especificado.
GetCustomAttributes(MemberInfo, Boolean)	Recupera uma coleção de atributos personalizados aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes(MemberInfo, Type)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.
GetCustomAttributes(MemberInfo, Type, Boolean)	Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
GetCustomAttributes<T>(MemberInfo)	Recupera uma coleção de atributos personalizados de um tipo especificado que são aplicados a um membro especificado.
GetCustomAttributes<T>(MemberInfo, Boolean)	Recupera uma coleção de atributos personalizados de um tipo especificado aplicado a um membro especificado e opcionalmente inspeciona os ancestrais desse membro.
IsDefined(MemberInfo, Type)	Indica se os atributos personalizados de um tipo especificados são aplicados a um membro especificado.
IsDefined(MemberInfo, Type, Boolean)	Indica se os atributos personalizados de um tipo especificado são aplicados a um membro especificado e, opcionalmente, aplicados a seus ancestrais.
GetTypeInfo(Type)	Retorna a representação de TypeInfo do tipo especificado.
GetMetadataToken(MemberInfo)	Obtém um token de metadados para o membro fornecido, se disponível.
HasMetadataToken(MemberInfo)	Retorna um valor que indica se um token de metadados está disponível para o membro especificado.
GetRuntimeEvent(Type, String)	Recupera um objeto que representa o evento especificado.
GetRuntimeEvents(Type)	Recupera uma coleção que representa todos os eventos definidos em um tipo especificado.
GetRuntimeField(Type, String)	Recupera um objeto que representa um campo especificado.
GetRuntimeFields(Type)	Recupera uma coleção que representa todos os campos definidos em um tipo especificado.
GetRuntimeInterfaceMap(TypeInfo, Type)	Retorna um mapeamento de interface para o tipo e para a interface especificados.
GetRuntimeMethod(Type, String, Type[])	Recupera um objeto que representa um método especificado.
GetRuntimeMethods(Type)	Recupera uma coleção que representa todos os métodos definidos em um tipo especificado.
GetRuntimeProperties(Type)	Recupera uma coleção que representa todas as propriedades definidas em um tipo especificado.
GetRuntimeProperty(Type, String)	Recupera um objeto que representa uma propriedade especificada.
GetConstructor(Type, Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetConstructors(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetConstructors(Type, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetFields(Type, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetGenericArguments(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetInterfaces(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetMember(Type, String)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetMember(Type, String, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetMembers(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetMethods(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetNestedType(Type, String, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetProperties(Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetProperties(Type, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetProperty(Type, String, BindingFlags)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetProperty(Type, String, Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
GetProperty(Type, String, Type, Type[])	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
IsAssignableFrom(Type, Type)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.
IsInstanceOfType(Type, Object)	Define e cria parâmetros de tipo genérico para métodos e tipos genéricos definidos dinamicamente. Essa classe não pode ser herdada.

Confira também

• DefineGenericParameters(String[])
• Como: Definir um tipo genérico com a emissão de reflexão