GenericTypeParameterBuilder Classe

Referência

Definição

Namespace:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Pacote:: System.Reflection.Emit v4.7.0

Origem:: GenericTypeParameterBuilder.cs

Origem:: GenericTypeParameterBuilder.cs

Origem:: GenericTypeParameterBuilder.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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 sealed : Type

public ref class GenericTypeParameterBuilder sealed : System::Reflection::TypeInfo

public ref class GenericTypeParameterBuilder abstract : System::Reflection::TypeInfo

public sealed class GenericTypeParameterBuilder : Type

public sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfo

public abstract class GenericTypeParameterBuilder : System.Reflection.TypeInfo

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder : Type

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfo

type GenericTypeParameterBuilder = class
    inherit Type

type GenericTypeParameterBuilder = class
    inherit TypeInfo

[<System.Runtime.InteropServices.ComVisible(true)>]
type GenericTypeParameterBuilder = class
    inherit Type

[<System.Runtime.InteropServices.ComVisible(true)>]
type GenericTypeParameterBuilder = class
    inherit TypeInfo

Public NotInheritable Class GenericTypeParameterBuilder
Inherits Type

Public NotInheritable Class GenericTypeParameterBuilder
Inherits TypeInfo

Public MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo

Herança: Object

MemberInfo

Type
GenericTypeParameterBuilder

Herança: Object

MemberInfo

TypeInfo
GenericTypeParameterBuilder

Herança: Object

MemberInfo

Type

TypeInfo
GenericTypeParameterBuilder

Atributos: ComVisibleAttribute

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	Obtém os atributos associados ao Type.
Attributes	Obtém os atributos associados ao Type. (Herdado de Type)
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.
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. (Herdado de Type)
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.
GenericTypeArguments	Obtém uma matriz dos argumentos de tipo genérico para esse tipo. (Herdado de Type)
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	Obtém um valor que indica 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. (Herdado de Type)
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	Obtém um valor que indica se o Type é abstrato e deve ser substituído. (Herdado de Type)
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	Obtém um valor que indica se o atributo de formato da cadeia de caracteres `AnsiClass` está selecionado para o Type. (Herdado de Type)
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	Obtém um valor que indica se o tipo é uma matriz. (Herdado de Type)
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	Obtém um valor que indica se o atributo de formato da cadeia de caracteres `AutoClass` está selecionado para o Type. (Herdado de Type)
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	Obtém um valor que indica se os campos do tipo atual são apresentados automaticamente pelo Common Language Runtime. (Herdado de Type)
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	Obtém um valor que indica se o Type é aprovado por referência. (Herdado de Type)
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.
IsByRefLike	Obtém um valor que indica se o tipo é uma estrutura de tipo ByRef. (Herdado de Type)
IsClass	Obtém um valor que indica se o Type é uma classe ou um delegado; ou seja, não um tipo de valor ou interface. (Herdado de Type)
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	Obtém um valor que indica se o Type é um objeto COM. (Herdado de Type)
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.
IsConstructedGenericType	Obtém um valor que indica se este objeto representa um tipo genérico construído. Você pode criar instâncias de um tipo genérico construído. (Herdado de Type)
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.
IsEnum	Obtém um valor que indica se o Type atual representa uma enumeração. (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	Obtém um valor que indica se os campos do tipo atual são apresentados em deslocamentos explicitamente especificados. (Herdado de Type)
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	Obtém um valor que indica se o Type tem um atributo ComImportAttribute aplicado, indicando que ele foi importado de uma biblioteca de tipos COM. (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	Obtém um valor que indica se o Type é uma interface, ou seja, não é uma classe ou um tipo de valor. (Herdado de Type)
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	Obtém um valor que indica se os campos do tipo atual são apresentados em sequência, na ordem em que foram definidos ou emitidos para os metadados. (Herdado de Type)
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	Obtém um valor que indica se é realizado marshal no Type por referência. (Herdado de Type)
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	Obtém um valor que indica se o objeto atual Type representa um tipo cuja definição está aninhada dentro da definição de outro tipo. (Herdado de Type)
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	Obtém um valor que indica se o Type é aninhado e visível somente dentro de seu próprio assembly. (Herdado de Type)
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	Obtém um valor que indica se o Type é aninhado e visíveis somente para classes que pertencem à sua própria família e ao seu próprio assembly. (Herdado de Type)
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	Obtém um valor que indica se o Type é aninhado e visível somente dentro de sua própria família. (Herdado de Type)
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	Obtém um valor que indica se o Type é aninhado e visíveis somente para classes que pertençam à sua própria família ou ao seu próprio assembly. (Herdado de Type)
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	Obtém um valor que indica se o Type é aninhado e declarado privado. (Herdado de Type)
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	Obtém um valor que indica se uma classe é aninhada e declarada pública. (Herdado de Type)
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	Obtém um valor que indica se o Type não está declarado como público. (Herdado de Type)
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	Obtém um valor que indica se o Type é um ponteiro. (Herdado de Type)
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	Obtém um valor que indica se o Type é um dos tipos primitivos. (Herdado de Type)
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	Obtém um valor que indica se o Type está declarado como público. (Herdado de Type)
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	Obtém um valor que indica se o Type está declarado selado. (Herdado de Type)
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.
IsSerializable	Obsoleto. Obtém um valor que indica se o Type é serializável binário. (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	Obtém um valor que indica se o tipo tem um nome que exige tratamento especial. (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.
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. (Herdado de Type)
IsTypeDefinition	Obtém um valor que indica se o tipo é uma definição de tipo.
IsTypeDefinition	Obtém um valor que indica se o tipo é uma definição de tipo. (Herdado de Type)
IsUnicodeClass	Obtém um valor que indica se o atributo de formato da cadeia de caracteres `UnicodeClass` está selecionado para o Type. (Herdado de Type)
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	Obtém um valor que indica se o Type é um tipo de valor. (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	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.
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	Obtém um valor que indica se Type pode ser acessado pelo código fora do assembly. (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	Obtém um valor MemberTypes que indica que esse membro é um tipo ou um tipo aninhado. (Herdado de Type)
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.
MetadataToken	Obtém um valor que identifica um elemento de metadados. (Herdado de MemberInfo)
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.
ReflectedType	Obtém o objeto de classe que foi usado para obter esta instância de `MemberInfo`. (Herdado de MemberInfo)
StructLayoutAttribute	Obtém um StructLayoutAttribute que descreve o layout do tipo atual. (Herdado de Type)
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	Obtém o inicializador para o tipo. (Herdado de Type)
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.
UnderlyingSystemType	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)

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)	Retorna uma matriz de objetos Type que representa uma lista filtrada das interfaces implementadas ou herdadas pelo Type atual. (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)	Retorna uma matriz filtrada de objetos MemberInfo do tipo do membro especificado. (Herdado de Type)
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.
GetArrayRank()	Obtém o número de dimensões em uma matriz. (Herdado de Type)
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.
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. (Herdado de 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[])	Pesquisa um construtor de instância pública cujos parâmetros correspondem aos tipos na matriz especificada. (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.
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Quando substituído em uma classe derivada, 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)
GetConstructors()	Retorna todos os construtores públicos definidos para o Type atual. (Herdado de Type)
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.
GetConstructors(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)
GetCustomAttributes(Boolean)	Sem suporte para parâmetros de tipo genérico incompletos.
GetCustomAttributes(Boolean)	Quando substituído em uma classe derivada, retorna uma matriz de todos os atributos personalizados aplicados a esse membro. (Herdado de MemberInfo)
GetCustomAttributes(Type, Boolean)	Sem suporte para parâmetros de tipo genérico incompletos.
GetCustomAttributes(Type, Boolean)	Quando substituído em uma classe derivada, retorna uma matriz de atributos personalizados aplicados a esse membro e identificados por Type. (Herdado de MemberInfo)
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()	Procura os membros definidos para o Type atual, cujo DefaultMemberAttribute está definido. (Herdado de Type)
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)	Retorna o nome da constante que tem o valor especificado para o tipo de enumeração atual. (Herdado de Type)
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()	Retorna os nomes dos membros do tipo de enumeração atual. (Herdado de Type)
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()	Retorna o tipo subjacente do tipo de enumeração atual. (Herdado de Type)
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()	Retorna uma matriz de valores das constantes no tipo de enumeração especificado. (Herdado de Type)
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)	Retorna o objeto EventInfo que representa o evento público especificado. (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.
GetEvent(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)
GetEvents()	Sem suporte para parâmetros de tipo genérico incompletos.
GetEvents()	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)
GetEvents(BindingFlags)	Sem suporte para parâmetros de tipo genérico incompletos.
GetEvents(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)
GetField(String)	Pesquisa o campo público com o nome especificado. (Herdado de Type)
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.
GetField(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)
GetFields()	Retorna todos os campos públicos do Type atual. (Herdado de Type)
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.
GetFields(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)
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.
GetGenericArguments()	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)
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.
GetGenericParameterConstraints()	Retorna uma matriz de objetos Type que representam as restrições no parâmetro de tipo genérico atual. (Herdado de Type)
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)	Pesquisa a interface com o nome especificado. (Herdado de Type)
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.
GetInterface(String, Boolean)	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)
GetInterfaceMap(Type)	Sem suporte para parâmetros de tipo genérico incompletos.
GetInterfaces()	Sem suporte para parâmetros de tipo genérico incompletos.
GetInterfaces()	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)	Pesquisa a propriedade pública com o nome especificado. (Herdado de Type)
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)	Pesquisa os membros especificados usando as restrições de associação especificadas. (Herdado de Type)
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.
GetMember(String, MemberTypes, 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)
GetMembers()	Retorna todos os membros públicos do Type atual. (Herdado de Type)
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.
GetMembers(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)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)	Pesquisa o MemberInfo no atual Type que corresponde ao especificado MemberInfo. (Herdado de Type)
GetMethod(String)	Pesquisa o método público com o nome especificado. (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)	Pesquisa o método especificado, usando as restrições de associação especificadas. (Herdado de Type)
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[])	Pesquisa o método público especificado cujos parâmetros correspondem aos tipos de argumento especificados. (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[])	Pesquisa o método público especificado cujos parâmetros correspondem aos modificadores e tipos de argumento especificados. (Herdado de Type)
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, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])	Quando substituído em uma classe derivada, 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)
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()	Retorna todos os métodos públicos do Type atual. (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.
GetMethods(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)
GetNestedType(String)	Pesquisa o tipo aninhado público com o nome especificado. (Herdado de Type)
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.
GetNestedType(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)
GetNestedTypes()	Retorna os tipos públicos aninhados no Type atual. (Herdado de Type)
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.
GetNestedTypes(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)
GetOptionalCustomModifiers()	Quando substituído em uma classe derivada, retorna os modificadores personalizados opcionais do atual Type. (Herdado de Type)
GetProperties()	Retorna todas as propriedades públicas do Type atual. (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.
GetProperties(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)	Pesquisa a propriedade pública com o nome especificado. (Herdado de Type)
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)	Pesquisa a propriedade especificada usando as restrições de associação especificadas. (Herdado de Type)
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)	Pesquisa a propriedade pública com o nome e tipo retornado especificados. (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[])	Pesquisa a propriedade pública especificada cujos parâmetros correspondem aos tipos de argumento especificados. (Herdado de Type)
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[])	Pesquisa a propriedade pública especificada cujos parâmetros correspondem aos tipos de argumento e modificadores especificados. (Herdado de Type)
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[])	Pesquisa a propriedade pública especificada cujos parâmetros correspondem aos tipos de argumento especificados. (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)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Sem suporte para parâmetros de tipo genérico incompletos.
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Quando substituído em uma classe derivada, 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)
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)
GetType()	Descobre os atributos de um membro e fornece acesso aos metadados de membro. (Herdado de MemberInfo)
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.
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. (Herdado de Type)
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.
IsArrayImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsArray e determina se o Type é uma matriz. (Herdado de Type)
IsAssignableFrom(Type)	Gera uma exceção NotSupportedException em todos os casos.
IsAssignableFrom(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)
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.
IsByRefImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsByRef e determina se o Type é passado por referência. (Herdado de Type)
IsCOMObjectImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsCOMObject e determina se o Type é um objeto COM.
IsCOMObjectImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsCOMObject e determina se o Type é um objeto COM. (Herdado de Type)
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.
IsDefined(Type, Boolean)	Quando substituído em uma classe derivada, indica se um ou mais atributos do tipo especificado ou de seus tipos derivados são aplicados a esse membro. (Herdado de MemberInfo)
IsEnumDefined(Object)	Retorna um valor que indica se o valor especificado existe no tipo de enumeração atual. (Herdado de Type)
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)	Determina se dois tipos COM têm a mesma identidade e são elegíveis para equivalência de tipo. (Herdado de Type)
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)	Determina se o objeto especificado é uma instância do Type atual. (Herdado de Type)
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.
IsPointerImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsPointer e determina se o Type é um ponteiro. (Herdado de Type)
IsPrimitiveImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsPrimitive e determina se o Type é um dos tipos primitivos.
IsPrimitiveImpl()	Quando substituído em uma classe derivada, implementa a propriedade IsPrimitive e determina se o Type é um dos tipos primitivos. (Herdado de Type)
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.
IsValueTypeImpl()	Implementa a propriedade IsValueType e determina se o Type é um tipo de valor, ou seja, não é uma classe nem uma interface. (Herdado de Type)
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

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição. (Herdado de MemberInfo)
_MemberInfo.GetType()	Obtém um objeto Type que representa a classe MemberInfo. (Herdado de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface. (Herdado de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1). (Herdado de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fornece acesso a propriedades e métodos expostos por um objeto. (Herdado de MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mapeia um conjunto de nomes para um conjunto correspondente de identificadores de expedição. (Herdado de Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)	Recupera as informações do tipo de um objeto, que podem ser usadas para obter informações de tipo para uma interface. (Herdado de Type)
_Type.GetTypeInfoCount(UInt32)	Retorna o número de interfaces de informações do tipo que um objeto fornece (0 ou 1). (Herdado de Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fornece acesso a propriedades e métodos expostos por um objeto. (Herdado de Type)
ICustomAttributeProvider.GetCustomAttributes(Boolean)	Retorna uma matriz de todos os atributos personalizados definidos neste membro, exceto atributos nomeados ou então uma matriz vazia, se não houver nenhum atributo personalizado. (Herdado de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)	Retorna uma matriz de atributos personalizados definidos neste membro, identificados por tipo ou então uma matriz vazia, se não houver nenhum atributo personalizado desse tipo. (Herdado de MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)	Indica se uma ou mais instâncias de `attributeType` estão definidas nesse membro. (Herdado de MemberInfo)
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.

Aplica-se a

Partilhar via