GenericTypeParameterBuilder Clase

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

System.Reflection.Emit.dll

Source:

GenericTypeParameterBuilder.cs

Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.

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

Herencia

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Ejemplos

En el ejemplo de código siguiente se crea un tipo genérico con dos parámetros de tipo y se guardan en el ensamblado GenericEmitExample1.dll. Puede usar el Ildasm.exe (desensamblador de IL) para ver los tipos generados. Para obtener una explicación más detallada de los pasos implicados en la definición de un tipo genérico dinámico, vea Cómo: Definir un tipo genérico con emisión de reflexión.

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

Comentarios

Puede obtener una matriz de objetos GenericTypeParameterBuilder mediante el método TypeBuilder.DefineGenericParameters para agregar parámetros de tipo a un tipo dinámico, lo que lo convierte en un tipo genérico o mediante el método MethodBuilder.DefineGenericParameters para agregar parámetros de tipo a un método dinámico. Use los objetos GenericTypeParameterBuilder para agregar restricciones a los parámetros de tipo. Las restricciones son de tres tipos:

• La restricción de tipo base especifica que cualquier tipo asignado al parámetro de tipo genérico debe derivar de un tipo base determinado. Establezca esta restricción mediante el método SetBaseTypeConstraint.

• Una restricción de interfaz especifica que cualquier tipo asignado al parámetro de tipo genérico debe implementar una interfaz determinada. Establezca las restricciones de interfaz mediante el método SetInterfaceConstraints.

• Las restricciones especiales especifican que cualquier tipo asignado al parámetro de tipo genérico debe tener un constructor sin parámetros, debe ser un tipo de referencia o debe ser un tipo de valor. Establezca las restricciones especiales para un parámetro de tipo mediante el método SetGenericParameterAttributes.

Las restricciones de interfaz y las restricciones especiales no se pueden recuperar mediante métodos de la clase GenericTypeParameterBuilder. Una vez creado el tipo genérico que contiene los parámetros de tipo, puede usar su objeto Type para reflejar las restricciones. Use el método Type.GetGenericArguments para obtener los parámetros de tipo y, para cada parámetro de tipo, use el método Type.GetGenericParameterConstraints para obtener la restricción de tipo base y las restricciones de interfaz, y la propiedad Type.GenericParameterAttributes para obtener las restricciones especiales.

Constructores

GenericTypeParameterBuilder()

Inicializa una nueva instancia de GenericTypeParameterBuilder clase.

Propiedades

Assembly	Obtiene un objeto Assembly que representa el ensamblado dinámico que contiene la definición de tipo genérico a la que pertenece el parámetro de tipo actual.
AssemblyQualifiedName	Obtiene null en todos los casos.
Attributes	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
BaseType	Obtiene la restricción de tipo base del parámetro de tipo genérico actual.
ContainsGenericParameters	Obtiene true en todos los casos.
CustomAttributes	Obtiene una colección que contiene los atributos personalizados de este miembro. (Heredado de MemberInfo)
DeclaredConstructors	Obtiene una colección de los constructores declarados por el tipo actual. (Heredado de TypeInfo)
DeclaredEvents	Obtiene una colección de los eventos definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredFields	Obtiene una colección de los campos definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredMembers	Obtiene una colección de los miembros definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredMethods	Obtiene una colección de los métodos definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredNestedTypes	Obtiene una colección de los tipos anidados definidos por el tipo actual. (Heredado de TypeInfo)
DeclaredProperties	Obtiene una colección de las propiedades definidas por el tipo actual. (Heredado de TypeInfo)
DeclaringMethod	Obtiene un MethodInfo que representa el método declarante, si el GenericTypeParameterBuilder actual representa un parámetro de tipo de un método genérico.
DeclaringType	Obtiene la definición de tipo genérico o la definición de método genérico a la que pertenece el parámetro de tipo genérico.
FullName	Obtiene null en todos los casos.
GenericParameterAttributes	Obtiene una combinación de marcas de GenericParameterAttributes que describen la covarianza y las restricciones especiales del parámetro de tipo genérico actual.
GenericParameterPosition	Obtiene la posición del parámetro de tipo en la lista de parámetros de tipo del tipo genérico o método que declaró el parámetro.
GenericTypeArguments	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GenericTypeParameters	Obtiene una matriz de los parámetros de tipo genérico de la instancia actual. (Heredado de TypeInfo)
GUID	No se admite para parámetros de tipo genérico incompletos.
HasElementType	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
ImplementedInterfaces	Obtiene una colección de las interfaces implementadas por el tipo actual. (Heredado de TypeInfo)
IsAbstract	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsAnsiClass	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsArray	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsAutoClass	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsAutoLayout	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsByRef	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsByRefLike	Obtiene un valor que indica si el tipo es una estructura similar a byref.
IsClass	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsCollectible	Obtiene un valor que indica si este objeto MemberInfo forma parte de un ensamblado mantenido en un AssemblyLoadContextrecopilable. (Heredado de MemberInfo)
IsCOMObject	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsConstructedGenericType	Obtiene un valor que indica si este objeto representa un tipo genérico construido.
IsContextful	Obtiene un valor que indica si el Type se puede hospedar en un contexto. (Heredado de Type)
IsEnum	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsExplicitLayout	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsFunctionPointer	Obtiene un valor que indica si el Type actual es un puntero de función. (Heredado de Type)
IsGenericMethodParameter	Obtiene un valor que indica si el Type actual representa un parámetro de tipo en la definición de un método genérico. (Heredado de Type)
IsGenericParameter	Obtiene true en todos los casos.
IsGenericType	Devuelve false en todos los casos.
IsGenericTypeDefinition	Obtiene false en todos los casos.
IsGenericTypeParameter	Obtiene un valor que indica si el Type actual representa un parámetro de tipo en la definición de un tipo genérico. (Heredado de Type)
IsImport	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsInterface	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsLayoutSequential	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsMarshalByRef	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNested	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNestedAssembly	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNestedFamANDAssem	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNestedFamily	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNestedFamORAssem	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNestedPrivate	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNestedPublic	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsNotPublic	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsPointer	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsPrimitive	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsPublic	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsSealed	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsSecurityCritical	Obtiene un valor que indica si el tipo actual es crítico para la seguridad o crítico para la seguridad en el nivel de confianza actual y, por tanto, puede realizar operaciones críticas. (Heredado de Type)
IsSecuritySafeCritical	Obtiene un valor que indica si el tipo actual es crítico para la seguridad en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y se puede acceder a ellas mediante código transparente. (Heredado de Type)
IsSecurityTransparent	Obtiene un valor que indica si el tipo actual es transparente en el nivel de confianza actual y, por tanto, no puede realizar operaciones críticas. (Heredado de Type)
IsSerializable	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsSignatureType	Obtiene un valor que indica si el tipo es un tipo de firma. (Heredado de Type)
IsSpecialName	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsSZArray	Obtiene un valor que indica si el tipo es un tipo de matriz que solo puede representar una matriz unidimensional con un límite inferior cero.
IsTypeDefinition	Obtiene un valor que indica si el tipo es una definición de tipo.
IsUnicodeClass	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsUnmanagedFunctionPointer	Obtiene un valor que indica si el Type actual es un puntero de función no administrado. (Heredado de Type)
IsValueType	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsVariableBoundArray	Obtiene un valor que indica si el tipo es un tipo de matriz que puede representar una matriz multidimensional o una matriz con un límite inferior arbitrario. (Heredado de Type)
IsVisible	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
MemberType	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
MetadataToken	Obtiene un token que identifica el módulo dinámico actual en los metadatos.
Module	Obtiene el módulo dinámico que contiene el parámetro de tipo genérico.
Name	Obtiene el nombre del parámetro de tipo genérico.
Namespace	Obtiene null en todos los casos.
ReflectedType	Obtiene el objeto Type que se usó para obtener el GenericTypeParameterBuilder.
StructLayoutAttribute	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
TypeHandle	No se admite para parámetros de tipo genérico incompletos.
TypeInitializer	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
UnderlyingSystemType	Obtiene el parámetro de tipo genérico actual.

Métodos

AsType()	Devuelve el tipo actual como un objeto Type. (Heredado de TypeInfo)
Equals(Object)	Comprueba si el objeto especificado es una instancia de EventToken y es igual a la instancia actual.
Equals(Type)	Determina si el tipo de sistema subyacente del Type actual es el mismo que el tipo de sistema subyacente del Typeespecificado. (Heredado de Type)
FindInterfaces(TypeFilter, Object)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetArrayRank()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetAttributeFlagsImpl()	Cuando se reemplaza en una clase derivada, implementa la propiedad Attributes y obtiene una combinación bit a bit de valores de enumeración que indican los atributos asociados a la Type.
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, utilizando las restricciones de enlace especificadas y la convención de llamada especificada. (Heredado de Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])	Busca un constructor cuyos parámetros coincidan con los tipos de argumento y modificadores especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetConstructor(BindingFlags, Type[])	Busca un constructor cuyos parámetros coincidan con los tipos de argumento especificados mediante las restricciones de enlace especificadas. (Heredado de Type)
GetConstructor(Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	No se admite para parámetros de tipo genérico incompletos.
GetConstructors()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetConstructors(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetCustomAttributes(Boolean)	No se admite para parámetros de tipo genérico incompletos.
GetCustomAttributes(Type, Boolean)	No se admite para parámetros de tipo genérico incompletos.
GetCustomAttributesData()	Devuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se han aplicado al miembro de destino. (Heredado de MemberInfo)
GetDeclaredEvent(String)	Devuelve un objeto que representa el evento especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredField(String)	Devuelve un objeto que representa el campo especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredMethod(String)	Devuelve un objeto que representa el método especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredMethods(String)	Devuelve una colección que contiene todos los métodos declarados en el tipo actual que coinciden con el nombre especificado. (Heredado de TypeInfo)
GetDeclaredNestedType(String)	Devuelve un objeto que representa el tipo anidado especificado declarado por el tipo actual. (Heredado de TypeInfo)
GetDeclaredProperty(String)	Devuelve un objeto que representa la propiedad especificada declarada por el tipo actual. (Heredado de TypeInfo)
GetDefaultMembers()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetElementType()	Produce un NotSupportedException en todos los casos.
GetEnumName(Object)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetEnumNames()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetEnumUnderlyingType()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetEnumValues()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetEnumValuesAsUnderlyingType()	Recupera una matriz de los valores de las constantes de tipo subyacentes de este tipo de enumeración. (Heredado de Type)
GetEvent(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetEvent(String, BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetEvents()	No se admite para parámetros de tipo genérico incompletos.
GetEvents(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetField(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetField(String, BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetFields()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetFields(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetFunctionPointerCallingConventions()	Cuando se reemplaza en una clase derivada, devuelve las convenciones de llamada del puntero de función actual Type. (Heredado de Type)
GetFunctionPointerParameterTypes()	Cuando se reemplaza en una clase derivada, devuelve los tipos de parámetro del puntero de función actual Type. (Heredado de Type)
GetFunctionPointerReturnType()	Cuando se reemplaza en una clase derivada, devuelve el tipo de valor devuelto del puntero de función actual Type. (Heredado de Type)
GetGenericArguments()	No es válido para los parámetros de tipo genérico.
GetGenericParameterConstraints()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetGenericTypeDefinition()	No es válido para los parámetros de tipo genérico.
GetHashCode()	Devuelve un código hash entero de 32 bits para la instancia actual.
GetInterface(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetInterface(String, Boolean)	No se admite para parámetros de tipo genérico incompletos.
GetInterfaceMap(Type)	No se admite para parámetros de tipo genérico incompletos.
GetInterfaces()	No se admite para parámetros de tipo genérico incompletos.
GetMember(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMember(String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMember(String, MemberTypes, BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetMembers()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMembers(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Busca el MemberInfo en el Type actual que coincide con el MemberInfoespecificado. (Heredado de Type)
GetMethod(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMethod(String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coinciden con los tipos y modificadores de argumento especificados, utilizando las restricciones de enlace especificadas y la convención de llamada especificada. (Heredado de Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coinciden con los tipos de argumento y modificadores especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetMethod(String, BindingFlags, Type[])	Busca el método especificado cuyos parámetros coinciden con los tipos de argumento especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coinciden con el recuento de parámetros genéricos, los tipos de argumento y los modificadores especificados, utilizando las restricciones de enlace especificadas y la convención de llamada especificada. (Heredado de Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])	Busca el método especificado cuyos parámetros coinciden con el recuento de parámetros genéricos, los tipos de argumento y los modificadores especificados mediante las restricciones de enlace especificadas. (Heredado de Type)
GetMethod(String, Int32, BindingFlags, Type[])	Busca el método especificado cuyos parámetros coinciden con el número de parámetros genéricos y los tipos de argumento especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetMethod(String, Int32, Type[])	Busca el método público especificado cuyos parámetros coinciden con el número de parámetros genéricos y los tipos de argumento especificados. (Heredado de Type)
GetMethod(String, Int32, Type[], ParameterModifier[])	Busca el método público especificado cuyos parámetros coinciden con el recuento de parámetros genéricos, los tipos de argumento y los modificadores especificados. (Heredado de Type)
GetMethod(String, Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMethod(String, Type[], ParameterModifier[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	No se admite para parámetros de tipo genérico incompletos.
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Cuando se reemplaza en una clase derivada, busca el método especificado cuyos parámetros coinciden con el recuento de parámetros genéricos, los tipos de argumento y los modificadores especificados, utilizando las restricciones de enlace especificadas y la convención de llamada especificada. (Heredado de Type)
GetMethods()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetMethods(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetNestedType(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetNestedType(String, BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetNestedTypes()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetNestedTypes(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetOptionalCustomModifiers()	Cuando se reemplaza en una clase derivada, devuelve los modificadores personalizados opcionales del Typeactual. (Heredado de Type)
GetProperties()	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetProperties(BindingFlags)	No se admite para parámetros de tipo genérico incompletos.
GetProperty(String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetProperty(String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Busca la propiedad especificada cuyos parámetros coinciden con los tipos de argumento y modificadores especificados, utilizando las restricciones de enlace especificadas. (Heredado de Type)
GetProperty(String, Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetProperty(String, Type, Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetProperty(String, Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	No se admite para parámetros de tipo genérico incompletos.
GetRequiredCustomModifiers()	Cuando se reemplaza en una clase derivada, devuelve los modificadores personalizados necesarios del Typeactual. (Heredado de Type)
GetType()	Obtiene el Typeactual. (Heredado de Type)
GetTypeCodeImpl()	Devuelve el código de tipo subyacente de esta instancia de Type. (Heredado de Type)
HasElementTypeImpl()	Cuando se invalida en una clase derivada, implementa la propiedad HasElementType y determina si el Type actual abarca o hace referencia a otro tipo; es decir, si el Type actual es una matriz, un puntero o se pasa por referencia.
HasSameMetadataDefinitionAs(MemberInfo)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])	Invoca al miembro especificado mediante las restricciones de enlace especificadas y coincide con la lista de argumentos especificada. (Heredado de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Invoca al miembro especificado mediante las restricciones de enlace especificadas y coincide con la lista de argumentos y la referencia cultural especificadas. (Heredado de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	No se admite para parámetros de tipo genérico incompletos.
IsArrayImpl()	Cuando se reemplaza en una clase derivada, implementa la propiedad IsArray y determina si el Type es una matriz.
IsAssignableFrom(Type)	Produce una excepción de NotSupportedException en todos los casos.
IsAssignableFrom(TypeInfo)	Produce una excepción de NotSupportedException en todos los casos.
IsAssignableTo(Type)	Determina si el tipo actual se puede asignar a una variable del targetTypeespecificado. (Heredado de Type)
IsByRefImpl()	Cuando se reemplaza en una clase derivada, implementa la propiedad IsByRef y determina si el Type se pasa por referencia.
IsCOMObjectImpl()	Cuando se reemplaza en una clase derivada, implementa la propiedad IsCOMObject y determina si el Type es un objeto COM.
IsContextfulImpl()	Implementa la propiedad IsContextful y determina si el Type se puede hospedar en un contexto. (Heredado de Type)
IsDefined(Type, Boolean)	No se admite para parámetros de tipo genérico incompletos.
IsEnumDefined(Object)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsEquivalentTo(Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsInstanceOfType(Object)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar. (Heredado de TypeInfo)
IsMarshalByRefImpl()	Implementa la propiedad IsMarshalByRef y determina si el Type se serializa por referencia. (Heredado de Type)
IsPointerImpl()	Cuando se reemplaza en una clase derivada, implementa la propiedad IsPointer y determina si el Type es un puntero.
IsPrimitiveImpl()	Cuando se reemplaza en una clase derivada, implementa la propiedad IsPrimitive y determina si el Type es uno de los tipos primitivos.
IsSubclassOf(Type)	No se admite para parámetros de tipo genérico incompletos.
IsValueTypeImpl()	Implementa la propiedad IsValueType y determina si el Type es un tipo de valor; es decir, no una clase ni una interfaz.
MakeArrayType()	Devuelve el tipo de una matriz unidimensional cuyo tipo de elemento es el parámetro de tipo genérico.
MakeArrayType(Int32)	Devuelve el tipo de una matriz cuyo tipo de elemento es el parámetro de tipo genérico, con el número especificado de dimensiones.
MakeByRefType()	Devuelve un objeto Type que representa el parámetro de tipo genérico actual cuando se pasa como parámetro de referencia.
MakeGenericType(Type[])	No es válido para parámetros de tipo genérico incompletos.
MakePointerType()	Devuelve un objeto Type que representa un puntero al parámetro de tipo genérico actual.
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
SetBaseTypeConstraint(Type)	Establece el tipo base que debe heredar un tipo para sustituirlo por el parámetro de tipo.
SetBaseTypeConstraintCore(Type)	Cuando se reemplaza en una clase derivada, establece el tipo base que debe heredar un tipo para sustituirlo por el parámetro de tipo.
SetCustomAttribute(ConstructorInfo, Byte[])	Establece un atributo personalizado mediante un blob de atributo personalizado especificado.
SetCustomAttribute(CustomAttributeBuilder)	Establezca un atributo personalizado mediante un generador de atributos personalizados.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Cuando se invalida en una clase derivada, establece un atributo personalizado en este ensamblado.
SetGenericParameterAttributes(GenericParameterAttributes)	Establece las características de varianza y las restricciones especiales del parámetro genérico, como la restricción de constructor sin parámetros.
SetGenericParameterAttributesCore(GenericParameterAttributes)	Cuando se reemplaza en una clase derivada, establece las características de varianza y las restricciones especiales del parámetro genérico, como la restricción de constructor sin parámetros.
SetInterfaceConstraints(Type[])	Establece las interfaces que un tipo debe implementar para sustituirse por el parámetro de tipo.
SetInterfaceConstraintsCore(Type[])	Cuando se invalida en una clase derivada, establece las interfaces que un tipo debe implementar para sustituirse por el parámetro de tipo.
ToString()	Devuelve una representación de cadena del parámetro de tipo genérico actual.

Implementaciones de interfaz explícitas

IReflectableType.GetTypeInfo()

Devuelve una representación del tipo actual como un objeto TypeInfo. (Heredado de TypeInfo)

Métodos de extensión

GetCustomAttribute(MemberInfo, Type)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttribute(MemberInfo, Type, Boolean)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttribute<T>(MemberInfo)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttribute<T>(MemberInfo, Boolean)	Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttributes(MemberInfo)	Recupera una colección de atributos personalizados que se aplican a un miembro especificado.
GetCustomAttributes(MemberInfo, Boolean)	Recupera una colección de atributos personalizados que se aplican a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttributes(MemberInfo, Type)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttributes(MemberInfo, Type, Boolean)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
GetCustomAttributes<T>(MemberInfo)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado.
GetCustomAttributes<T>(MemberInfo, Boolean)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un miembro especificado y, opcionalmente, inspecciona los antecesores de ese miembro.
IsDefined(MemberInfo, Type)	Indica si los atributos personalizados de un tipo especificado se aplican a un miembro especificado.
IsDefined(MemberInfo, Type, Boolean)	Indica si los atributos personalizados de un tipo especificado se aplican a un miembro especificado y, opcionalmente, se aplican a sus antecesores.
GetTypeInfo(Type)	Devuelve la representación TypeInfo del tipo especificado.
GetMetadataToken(MemberInfo)	Obtiene un token de metadatos para el miembro especificado, si está disponible.
HasMetadataToken(MemberInfo)	Devuelve un valor que indica si un token de metadatos está disponible para el miembro especificado.
GetRuntimeEvent(Type, String)	Recupera un objeto que representa el evento especificado.
GetRuntimeEvents(Type)	Recupera una colección que representa todos los eventos definidos en un tipo especificado.
GetRuntimeField(Type, String)	Recupera un objeto que representa un campo especificado.
GetRuntimeFields(Type)	Recupera una colección que representa todos los campos definidos en un tipo especificado.
GetRuntimeInterfaceMap(TypeInfo, Type)	Devuelve una asignación de interfaz para el tipo especificado y la interfaz especificada.
GetRuntimeMethod(Type, String, Type[])	Recupera un objeto que representa un método especificado.
GetRuntimeMethods(Type)	Recupera una colección que representa todos los métodos definidos en un tipo especificado.
GetRuntimeProperties(Type)	Recupera una colección que representa todas las propiedades definidas en un tipo especificado.
GetRuntimeProperty(Type, String)	Recupera un objeto que representa una propiedad especificada.
GetConstructor(Type, Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetConstructors(Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetDefaultMembers(Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetEvent(Type, String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetField(Type, String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetInterfaces(Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetMember(Type, String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetMembers(Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetMethod(Type, String, Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetNestedType(Type, String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetProperties(Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetProperties(Type, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetProperty(Type, String)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetProperty(Type, String, BindingFlags)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetProperty(Type, String, Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
GetProperty(Type, String, Type, Type[])	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
IsAssignableFrom(Type, Type)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.
IsInstanceOfType(Type, Object)	Define y crea parámetros de tipo genéricos para tipos y métodos genéricos definidos dinámicamente. Esta clase no se puede heredar.

Consulte también

• DefineGenericParameters(String[])
• Cómo: Definir un tipo genérico con emisión de reflexión