Sdílet prostřednictvím


GenericTypeParameterBuilder Třída

Definice

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 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
Dědičnost
GenericTypeParameterBuilder
Dědičnost
GenericTypeParameterBuilder
Dědičnost
GenericTypeParameterBuilder
Atributy

Příklady

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

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Collections::Generic;

// Dummy class to satisfy TFirst constraints.
//
public ref class Example {};

// Define a trivial base class and two trivial interfaces 
// to use when demonstrating constraints.
//
public ref class ExampleBase {};
public interface class IExampleA {};
public interface class IExampleB {};

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

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

   if ((constraints & GenericParameterAttributes::ReferenceTypeConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    ReferenceTypeConstraint");

   if ((constraints & GenericParameterAttributes::NotNullableValueTypeConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    NotNullableValueTypeConstraint");

   if ((constraints & GenericParameterAttributes::DefaultConstructorConstraint)
           != GenericParameterAttributes::None)
       Console::WriteLine( L"    DefaultConstructorConstraint");
}

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

   array<Type^>^ typeParameters = t->GetGenericArguments();
   Console::WriteLine( L"\r\nListing {0} type parameters for type '{1}'.", 
       typeParameters->Length, t );

   for each ( Type^ tParam in typeParameters )
   {
       Console::WriteLine( L"\r\nType parameter {0}:", 
           tParam->ToString() );

       for each (Type^ c in tParam->GetGenericParameterConstraints())
       {
           if (c->IsInterface)
               Console::WriteLine( L"    Interface constraint: {0}", c);
           else
               Console::WriteLine( L"    Base type constraint: {0}", c);
       }
       ListConstraintAttributes(tParam);
   }
}

void main()
{
   // Define a dynamic assembly to contain the sample type. The
   // assembly will be run and also saved to disk, so
   // AssemblyBuilderAccess.RunAndSave is specified.
   //
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ myAsmName = gcnew AssemblyName( L"GenericEmitExample1" );
   AssemblyBuilder^ myAssembly = myDomain->DefineDynamicAssembly( 
       myAsmName, AssemblyBuilderAccess::RunAndSave );

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

   // Get type objects for the base class trivial interfaces to
   // be used as constraints.
   //
   Type^ baseType = ExampleBase::typeid; 
   Type^ interfaceA = IExampleA::typeid; 
   Type^ interfaceB = IExampleB::typeid;
   
   // Define the sample type.
   //
   TypeBuilder^ myType = myModule->DefineType( L"Sample", 
       TypeAttributes::Public );
   
   Console::WriteLine( L"Type 'Sample' is generic: {0}", 
       myType->IsGenericType );
   
   // Define type parameters for the type. Until you do this, 
   // the type is not generic, as the preceding and following 
   // WriteLine statements show. The type parameter names are
   // specified as an array of strings. To make the code
   // easier to read, each GenericTypeParameterBuilder is placed
   // in a variable with the same name as the type parameter.
   // 
   array<String^>^typeParamNames = {L"TFirst",L"TSecond"};
   array<GenericTypeParameterBuilder^>^typeParams = 
       myType->DefineGenericParameters( typeParamNames );

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

   Console::WriteLine( L"Type 'Sample' is generic: {0}", 
       myType->IsGenericType );
   
   // Apply constraints to the type parameters.
   //
   // A type that is substituted for the first parameter, TFirst,
   // must be a reference type and must have a parameterless
   // constructor.
   TFirst->SetGenericParameterAttributes( 
       GenericParameterAttributes::DefaultConstructorConstraint | 
       GenericParameterAttributes::ReferenceTypeConstraint 
   );

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

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

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

   MethodBuilder^ exMethod = 
       myType->DefineMethod("ExampleMethod", 
           MethodAttributes::Public | MethodAttributes::Static, 
           listOfTFirst, 
           mParamTypes);

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

   ConstructorInfo^ ctorPrep = listOf->GetConstructor(ctorArgs);
   ConstructorInfo^ ctor = 
       TypeBuilder::GetConstructor(listOfTFirst, ctorPrep);

   ilgen->Emit(OpCodes::Ldarg_0);
   ilgen->Emit(OpCodes::Newobj, ctor);
   ilgen->Emit(OpCodes::Ret);

   // Create the type and save the assembly. 
   Type^ finished = myType->CreateType();
   myAssembly->Save( String::Concat( myAsmName->Name, L".dll" ) );

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

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

   List<Example^>^ listX = 
       (List<Example^>^) mi->Invoke(nullptr, arguments);

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

   DisplayGenericParameters(finished);
}

/* This code example produces the following output:

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

There are 2 elements in the List<Example>.

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

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

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

public interface IExampleA {}

public interface IExampleB {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        DisplayGenericParameters(finished);
    }

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

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

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

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

            ListConstraintAttributes(tParam);
        }
    }

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

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

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

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

/* This code example produces the following output:

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

There are 2 elements in the List<Example>.

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

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Collections.Generic

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

Public Interface IExampleA
End Interface

Public Interface IExampleB
End Interface

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        DisplayGenericParameters(finished)
    End Sub

    Private Shared Sub DisplayGenericParameters(ByVal t As Type)

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

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

        For Each tParam As Type In typeParameters

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

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

            ListConstraintAttributes(tParam)
        Next tParam
    End Sub

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

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

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

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

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

    End Sub 

End Class

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

Poznámky

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

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

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

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

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

Konstruktory

GenericTypeParameterBuilder()

Inicializuje novou instanci GenericTypeParameterBuilder třídy.

Vlastnosti

Assembly

Assembly Získá objekt představující dynamické sestavení, které obsahuje obecné definice typu aktuální typ parametru patří.

AssemblyQualifiedName

Získá null ve všech případech.

Attributes

Získá atributy přidružené k Type.

Attributes

Získá atributy přidružené k Type.

(Zděděno od Type)
Attributes

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

(Zděděno od TypeInfo)
BaseType

Získá omezení základního typu aktuálního parametru obecného typu.

ContainsGenericParameters

Získá true ve všech případech.

CustomAttributes

Získá kolekci, která obsahuje vlastní atributy tohoto člena.

(Zděděno od MemberInfo)
DeclaredConstructors

Získá kolekci konstruktorů deklarovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaredEvents

Získá kolekci událostí definovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaredFields

Získá kolekci polí definovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaredMembers

Získá kolekci členů definovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaredMethods

Získá kolekci metod definovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaredNestedTypes

Získá kolekci vnořených typů definovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaredProperties

Získá kolekci vlastností definovaných aktuálním typem.

(Zděděno od TypeInfo)
DeclaringMethod

Získá objekt MethodInfo , který představuje deklarující metodu, pokud aktuální GenericTypeParameterBuilder představuje typ parametru obecné metody.

DeclaringType

Získá definici obecného typu nebo definici obecné metody, do které patří parametr obecného typu.

FullName

Získá null ve všech případech.

GenericParameterAttributes

Získá kombinaci GenericParameterAttributes příznaků, které popisují kovarianci a speciální omezení aktuálního obecného typu parametru.

GenericParameterAttributes

Získá kombinaci GenericParameterAttributes příznaků, které popisují kovarianci a speciální omezení aktuálního obecného typu parametru.

(Zděděno od Type)
GenericParameterPosition

Získá pozici parametru typu v seznamu parametrů typu obecného typu nebo metody, která deklarovala parametr.

GenericTypeArguments

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

GenericTypeArguments

Získá pole argumentů obecného typu pro tento typ.

(Zděděno od Type)
GenericTypeArguments

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

(Zděděno od TypeInfo)
GenericTypeParameters

Získá pole parametrů obecného typu aktuální instance.

(Zděděno od TypeInfo)
GUID

Nepodporuje se pro neúplné parametry obecného typu.

HasElementType

Získá hodnotu označující, zda aktuální Type zahrnuje nebo odkazuje na jiný typ; to znamená, zda je aktuální Type pole, ukazatel, nebo je předán pomocí odkazu.

(Zděděno od Type)
HasElementType

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

(Zděděno od TypeInfo)
ImplementedInterfaces

Získá kolekci rozhraní implementovaných aktuálním typem.

(Zděděno od TypeInfo)
IsAbstract

Získá hodnotu označující, zda Type je abstraktní a musí být přepsána.

(Zděděno od Type)
IsAbstract

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

(Zděděno od TypeInfo)
IsAnsiClass

Získá hodnotu označující, zda je atribut formátu AnsiClass řetězce vybrán pro Type.

(Zděděno od Type)
IsAnsiClass

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

(Zděděno od TypeInfo)
IsArray

Získá hodnotu, která označuje, zda je typ pole.

(Zděděno od Type)
IsArray

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

(Zděděno od TypeInfo)
IsAutoClass

Získá hodnotu označující, zda je atribut formátu AutoClass řetězce vybrán pro Type.

(Zděděno od Type)
IsAutoClass

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

(Zděděno od TypeInfo)
IsAutoLayout

Získá hodnotu označující, zda pole aktuálního typu jsou automaticky rozloženy modulem CLR (Common Language Runtime).

(Zděděno od Type)
IsAutoLayout

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

(Zděděno od TypeInfo)
IsByRef

Získá hodnotu označující, zda Type je předán odkaz.

(Zděděno od Type)
IsByRef

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

(Zděděno od TypeInfo)
IsByRefLike

Získá hodnotu, která označuje, zda typ je byref-like struktury.

IsByRefLike

Získá hodnotu, která označuje, zda je typ byref-like struktury.

(Zděděno od Type)
IsClass

Získá hodnotu označující, zda Type je třída nebo delegát; to znamená, že ne typ hodnoty nebo rozhraní.

(Zděděno od Type)
IsClass

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

(Zděděno od TypeInfo)
IsCollectible

Získá hodnotu, která označuje, zda je tento MemberInfo objekt součástí sestavení uchovávaného v collectible AssemblyLoadContext.

(Zděděno od MemberInfo)
IsCOMObject

Získá hodnotu označující, zda Type je objekt COM.

(Zděděno od Type)
IsCOMObject

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

(Zděděno od TypeInfo)
IsConstructedGenericType

Získá hodnotu, která označuje, zda tento objekt představuje vytvořený obecný typ.

IsConstructedGenericType

Získá hodnotu, která označuje, zda tento objekt představuje vytvořený obecný typ. Můžete vytvořit instance vytvořeného obecného typu.

(Zděděno od Type)
IsContextful

Získá hodnotu označující, zda Type lze hostovat v kontextu.

(Zděděno od Type)
IsEnum

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

IsEnum

Získá hodnotu označující, zda aktuální Type představuje výčet.

(Zděděno od Type)
IsEnum

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

(Zděděno od TypeInfo)
IsExplicitLayout

Získá hodnotu označující, zda pole aktuálního typu jsou rozloženy na explicitně zadané posuny.

(Zděděno od Type)
IsExplicitLayout

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

(Zděděno od TypeInfo)
IsFunctionPointer

Získá hodnotu, která označuje, zda Type aktuální je ukazatel funkce.

(Zděděno od Type)
IsGenericMethodParameter

Získá hodnotu, která označuje, zda aktuální Type představuje parametr typu v definici obecné metody.

(Zděděno od Type)
IsGenericParameter

Získá true ve všech případech.

IsGenericType

Vrátí false se ve všech případech.

IsGenericTypeDefinition

Získá false ve všech případech.

IsGenericTypeParameter

Získá hodnotu, která označuje, zda aktuální Type představuje parametr typu v definici obecného typu.

(Zděděno od Type)
IsImport

Získá hodnotu označující, zda TypeComImportAttribute atribut použitý, což označuje, že byl importován z knihovny typů modelu COM.

(Zděděno od Type)
IsImport

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

(Zděděno od TypeInfo)
IsInterface

Získá hodnotu označující, zda Type je rozhraní; to znamená, že třída nebo typ hodnoty.

(Zděděno od Type)
IsInterface

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

(Zděděno od TypeInfo)
IsLayoutSequential

Získá hodnotu označující, zda pole aktuálního typu jsou rozloženy postupně v pořadí, v jakém byly definovány nebo generovány do metadat.

(Zděděno od Type)
IsLayoutSequential

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

(Zděděno od TypeInfo)
IsMarshalByRef

Získá hodnotu označující, zda Type je zařazován odkazem.

(Zděděno od Type)
IsMarshalByRef

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

(Zděděno od TypeInfo)
IsNested

Získá hodnotu označující, zda aktuální Type objekt představuje typ, jehož definice je vnořena uvnitř definice jiného typu.

(Zděděno od Type)
IsNested

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

(Zděděno od TypeInfo)
IsNestedAssembly

Získá hodnotu označující, zda Type je vnořený a viditelný pouze v rámci vlastní sestavení.

(Zděděno od Type)
IsNestedAssembly

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

(Zděděno od TypeInfo)
IsNestedFamANDAssem

Získá hodnotu označující, zda Type je vnořený a viditelný pouze třídy, které patří do jeho vlastní rodiny i vlastní sestavení.

(Zděděno od Type)
IsNestedFamANDAssem

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

(Zděděno od TypeInfo)
IsNestedFamily

Získá hodnotu označující, zda Type je vnořený a viditelný pouze v rámci své vlastní rodiny.

(Zděděno od Type)
IsNestedFamily

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

(Zděděno od TypeInfo)
IsNestedFamORAssem

Získá hodnotu označující, zda Type je vnořený a viditelný pouze třídy, které patří buď do vlastní rodiny, nebo do vlastního sestavení.

(Zděděno od Type)
IsNestedFamORAssem

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

(Zděděno od TypeInfo)
IsNestedPrivate

Získá hodnotu označující, zda je vnořený Type a deklarován privátní.

(Zděděno od Type)
IsNestedPrivate

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

(Zděděno od TypeInfo)
IsNestedPublic

Získá hodnotu označující, zda je třída vnořená a deklarována veřejná.

(Zděděno od Type)
IsNestedPublic

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

(Zděděno od TypeInfo)
IsNotPublic

Získá hodnotu označující, zda Type není deklarován veřejný.

(Zděděno od Type)
IsNotPublic

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

(Zděděno od TypeInfo)
IsPointer

Získá hodnotu označující, zda Type je ukazatel.

(Zděděno od Type)
IsPointer

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

(Zděděno od TypeInfo)
IsPrimitive

Získá hodnotu označující, zda Type je jedním z primitivních typů.

(Zděděno od Type)
IsPrimitive

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

(Zděděno od TypeInfo)
IsPublic

Získá hodnotu označující, zda Type je deklarován veřejný.

(Zděděno od Type)
IsPublic

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

(Zděděno od TypeInfo)
IsSealed

Získá hodnotu označující, zda Type je deklarován zapečetěný.

(Zděděno od Type)
IsSealed

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

(Zděděno od TypeInfo)
IsSecurityCritical

Získá hodnotu, která označuje, zda aktuální typ je kritický zabezpečení nebo zabezpečení-bezpečné-kritické na aktuální úrovni důvěryhodnosti, a proto může provádět kritické operace.

(Zděděno od Type)
IsSecuritySafeCritical

Získá hodnotu, která označuje, zda aktuální typ je zabezpečení-kritický na aktuální úroveň důvěryhodnosti; to znamená, zda může provádět kritické operace a může být přístupný transparentním kódem.

(Zděděno od Type)
IsSecurityTransparent

Získá hodnotu, která označuje, zda aktuální typ je transparentní na aktuální úrovni důvěryhodnosti, a proto nelze provádět kritické operace.

(Zděděno od Type)
IsSerializable

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

IsSerializable
Zastaralé.

Získá hodnotu označující, zda Type je binární serializovatelný.

(Zděděno od Type)
IsSerializable

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

(Zděděno od TypeInfo)
IsSignatureType

Získá hodnotu, která označuje, zda typ je typ podpisu.

(Zděděno od Type)
IsSpecialName

Získá hodnotu označující, zda typ má název, který vyžaduje speciální zpracování.

(Zděděno od Type)
IsSpecialName

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

(Zděděno od TypeInfo)
IsSZArray

Získá hodnotu, která označuje, zda typ je typ pole, který může představovat pouze jednorozměrné pole s nulovou dolní mez.

IsSZArray

Získá hodnotu, která označuje, zda typ je typ pole, který může představovat pouze jednorozměrné pole s nulovou dolní mez.

(Zděděno od Type)
IsTypeDefinition

Získá hodnotu, která označuje, zda typ je definice typu.

IsTypeDefinition

Získá hodnotu, která označuje, zda typ je definice typu.

(Zděděno od Type)
IsUnicodeClass

Získá hodnotu označující, zda je atribut formátu UnicodeClass řetězce vybrán pro Type.

(Zděděno od Type)
IsUnicodeClass

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

(Zděděno od TypeInfo)
IsUnmanagedFunctionPointer

Získá hodnotu, která označuje, zda Type aktuální je nespravovaný ukazatel funkce.

(Zděděno od Type)
IsValueType

Získá hodnotu označující, zda Type je typ hodnoty.

(Zděděno od Type)
IsValueType

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

(Zděděno od TypeInfo)
IsVariableBoundArray

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

IsVariableBoundArray

Získá hodnotu, která označuje, zda typ je typ pole, který může představovat vícerozměrné pole nebo pole s libovolnou dolní mez.

(Zděděno od Type)
IsVisible

Získá hodnotu označující, zda Type lze přistupovat kódem mimo sestavení.

(Zděděno od Type)
IsVisible

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

(Zděděno od TypeInfo)
MemberType

MemberTypes Získá hodnotu označující, že tento člen je typ nebo vnořený typ.

(Zděděno od Type)
MemberType

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

(Zděděno od TypeInfo)
MetadataToken

Získá token, který identifikuje aktuální dynamický modul v metadatech.

MetadataToken

Získá hodnotu, která identifikuje prvek metadat.

(Zděděno od MemberInfo)
Module

Získá dynamický modul, který obsahuje parametr obecného typu.

Name

Získá název parametru obecného typu.

Namespace

Získá null ve všech případech.

ReflectedType

Type Získá objekt, který byl použit k získání .GenericTypeParameterBuilder

ReflectedType

Získá objekt třídy, který byl použit k získání této instance .MemberInfo

(Zděděno od MemberInfo)
StructLayoutAttribute

Získá, StructLayoutAttribute který popisuje rozložení aktuálního typu.

(Zděděno od Type)
StructLayoutAttribute

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

(Zděděno od TypeInfo)
TypeHandle

Nepodporuje se pro neúplné parametry obecného typu.

TypeInitializer

Získá inicializátor pro typ.

(Zděděno od Type)
TypeInitializer

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

(Zděděno od TypeInfo)
UnderlyingSystemType

Získá aktuální parametr obecného typu.

UnderlyingSystemType

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

(Zděděno od TypeInfo)

Metody

AsType()

Vrátí aktuální typ jako Type objekt.

(Zděděno od TypeInfo)
Equals(Object)

Testuje, zda daný objekt je instancí EventToken a je roven aktuální instanci.

Equals(Type)

Určuje, zda je typ základního systému aktuálního Type systému stejný jako typ základního systému zadaného Type.

(Zděděno od Type)
FindInterfaces(TypeFilter, Object)

Vrátí pole Type objektů představující filtrovaný seznam rozhraní implementovaných nebo zděděných aktuálním Typeobjektem .

(Zděděno od Type)
FindInterfaces(TypeFilter, Object)

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

(Zděděno od TypeInfo)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Vrátí filtrované pole MemberInfo objektů zadaného typu členu.

(Zděděno od Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

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

(Zděděno od TypeInfo)
GetArrayRank()

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

GetArrayRank()

Získá počet dimenzí v poli.

(Zděděno od Type)
GetArrayRank()

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

(Zděděno od TypeInfo)
GetAttributeFlagsImpl()

Při přepsání v odvozené třídě implementuje Attributes vlastnost a získá bitové kombinace hodnot výčtu, které označují atributy přidružené k Type.

GetAttributeFlagsImpl()

Při přepsání v odvozené třídě implementuje Attributes vlastnost a získá bitovou kombinaci hodnot výčtu, která označuje atributy přidružené k Type.

(Zděděno od Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení.

(Zděděno od Type)
GetConstructor(BindingFlags, Type[])

Vyhledá konstruktor, jehož parametry odpovídají zadaným typům argumentů pomocí zadaných vazeb omezení.

(Zděděno od Type)
GetConstructor(Type[])

Vyhledá konstruktor veřejné instance, jehož parametry odpovídají typům v zadaném poli.

(Zděděno od Type)
GetConstructor(Type[])

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

(Zděděno od TypeInfo)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Nepodporuje se pro neúplné parametry obecného typu.

GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Při přepsání v odvozené třídě hledá konstruktor, jehož parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetConstructors()

Vrátí všechny veřejné konstruktory definované pro aktuální Type.

(Zděděno od Type)
GetConstructors()

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

(Zděděno od TypeInfo)
GetConstructors(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetConstructors(BindingFlags)

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

(Zděděno od TypeInfo)
GetCustomAttributes(Boolean)

Nepodporuje se pro neúplné parametry obecného typu.

GetCustomAttributes(Boolean)

Při přepsání v odvozené třídě vrátí pole všech vlastních atributů použitých pro tento člen.

(Zděděno od MemberInfo)
GetCustomAttributes(Type, Boolean)

Nepodporuje se pro neúplné parametry obecného typu.

GetCustomAttributes(Type, Boolean)

Při přepsání v odvozené třídě vrátí pole vlastních atributů použitých u tohoto člena a identifikovaných pomocí Type.

(Zděděno od MemberInfo)
GetCustomAttributesData()

Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity na cílového člena.

(Zděděno od MemberInfo)
GetDeclaredEvent(String)

Vrátí objekt, který představuje zadanou událost deklarovanou aktuálním typem.

(Zděděno od TypeInfo)
GetDeclaredField(String)

Vrátí objekt, který představuje zadané pole deklarované aktuálním typem.

(Zděděno od TypeInfo)
GetDeclaredMethod(String)

Vrátí objekt, který představuje zadanou metodu deklarovanou aktuálním typem.

(Zděděno od TypeInfo)
GetDeclaredMethods(String)

Vrátí kolekci, která obsahuje všechny metody deklarované u aktuálního typu, které odpovídají zadanému názvu.

(Zděděno od TypeInfo)
GetDeclaredNestedType(String)

Vrátí objekt, který představuje zadaný vnořený typ deklarovaný aktuálním typem.

(Zděděno od TypeInfo)
GetDeclaredProperty(String)

Vrátí objekt, který představuje zadanou vlastnost deklarovanou aktuálním typem.

(Zděděno od TypeInfo)
GetDefaultMembers()

Vyhledá členy definované pro aktuální Type , jehož DefaultMemberAttribute hodnota je nastavena.

(Zděděno od Type)
GetDefaultMembers()

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

(Zděděno od TypeInfo)
GetElementType()

Ve všech případech vyvolá chybu NotSupportedException .

GetEnumName(Object)

Vrátí název konstanty, která má zadanou hodnotu pro aktuální typ výčtu.

(Zděděno od Type)
GetEnumName(Object)

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

(Zděděno od TypeInfo)
GetEnumNames()

Vrátí názvy členů aktuálního typu výčtu.

(Zděděno od Type)
GetEnumNames()

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

(Zděděno od TypeInfo)
GetEnumUnderlyingType()

Vrátí podkladový typ aktuálního typu výčtu.

(Zděděno od Type)
GetEnumUnderlyingType()

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

(Zděděno od TypeInfo)
GetEnumValues()

Vrátí matici hodnot konstant v aktuálním typu výčtu.

(Zděděno od Type)
GetEnumValues()

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

(Zděděno od TypeInfo)
GetEnumValuesAsUnderlyingType()

Načte pole hodnot základních konstant typu tohoto typu výčtu.

(Zděděno od Type)
GetEvent(String)

EventInfo Vrátí objekt představující zadanou veřejnou událost.

(Zděděno od Type)
GetEvent(String)

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

(Zděděno od TypeInfo)
GetEvent(String, BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetEvent(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetEvents()

Nepodporuje se pro neúplné parametry obecného typu.

GetEvents()

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

(Zděděno od TypeInfo)
GetEvents(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetEvents(BindingFlags)

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

(Zděděno od TypeInfo)
GetField(String)

Vyhledá veřejné pole se zadaným názvem.

(Zděděno od Type)
GetField(String)

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

(Zděděno od TypeInfo)
GetField(String, BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetField(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetFields()

Vrátí všechna veřejná pole aktuálního Typepole .

(Zděděno od Type)
GetFields()

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

(Zděděno od TypeInfo)
GetFields(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetFields(BindingFlags)

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

(Zděděno od TypeInfo)
GetFunctionPointerCallingConventions()

Při přepsání v odvozené třídě vrátí konvence volání aktuálního ukazatele Typena funkci .

(Zděděno od Type)
GetFunctionPointerParameterTypes()

Při přepsání v odvozené třídě vrátí typy parametrů aktuálního ukazatele Typena funkci .

(Zděděno od Type)
GetFunctionPointerReturnType()

Při přepsání v odvozené třídě vrátí návratový typ aktuálního ukazatele Typena funkci .

(Zděděno od Type)
GetGenericArguments()

Neplatí pro parametry obecného typu.

GetGenericArguments()

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

(Zděděno od TypeInfo)
GetGenericParameterConstraints()

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

GetGenericParameterConstraints()

Vrátí pole Type objektů, které představují omezení aktuálního parametru obecného typu.

(Zděděno od Type)
GetGenericParameterConstraints()

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

(Zděděno od TypeInfo)
GetGenericTypeDefinition()

Neplatí pro parametry obecného typu.

GetHashCode()

Vrátí 32bitový celočíselný hashový kód pro aktuální instanci.

GetInterface(String)

Vyhledá rozhraní se zadaným názvem.

(Zděděno od Type)
GetInterface(String)

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

(Zděděno od TypeInfo)
GetInterface(String, Boolean)

Nepodporuje se pro neúplné parametry obecného typu.

GetInterface(String, Boolean)

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

(Zděděno od TypeInfo)
GetInterfaceMap(Type)

Nepodporuje se pro neúplné parametry obecného typu.

GetInterfaces()

Nepodporuje se pro neúplné parametry obecného typu.

GetInterfaces()

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

(Zděděno od TypeInfo)
GetMember(String)

Vyhledá veřejné členy se zadaným názvem.

(Zděděno od Type)
GetMember(String)

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

(Zděděno od TypeInfo)
GetMember(String, BindingFlags)

Vyhledá zadané členy pomocí zadaných omezení vazby.

(Zděděno od Type)
GetMember(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetMember(String, MemberTypes, BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetMember(String, MemberTypes, BindingFlags)

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

(Zděděno od TypeInfo)
GetMembers()

Vrátí všechny veřejné členy aktuálního Type.

(Zděděno od Type)
GetMembers()

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

(Zděděno od TypeInfo)
GetMembers(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetMembers(BindingFlags)

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

(Zděděno od TypeInfo)
GetMemberWithSameMetadataDefinitionAs(MemberInfo)

Vyhledá u MemberInfo aktuálního Type , který odpovídá zadané MemberInfohodnotě .

(Zděděno od Type)
GetMethod(String)

Vyhledá veřejnou metodu se zadaným názvem.

(Zděděno od Type)
GetMethod(String)

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

(Zděděno od TypeInfo)
GetMethod(String, BindingFlags)

Vyhledá zadanou metodu pomocí zadaných omezení vazby.

(Zděděno od Type)
GetMethod(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení.

(Zděděno od Type)
GetMethod(String, BindingFlags, Type[])

Vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů, pomocí zadaných vazeb omezení.

(Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných vazebních omezení.

(Zděděno od Type)
GetMethod(String, Int32, BindingFlags, Type[])

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

(Zděděno od Type)
GetMethod(String, Int32, Type[])

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů a typům argumentů.

(Zděděno od Type)
GetMethod(String, Int32, Type[], ParameterModifier[])

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům.

(Zděděno od Type)
GetMethod(String, Type[])

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů.

(Zděděno od Type)
GetMethod(String, Type[])

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

(Zděděno od TypeInfo)
GetMethod(String, Type[], ParameterModifier[])

Vyhledá zadanou veřejnou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům.

(Zděděno od Type)
GetMethod(String, Type[], ParameterModifier[])

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

(Zděděno od TypeInfo)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Nepodporuje se pro neúplné parametry obecného typu.

GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Při přepsání v odvozené třídě vyhledá zadanou metodu, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Při přepsání v odvozené třídě vyhledá zadanou metodu, jejíž parametry odpovídají zadanému počtu obecných parametrů, typům argumentů a modifikátorům, pomocí zadaných vazeb omezení a zadané konvence volání.

(Zděděno od Type)
GetMethods()

Vrátí všechny veřejné metody aktuálního Typeobjektu .

(Zděděno od Type)
GetMethods()

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

(Zděděno od TypeInfo)
GetMethods(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetMethods(BindingFlags)

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

(Zděděno od TypeInfo)
GetNestedType(String)

Vyhledá veřejný vnořený typ se zadaným názvem.

(Zděděno od Type)
GetNestedType(String)

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

(Zděděno od TypeInfo)
GetNestedType(String, BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetNestedType(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetNestedTypes()

Vrátí veřejné typy vnořené do aktuálního Type.

(Zděděno od Type)
GetNestedTypes()

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

(Zděděno od TypeInfo)
GetNestedTypes(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetNestedTypes(BindingFlags)

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

(Zděděno od TypeInfo)
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()

Vrátí všechny veřejné vlastnosti aktuálního Typeobjektu .

(Zděděno od Type)
GetProperties()

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

(Zděděno od TypeInfo)
GetProperties(BindingFlags)

Nepodporuje se pro neúplné parametry obecného typu.

GetProperties(BindingFlags)

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

(Zděděno od TypeInfo)
GetProperty(String)

Vyhledá veřejnou vlastnost se zadaným názvem.

(Zděděno od Type)
GetProperty(String)

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

(Zděděno od TypeInfo)
GetProperty(String, BindingFlags)

Vyhledá zadanou vlastnost pomocí zadaných omezení vazby.

(Zděděno od Type)
GetProperty(String, BindingFlags)

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

(Zděděno od TypeInfo)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Vyhledá zadanou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení.

(Zděděno od Type)
GetProperty(String, Type)

Vyhledá veřejnou vlastnost se zadaným názvem a návratovým typem.

(Zděděno od Type)
GetProperty(String, Type)

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

(Zděděno od TypeInfo)
GetProperty(String, Type, Type[])

Vyhledá zadanou veřejnou vlastnost, jejíž parametry odpovídají zadaným typům argumentů.

(Zděděno od Type)
GetProperty(String, Type, Type[])

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

(Zděděno od TypeInfo)
GetProperty(String, Type, Type[], ParameterModifier[])

Vyhledá zadanou veřejnou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům.

(Zděděno od Type)
GetProperty(String, Type, Type[], ParameterModifier[])

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

(Zděděno od TypeInfo)
GetProperty(String, Type[])

Vyhledá zadanou veřejnou vlastnost, jejíž parametry odpovídají zadaným typům argumentů.

(Zděděno od Type)
GetProperty(String, Type[])

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

(Zděděno od TypeInfo)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Nepodporuje se pro neúplné parametry obecného typu.

GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Při přepsání v odvozené třídě vyhledá zadanou vlastnost, jejíž parametry odpovídají zadaným typům argumentů a modifikátorům, pomocí zadaných vazeb omezení.

(Zděděno od Type)
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)
GetType()

Zjistí atributy člena a poskytuje přístup k metadatům člena.

(Zděděno od MemberInfo)
GetTypeCodeImpl()

Vrátí kód základního typu této Type instance.

(Zděděno od Type)
HasElementTypeImpl()

Při přepsání v odvozené třídě implementuje HasElementType vlastnost a určuje, zda proud Type zahrnuje nebo odkazuje na jiný typ; to znamená, zda je proud Type pole, ukazatel, nebo je předán odkazem.

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 proud Type pole, ukazatel, nebo je předán odkazem.

(Zděděno od Type)
HasSameMetadataDefinitionAs(MemberInfo)

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

(Zděděno od MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Vyvolá zadaný člen pomocí omezení zadané vazby a odpovídající seznamu zadaných argumentů.

(Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Vyvolá zadaný člen pomocí zadaných vazeb omezení a odpovídající zadanému seznamu argumentů a jazykové verzi.

(Zděděno od Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Nepodporuje se pro neúplné parametry obecného typu.

IsArrayImpl()

Při přepsání v odvozené třídě implementuje IsArray vlastnost a určuje, zda Type je pole.

IsArrayImpl()

Při přepsání v odvozené třídě implementuje IsArray vlastnost a určuje, zda Type je pole.

(Zděděno od Type)
IsAssignableFrom(Type)

Ve všech případech vyvolá NotSupportedException výjimku.

IsAssignableFrom(Type)

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

(Zděděno od TypeInfo)
IsAssignableFrom(TypeInfo)

Ve všech případech vyvolá NotSupportedException výjimku.

IsAssignableTo(Type)

Určuje, zda lze aktuální typ přiřadit proměnné zadaného targetTypetypu .

(Zděděno od Type)
IsByRefImpl()

Při přepsání v odvozené třídě implementuje IsByRef vlastnost a určuje, zda Type je předán odkaz.

IsByRefImpl()

Při přepsání v odvozené třídě implementuje IsByRef vlastnost a určuje, zda Type je předán odkaz.

(Zděděno od Type)
IsCOMObjectImpl()

Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt com.

IsCOMObjectImpl()

Při přepsání v odvozené třídě implementuje IsCOMObject vlastnost a určuje, zda Type je objekt com.

(Zděděno od Type)
IsContextfulImpl()

Implementuje IsContextful vlastnost a určuje, zda Type lze hostovat v kontextu.

(Zděděno od Type)
IsDefined(Type, Boolean)

Nepodporuje se pro neúplné parametry obecného typu.

IsDefined(Type, Boolean)

Při přepsání v odvozené třídě, označuje, zda jeden nebo více atributů zadaného typu nebo jeho odvozených typů je použito na tento člen.

(Zděděno od MemberInfo)
IsEnumDefined(Object)

Vrátí hodnotu, která označuje, zda zadaná hodnota existuje v aktuálním typu výčtu.

(Zděděno od Type)
IsEnumDefined(Object)

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

(Zděděno od TypeInfo)
IsEquivalentTo(Type)

Určuje, zda dva typy modelu COM mají stejnou identitu a jsou způsobilé pro ekvivalenci typů.

(Zděděno od Type)
IsEquivalentTo(Type)

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

(Zděděno od TypeInfo)
IsInstanceOfType(Object)

Určuje, zda je zadaný objekt instancí aktuálního Typeobjektu .

(Zděděno od Type)
IsInstanceOfType(Object)

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

(Zděděno od TypeInfo)
IsMarshalByRefImpl()

Implementuje IsMarshalByRef vlastnost a určuje, zda Type je zařazován odkazem.

(Zděděno od Type)
IsPointerImpl()

Při přepsání v odvozené třídě implementuje IsPointer vlastnost a určuje, zda Type je ukazatel.

IsPointerImpl()

Při přepsání v odvozené třídě implementuje IsPointer vlastnost a určuje, zda Type je ukazatel.

(Zděděno od Type)
IsPrimitiveImpl()

Při přepsání v odvozené třídě implementuje IsPrimitive vlastnost a určuje, zda Type je jeden z primitivních typů.

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ů.

(Zděděno od Type)
IsSubclassOf(Type)

Nepodporuje se pro neúplné parametry obecného typu.

IsValueTypeImpl()

Implementuje IsValueType vlastnost a určuje, zda Type je typ hodnoty, tj. nikoli třída nebo rozhraní.

IsValueTypeImpl()

Implementuje IsValueType vlastnost a určuje, zda Type je typ hodnoty, tj. nikoli třída nebo rozhraní.

(Zděděno od Type)
MakeArrayType()

Vrátí typ jednorozměrného pole, jehož typ prvku je parametr obecného typu.

MakeArrayType(Int32)

Vrátí typ pole, jehož typ prvku je parametr obecného typu se zadaným počtem dimenzí.

MakeByRefType()

Type Vrátí objekt, který představuje aktuální parametr obecného typu při předání jako referenční parametr.

MakeGenericType(Type[])

Není platné pro neúplné parametry obecného typu.

MakePointerType()

Type Vrátí objekt, který představuje ukazatel na aktuální parametr obecného typu.

MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
SetBaseTypeConstraint(Type)

Nastaví základní typ, který musí typ dědit, aby byl nahrazen parametrem typu.

SetBaseTypeConstraintCore(Type)

Při přepsání v odvozené třídě nastaví základní typ, který musí typ dědit, aby byl nahrazen parametrem typu.

SetCustomAttribute(ConstructorInfo, Byte[])

Nastaví vlastní atribut pomocí zadaného objektu blob vlastního atributu.

SetCustomAttribute(CustomAttributeBuilder)

Nastavte vlastní atribut pomocí vlastního tvůrce atributů.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Při přepsání v odvozené třídě nastaví vlastní atribut v tomto sestavení.

SetGenericParameterAttributes(GenericParameterAttributes)

Nastaví rozptylové charakteristiky a speciální omezení obecného parametru, například omezení konstruktoru bez parametrů.

SetGenericParameterAttributesCore(GenericParameterAttributes)

Při přepsání v odvozené třídě nastaví rozptylové charakteristiky a speciální omezení obecného parametru, jako je omezení konstruktoru bez parametrů.

SetInterfaceConstraints(Type[])

Nastaví rozhraní, která musí typ implementovat, aby byl nahrazen parametrem typu.

SetInterfaceConstraintsCore(Type[])

Při přepsání v odvozené třídě nastaví rozhraní, která musí typ implementovat, aby byl nahrazen parametrem typu.

ToString()

Vrátí řetězcovou reprezentaci aktuálního parametru obecného typu.

Explicitní implementace rozhraní

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od MemberInfo)
_MemberInfo.GetType()

Type Získá objekt představující MemberInfo třídu .

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

(Zděděno od Type)
_Type.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od Type)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Vrátí pole všech vlastních atributů definovaných v tomto členu, s výjimkou pojmenovaných atributů, nebo prázdné pole, pokud neexistují žádné vlastní atributy.

(Zděděno od MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Vrátí pole vlastních atributů definovaných v tomto členu, identifikované typem nebo prázdné pole, pokud neexistují žádné vlastní atributy tohoto typu.

(Zděděno od MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Určuje, zda je u tohoto člena attributeType definována jedna nebo více instancí.

(Zděděno od MemberInfo)
IReflectableType.GetTypeInfo()

Vrátí reprezentaci aktuálního typu jako objektu TypeInfo .

(Zděděno od TypeInfo)

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)

Načte vlastní atribut zadaného typu, který je použit na zadaného člena.

GetCustomAttribute(MemberInfo, Type, Boolean)

Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.

GetCustomAttribute<T>(MemberInfo)

Načte vlastní atribut zadaného typu, který je použit na zadaného člena.

GetCustomAttribute<T>(MemberInfo, Boolean)

Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.

GetCustomAttributes(MemberInfo)

Načte kolekci vlastních atributů, které jsou použity na zadaného člena.

GetCustomAttributes(MemberInfo, Boolean)

Načte kolekci vlastních atributů, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena.

GetCustomAttributes(MemberInfo, Type)

Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.

GetCustomAttributes(MemberInfo, Type, Boolean)

Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.

GetCustomAttributes<T>(MemberInfo)

Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.

GetCustomAttributes<T>(MemberInfo, Boolean)

Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.

IsDefined(MemberInfo, Type)

Určuje, zda jsou na zadaného člena použity vlastní atributy zadaného typu.

IsDefined(MemberInfo, Type, Boolean)

Určuje, zda se vlastní atributy zadaného typu použijí na zadaného člena a volitelně se použijí na jeho předky.

GetTypeInfo(Type)

Vrátí reprezentaci TypeInfo zadaného typu.

GetMetadataToken(MemberInfo)

Získá token metadat pro daný člen, pokud je k dispozici.

HasMetadataToken(MemberInfo)

Vrátí hodnotu, která označuje, zda je token metadat k dispozici pro zadaného člena.

GetRuntimeEvent(Type, String)

Načte objekt, který představuje zadanou událost.

GetRuntimeEvents(Type)

Načte kolekci, která představuje všechny události definované na zadaném typu.

GetRuntimeField(Type, String)

Načte objekt, který představuje zadané pole.

GetRuntimeFields(Type)

Načte kolekci, která představuje všechna pole definovaná na zadaném typu.

GetRuntimeInterfaceMap(TypeInfo, Type)

Vrátí mapování rozhraní pro zadaný typ a zadané rozhraní.

GetRuntimeMethod(Type, String, Type[])

Načte objekt, který představuje zadanou metodu.

GetRuntimeMethods(Type)

Načte kolekci, která představuje všechny metody definované na zadaném typu.

GetRuntimeProperties(Type)

Načte kolekci, která představuje všechny vlastnosti definované na zadaném typu.

GetRuntimeProperty(Type, String)

Načte objekt, který představuje zadanou vlastnost.

GetConstructor(Type, Type[])

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

GetConstructors(Type)

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

GetConstructors(Type, BindingFlags)

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

GetFields(Type, BindingFlags)

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

GetGenericArguments(Type)

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

GetInterfaces(Type)

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

GetMember(Type, String)

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

GetMember(Type, String, BindingFlags)

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

GetMembers(Type)

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

GetMethods(Type)

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

GetNestedType(Type, String, BindingFlags)

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

GetProperties(Type)

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

GetProperties(Type, BindingFlags)

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

GetProperty(Type, String, BindingFlags)

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

GetProperty(Type, String, Type)

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

GetProperty(Type, String, Type, Type[])

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

IsAssignableFrom(Type, Type)

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

IsInstanceOfType(Type, Object)

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

Platí pro

Viz také