GenericTypeParameterBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Emit.dll

Zdroj:

GenericTypeParameterBuilder.cs

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

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

public abstract class GenericTypeParameterBuilder : System.Reflection.TypeInfo

type GenericTypeParameterBuilder = class
    inherit TypeInfo

Public MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo

Dědičnost

Object

MemberInfo

Type

TypeInfo

GenericTypeParameterBuilder

Příklady

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

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

// Define a trivial base class and two trivial interfaces
// to use when demonstrating constraints.
//
public class ExampleBase {}

public interface IExampleA {}

public interface IExampleB {}

// Define a trivial type that can substitute for type parameter
// TSecond.
//
public class ExampleDerived : ExampleBase, IExampleA, IExampleB {}

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
        AssemblyBuilder myAssembly =
            myDomain.DefineDynamicAssembly(myAsmName,
                AssemblyBuilderAccess.RunAndSave);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same
        // as the assembly name.
        //
        ModuleBuilder myModule =
            myAssembly.DefineDynamicModule(myAsmName.Name,
               myAsmName.Name + ".dll");

        // Get type objects for the base class trivial interfaces to
        // be used as constraints.
        //
        Type baseType = typeof(ExampleBase);
        Type interfaceA = typeof(IExampleA);
        Type interfaceB = typeof(IExampleB);

        // Define the sample type.
        //
        TypeBuilder myType =
            myModule.DefineType("Sample", TypeAttributes.Public);

        Console.WriteLine("Type 'Sample' is generic: {0}",
            myType.IsGenericType);

        // Define type parameters for the type. Until you do this,
        // the type is not generic, as the preceding and following
        // WriteLine statements show. The type parameter names are
        // specified as an array of strings. To make the code
        // easier to read, each GenericTypeParameterBuilder is placed
        // in a variable with the same name as the type parameter.
        //
        string[] typeParamNames = {"TFirst", "TSecond"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        GenericTypeParameterBuilder TFirst = typeParams[0];
        GenericTypeParameterBuilder TSecond = typeParams[1];

        Console.WriteLine("Type 'Sample' is generic: {0}",
            myType.IsGenericType);

        // Apply constraints to the type parameters.
        //
        // A type that is substituted for the first parameter, TFirst,
        // must be a reference type and must have a parameterless
        // constructor.
        TFirst.SetGenericParameterAttributes(
            GenericParameterAttributes.DefaultConstructorConstraint |
            GenericParameterAttributes.ReferenceTypeConstraint);

        // A type that is substituted for the second type
        // parameter must implement IExampleA and IExampleB, and
        // inherit from the trivial test class ExampleBase. The
        // interface constraints are specified as an array
        // containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType);
        Type[] interfaceTypes = {interfaceA, interfaceB};
        TSecond.SetInterfaceConstraints(interfaceTypes);

        // The following code adds a private field named ExampleField,
        // of type TFirst.
        FieldBuilder exField =
            myType.DefineField("ExampleField", TFirst,
                FieldAttributes.Private);

        // Define a static method that takes an array of TFirst and
        // returns a List<TFirst> containing all the elements of
        // the array. To define this method it is necessary to create
        // the type List<TFirst> by calling MakeGenericType on the
        // generic type definition, List<T>. (The T is omitted with
        // the typeof operator when you get the generic type
        // definition.) The parameter type is created by using the
        // MakeArrayType method.
        //
        Type listOf = typeof(List<>);
        Type listOfTFirst = listOf.MakeGenericType(TFirst);
        Type[] mParamTypes = {TFirst.MakeArrayType()};

        MethodBuilder exMethod =
            myType.DefineMethod("ExampleMethod",
                MethodAttributes.Public | MethodAttributes.Static,
                listOfTFirst,
                mParamTypes);

        // Emit the method body.
        // The method body consists of just three opcodes, to load
        // the input array onto the execution stack, to call the
        // List<TFirst> constructor that takes IEnumerable<TFirst>,
        // which does all the work of putting the input elements into
        // the list, and to return, leaving the list on the stack. The
        // hard work is getting the constructor.
        //
        // The GetConstructor method is not supported on a
        // GenericTypeParameterBuilder, so it is not possible to get
        // the constructor of List<TFirst> directly. There are two
        // steps, first getting the constructor of List<T> and then
        // calling a method that converts it to the corresponding
        // constructor of List<TFirst>.
        //
        // The constructor needed here is the one that takes an
        // IEnumerable<T>. Note, however, that this is not the
        // generic type definition of IEnumerable<T>; instead, the
        // T from List<T> must be substituted for the T of
        // IEnumerable<T>. (This seems confusing only because both
        // types have type parameters named T. That is why this example
        // uses the somewhat silly names TFirst and TSecond.) To get
        // the type of the constructor argument, take the generic
        // type definition IEnumerable<T> (expressed as
        // IEnumerable<> when you use the typeof operator) and
        // call MakeGenericType with the first generic type parameter
        // of List<T>. The constructor argument list must be passed
        // as an array, with just one argument in this case.
        //
        // Now it is possible to get the constructor of List<T>,
        // using GetConstructor on the generic type definition. To get
        // the constructor of List<TFirst>, pass List<TFirst> and
        // the constructor from List<T> to the static
        // TypeBuilder.GetConstructor method.
        //
        ILGenerator ilgen = exMethod.GetILGenerator();

        Type ienumOf = typeof(IEnumerable<>);
        Type TfromListOf = listOf.GetGenericArguments()[0];
        Type ienumOfT = ienumOf.MakeGenericType(TfromListOf);
        Type[] ctorArgs = {ienumOfT};

        ConstructorInfo ctorPrep = listOf.GetConstructor(ctorArgs);
        ConstructorInfo ctor =
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep);

        ilgen.Emit(OpCodes.Ldarg_0);
        ilgen.Emit(OpCodes.Newobj, ctor);
        ilgen.Emit(OpCodes.Ret);

        // Create the type and save the assembly.
        Type finished = myType.CreateType();
        myAssembly.Save(myAsmName.Name+".dll");

        // Invoke the method.
        // ExampleMethod is not generic, but the type it belongs to is
        // generic, so in order to get a MethodInfo that can be invoked
        // it is necessary to create a constructed type. The Example
        // class satisfies the constraints on TFirst, because it is a
        // reference type and has a default constructor. In order to
        // have a class that satisfies the constraints on TSecond,
        // this code example defines the ExampleDerived type. These
        // two types are passed to MakeGenericMethod to create the
        // constructed type.
        //
        Type[] typeArgs = {typeof(Example), typeof(ExampleDerived)};
        Type constructed = finished.MakeGenericType(typeArgs);
        MethodInfo mi = constructed.GetMethod("ExampleMethod");

        // Create an array of Example objects, as input to the generic
        // method. This array must be passed as the only element of an
        // array of arguments. The first argument of Invoke is
        // null, because ExampleMethod is static. Display the count
        // on the resulting List<Example>.
        //
        Example[] input = {new Example(), new Example()};
        object[] arguments = {input};

        List<Example> listX =
            (List<Example>) mi.Invoke(null, arguments);

        Console.WriteLine(
            "\nThere are {0} elements in the List<Example>.",
            listX.Count);

        DisplayGenericParameters(finished);
    }

    private static void DisplayGenericParameters(Type t)
    {
        if (!t.IsGenericType)
        {
            Console.WriteLine("Type '{0}' is not generic.");
            return;
        }
        if (!t.IsGenericTypeDefinition)
        {
            t = t.GetGenericTypeDefinition();
        }

        Type[] typeParameters = t.GetGenericArguments();
        Console.WriteLine("\nListing {0} type parameters for type '{1}'.",
            typeParameters.Length, t);

        foreach( Type tParam in typeParameters )
        {
            Console.WriteLine("\r\nType parameter {0}:", tParam.ToString());

            foreach( Type c in tParam.GetGenericParameterConstraints() )
            {
                if (c.IsInterface)
                {
                    Console.WriteLine("    Interface constraint: {0}", c);
                }
                else
                {
                    Console.WriteLine("    Base type constraint: {0}", c);
                }
            }

            ListConstraintAttributes(tParam);
        }
    }

    // List the constraint flags. The GenericParameterAttributes
    // enumeration contains two sets of attributes, variance and
    // constraints. For this example, only constraints are used.
    //
    private static void ListConstraintAttributes(Type t)
    {
        // Mask off the constraint flags.
        GenericParameterAttributes constraints =
            t.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;

        if ((constraints & GenericParameterAttributes.ReferenceTypeConstraint)
            != GenericParameterAttributes.None)
        {
            Console.WriteLine("    ReferenceTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.NotNullableValueTypeConstraint)
            != GenericParameterAttributes.None)
        {
            Console.WriteLine("    NotNullableValueTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.DefaultConstructorConstraint)
            !=GenericParameterAttributes.None)
        {
            Console.WriteLine("    DefaultConstructorConstraint");
        }
    }
}

/* This code example produces the following output:

Type 'Sample' is generic: False
Type 'Sample' is generic: True

There are 2 elements in the List<Example>.

Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Collections.Generic

' Define a trivial base class and two trivial interfaces 
' to use when demonstrating constraints.
'
Public Class ExampleBase
End Class

Public Interface IExampleA
End Interface

Public Interface IExampleB
End Interface

' Define a trivial type that can substitute for type parameter 
' TSecond.
'
Public Class ExampleDerived
    Inherits ExampleBase
    Implements IExampleA, IExampleB
End Class

Public Class Example
    Public Shared Sub Main()
        ' Define a dynamic assembly to contain the sample type. The
        ' assembly will not be run, but only saved to disk, so
        ' AssemblyBuilderAccess.Save is specified.
        '
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("GenericEmitExample1")
        Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly( _
            myAsmName, _
            AssemblyBuilderAccess.RunAndSave)

        ' An assembly is made up of executable modules. For a single-
        ' module assembly, the module name and file name are the same 
        ' as the assembly name. 
        '
        Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule( _
            myAsmName.Name, _
            myAsmName.Name & ".dll")

        ' Get type objects for the base class trivial interfaces to
        ' be used as constraints.
        '
        Dim baseType As Type = GetType(ExampleBase)
        Dim interfaceA As Type = GetType(IExampleA)
        Dim interfaceB As Type = GetType(IExampleB)
                
        ' Define the sample type.
        '
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Public)

        Console.WriteLine("Type 'Sample' is generic: {0}", _
            myType.IsGenericType)

        ' Define type parameters for the type. Until you do this, 
        ' the type is not generic, as the preceding and following 
        ' WriteLine statements show. The type parameter names are
        ' specified as an array of strings. To make the code
        ' easier to read, each GenericTypeParameterBuilder is placed
        ' in a variable with the same name as the type parameter.
        ' 
        Dim typeParamNames() As String = {"TFirst", "TSecond"}
        Dim typeParams() As GenericTypeParameterBuilder = _
            myType.DefineGenericParameters(typeParamNames)

        Dim TFirst As GenericTypeParameterBuilder = typeParams(0)
        Dim TSecond As GenericTypeParameterBuilder = typeParams(1)

        Console.WriteLine("Type 'Sample' is generic: {0}", _
            myType.IsGenericType)

        ' Apply constraints to the type parameters.
        '
        ' A type that is substituted for the first parameter, TFirst,
        ' must be a reference type and must have a parameterless
        ' constructor.
        TFirst.SetGenericParameterAttributes( _
            GenericParameterAttributes.DefaultConstructorConstraint _
            Or GenericParameterAttributes.ReferenceTypeConstraint)

        ' A type that is substituted for the second type
        ' parameter must implement IExampleA and IExampleB, and
        ' inherit from the trivial test class ExampleBase. The
        ' interface constraints are specified as an array 
        ' containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType)
        Dim interfaceTypes() As Type = {interfaceA, interfaceB}
        TSecond.SetInterfaceConstraints(interfaceTypes)

        ' The following code adds a private field named ExampleField,
        ' of type TFirst.
        Dim exField As FieldBuilder = _
            myType.DefineField("ExampleField", TFirst, _
                FieldAttributes.Private)

        ' Define a Shared method that takes an array of TFirst and 
        ' returns a List(Of TFirst) containing all the elements of 
        ' the array. To define this method it is necessary to create
        ' the type List(Of TFirst) by calling MakeGenericType on the
        ' generic type definition, List(Of T). (The T is omitted with
        ' the GetType operator when you get the generic type 
        ' definition.) The parameter type is created by using the
        ' MakeArrayType method. 
        '
        Dim listOf As Type = GetType(List(Of ))
        Dim listOfTFirst As Type = listOf.MakeGenericType(TFirst)
        Dim mParamTypes() As Type = { TFirst.MakeArrayType() }

        Dim exMethod As MethodBuilder = _
            myType.DefineMethod("ExampleMethod", _
                MethodAttributes.Public Or MethodAttributes.Static, _
                listOfTFirst, _
                mParamTypes)

        ' Emit the method body. 
        ' The method body consists of just three opcodes, to load 
        ' the input array onto the execution stack, to call the 
        ' List(Of TFirst) constructor that takes IEnumerable(Of TFirst),
        ' which does all the work of putting the input elements into
        ' the list, and to return, leaving the list on the stack. The
        ' hard work is getting the constructor.
        ' 
        ' The GetConstructor method is not supported on a 
        ' GenericTypeParameterBuilder, so it is not possible to get 
        ' the constructor of List(Of TFirst) directly. There are two
        ' steps, first getting the constructor of List(Of T) and then
        ' calling a method that converts it to the corresponding 
        ' constructor of List(Of TFirst).
        '
        ' The constructor needed here is the one that takes an
        ' IEnumerable(Of T). Note, however, that this is not the 
        ' generic type definition of IEnumerable(Of T); instead, the
        ' T from List(Of T) must be substituted for the T of 
        ' IEnumerable(Of T). (This seems confusing only because both
        ' types have type parameters named T. That is why this example
        ' uses the somewhat silly names TFirst and TSecond.) To get
        ' the type of the constructor argument, take the generic
        ' type definition IEnumerable(Of T) (expressed as 
        ' IEnumerable(Of ) when you use the GetType operator) and 
        ' call MakeGenericType with the first generic type parameter
        ' of List(Of T). The constructor argument list must be passed
        ' as an array, with just one argument in this case.
        ' 
        ' Now it is possible to get the constructor of List(Of T),
        ' using GetConstructor on the generic type definition. To get
        ' the constructor of List(Of TFirst), pass List(Of TFirst) and
        ' the constructor from List(Of T) to the static
        ' TypeBuilder.GetConstructor method.
        '
        Dim ilgen As ILGenerator = exMethod.GetILGenerator()
        
        Dim ienumOf As Type = GetType(IEnumerable(Of ))
        Dim listOfTParams() As Type = listOf.GetGenericArguments()
        Dim TfromListOf As Type = listOfTParams(0)
        Dim ienumOfT As Type = ienumOf.MakeGenericType(TfromListOf)
        Dim ctorArgs() As Type = { ienumOfT }

        Dim ctorPrep As ConstructorInfo = _
            listOf.GetConstructor(ctorArgs)
        Dim ctor As ConstructorInfo = _
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep)

        ilgen.Emit(OpCodes.Ldarg_0)
        ilgen.Emit(OpCodes.Newobj, ctor)
        ilgen.Emit(OpCodes.Ret)

        ' Create the type and save the assembly. 
        Dim finished As Type = myType.CreateType()
        myAssembly.Save(myAsmName.Name & ".dll")

        ' Invoke the method.
        ' ExampleMethod is not generic, but the type it belongs to is
        ' generic, so in order to get a MethodInfo that can be invoked
        ' it is necessary to create a constructed type. The Example 
        ' class satisfies the constraints on TFirst, because it is a 
        ' reference type and has a default constructor. In order to
        ' have a class that satisfies the constraints on TSecond, 
        ' this code example defines the ExampleDerived type. These
        ' two types are passed to MakeGenericMethod to create the
        ' constructed type.
        '
        Dim typeArgs() As Type = _
            { GetType(Example), GetType(ExampleDerived) }
        Dim constructed As Type = finished.MakeGenericType(typeArgs)
        Dim mi As MethodInfo = constructed.GetMethod("ExampleMethod")

        ' Create an array of Example objects, as input to the generic
        ' method. This array must be passed as the only element of an 
        ' array of arguments. The first argument of Invoke is 
        ' Nothing, because ExampleMethod is Shared. Display the count
        ' on the resulting List(Of Example).
        ' 
        Dim input() As Example = { New Example(), New Example() }
        Dim arguments() As Object = { input }

        Dim listX As List(Of Example) = mi.Invoke(Nothing, arguments)

        Console.WriteLine(vbLf & _
            "There are {0} elements in the List(Of Example).", _
            listX.Count _ 
        )

        DisplayGenericParameters(finished)
    End Sub

    Private Shared Sub DisplayGenericParameters(ByVal t As Type)

        If Not t.IsGenericType Then
            Console.WriteLine("Type '{0}' is not generic.")
            Return
        End If
        If Not t.IsGenericTypeDefinition Then _
            t = t.GetGenericTypeDefinition()

        Dim typeParameters() As Type = t.GetGenericArguments()
        Console.WriteLine(vbCrLf & _
            "Listing {0} type parameters for type '{1}'.", _
            typeParameters.Length, t)

        For Each tParam As Type In typeParameters

            Console.WriteLine(vbCrLf & "Type parameter {0}:", _
                tParam.ToString())

            For Each c As Type In tParam.GetGenericParameterConstraints()
                If c.IsInterface Then
                    Console.WriteLine("    Interface constraint: {0}", c)
                Else
                    Console.WriteLine("    Base type constraint: {0}", c)
                End If
            Next 

            ListConstraintAttributes(tParam)
        Next tParam
    End Sub

    ' List the constraint flags. The GenericParameterAttributes
    ' enumeration contains two sets of attributes, variance and
    ' constraints. For this example, only constraints are used.
    '
    Private Shared Sub ListConstraintAttributes(ByVal t As Type)

        ' Mask off the constraint flags. 
        Dim constraints As GenericParameterAttributes = _
            t.GenericParameterAttributes And _
            GenericParameterAttributes.SpecialConstraintMask

        If (constraints And GenericParameterAttributes.ReferenceTypeConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    ReferenceTypeConstraint")

        If (constraints And GenericParameterAttributes.NotNullableValueTypeConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    NotNullableValueTypeConstraint")

        If (constraints And GenericParameterAttributes.DefaultConstructorConstraint) _
                <> GenericParameterAttributes.None Then _
            Console.WriteLine("    DefaultConstructorConstraint")

    End Sub 

End Class

' This code example produces the following output:
'
'Type 'Sample' is generic: False
'Type 'Sample' is generic: True
'
'There are 2 elements in the List(Of Example).
'
'Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.
'
'Type parameter TFirst:
'    ReferenceTypeConstraint
'    DefaultConstructorConstraint
'
'Type parameter TSecond:
'    Interface constraint: IExampleA
'    Interface constraint: IExampleB
'    Base type constraint: ExampleBase

Poznámky

Pole GenericTypeParameterBuilder objektů můžete získat pomocí TypeBuilder.DefineGenericParameters metody pro přidání parametrů typu do dynamického typu, čímž se z něj vytvoří obecný typ nebo pomocí MethodBuilder.DefineGenericParameters metody pro přidání parametrů typu do dynamické metody. GenericTypeParameterBuilder Objekty slouží k přidání omezení do parametrů typu. Omezení jsou ze tří druhů:

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

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

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

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

Konstruktory

Name	Description
GenericTypeParameterBuilder()	Inicializuje novou instanci GenericTypeParameterBuilder třídy.

Vlastnosti

Name	Description
Assembly	Assembly Získá objekt představující dynamické sestavení, který obsahuje definici obecného typu aktuální typ parametr patří.
AssemblyQualifiedName	Dostane null se ve všech případech.
BaseType	Získá omezení základního typu aktuálního parametru obecného typu.
ContainsGenericParameters	Dostane true se ve všech případech.
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo)
DeclaredConstructors	Získá kolekci konstruktorů deklarovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredEvents	Získá kolekci událostí definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredFields	Získá kolekci polí definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredMembers	Získá kolekci členů definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredMethods	Získá kolekci metod definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredNestedTypes	Získá kolekci vnořených typů definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaredProperties	Získá kolekci vlastností definovaných aktuálním typem. (Zděděno od TypeInfo)
DeclaringMethod	MethodInfo Získá, který představuje deklarující metodu, pokud aktuální GenericTypeParameterBuilder představuje typ parametr obecné metody.
DeclaringType	Získá definici obecného typu nebo obecnou definici metody, do které patří parametr obecného typu.
FullName	Dostane null se ve všech případech.
GenericParameterAttributes	Získá kombinaci GenericParameterAttributes příznaků, které popisují kovarianci a zvláštní omezení aktuálního parametru obecného typu.
GenericParameterPosition	Získá pozici parametru typu v seznamu parametrů typu obecného typu nebo metody, která deklarovala parametr.
GenericTypeParameters	Získá pole parametrů obecného typu aktuální instance. (Zděděno od TypeInfo)
GUID	Nepodporuje se u neúplných parametrů obecného typu.
ImplementedInterfaces	Získá kolekci rozhraní implementovaných aktuálním typem. (Zděděno od TypeInfo)
IsByRefLike	Získá hodnotu, která označuje, zda typ je byref-like struktura.
IsCollectible	Získá hodnotu, která označuje, zda tento MemberInfo objekt odkazuje na jedno nebo více sestavení uložených v collectible AssemblyLoadContext. (Zděděno od MemberInfo)
IsConstructedGenericType	Získá hodnotu, která označuje, zda tento objekt představuje vytvořený obecný typ.
IsContextful	Získá hodnotu označující, zda Type lze hostovat v kontextu. (Zděděno od Type)
IsFunctionPointer	Získá hodnotu, která určuje, zda aktuální Type je ukazatel funkce. (Zděděno od Type)
IsGenericMethodParameter	Získá hodnotu, která určuje, zda aktuální Type představuje typ parametr v definici obecné metody. (Zděděno od Type)
IsGenericParameter	Dostane true se ve všech případech.
IsGenericType	Vrátí false ve všech případech.
IsGenericTypeDefinition	Dostane false se ve všech případech.
IsGenericTypeParameter	Získá hodnotu, která určuje, zda aktuální Type představuje parametr typu v definici obecného typu. (Zděděno od Type)
IsSecurityCritical	Získá hodnotu, která označuje, zda aktuální typ je kritický pro zabezpečení nebo zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti, a proto může provádět kritické operace. (Zděděno od Type)
IsSecuritySafeCritical	Získá hodnotu, která označuje, zda aktuální typ je zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti; to znamená, jestli může provádět kritické operace a může k němu přistupovat transparentní kód. (Zděděno od Type)
IsSecurityTransparent	Získá hodnotu, která určuje, zda aktuální typ je transparentní na aktuální úrovni důvěryhodnosti, a proto nemůže provádět kritické operace. (Zděděno od Type)
IsSignatureType	Získá hodnotu, která označuje, zda typ je typ podpisu. (Zděděno od Type)
IsSZArray	Získá hodnotu, která určuje, zda typ je typ pole, který může představovat pouze jednorozměrné pole s nulovou dolní mez.
IsTypeDefinition	Získá hodnotu, která určuje, zda typ je definice typu.
IsUnmanagedFunctionPointer	Získá hodnotu, která určuje, zda aktuální Type je nespravovaný ukazatel funkce. (Zděděno od Type)
IsVariableBoundArray	Získá hodnotu, která určuje, zda typ je typ pole, který může představovat vícerozměrné pole nebo pole s libovolnou dolní mez. (Zděděno od Type)
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
Module	Získá dynamický modul, který obsahuje parametr obecného typu.
Name	Získá název parametru obecného typu.
Namespace	Dostane null se ve všech případech.
ReflectedType	Type Získá objekt, který byl použit k získání GenericTypeParameterBuilder.
TypeHandle	Nepodporuje se u neúplných parametrů obecného typu.
UnderlyingSystemType	Získá aktuální parametr obecného typu.

Metody

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

Explicitní implementace rozhraní

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

Metody rozšíření

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

Viz také

• DefineGenericParameters(String[])
• Jak definovat obecný datový typ pomocí Reflection Emit