GenericTypeParameterBuilder Classe

Définition

Définit et crée des paramètres de type générique pour les types et méthodes génériques définis dynamiquement.Defines and creates generic type parameters for dynamically defined generic types and methods. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class GenericTypeParameterBuilder sealed : System::Reflection::TypeInfo
public ref class GenericTypeParameterBuilder sealed : Type
public ref class GenericTypeParameterBuilder abstract : System::Reflection::TypeInfo
public sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfo
public sealed class GenericTypeParameterBuilder : Type
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder : Type
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class GenericTypeParameterBuilder : System.Reflection.TypeInfo
public abstract class GenericTypeParameterBuilder : System.Reflection.TypeInfo
type GenericTypeParameterBuilder = class
    inherit TypeInfo
type GenericTypeParameterBuilder = class
    inherit Type
Public NotInheritable Class GenericTypeParameterBuilder
Inherits TypeInfo
Public NotInheritable Class GenericTypeParameterBuilder
Inherits Type
Public MustInherit Class GenericTypeParameterBuilder
Inherits TypeInfo
Héritage
GenericTypeParameterBuilder
Héritage
GenericTypeParameterBuilder
Héritage
GenericTypeParameterBuilder
Attributs

Exemples

L’exemple de code suivant crée un type générique avec deux paramètres de type, et les enregistre dans l’assembly GenericEmitExample1. dll.The following code example creates a generic type with two type parameters, and saves them in the assembly GenericEmitExample1.dll. Vous pouvez utiliser Ildasm. exe (Désassembleur il) pour afficher les types générés.You can use the Ildasm.exe (IL Disassembler) to view the generated types. Pour obtenir une explication plus détaillée des étapes impliquées dans la définition d’un type générique dynamique, consultez Comment : définir un type générique avec l’émission de réflexion.For a more detailed explanation of the steps involved in defining a dynamic generic type, see How to: Define a Generic Type with Reflection Emit.

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

Remarques

Vous pouvez obtenir un tableau d’objets GenericTypeParameterBuilder à l’aide de la méthode TypeBuilder.DefineGenericParameters pour ajouter des paramètres de type à un type dynamique, ce qui en fait un type générique ou en utilisant la méthode MethodBuilder.DefineGenericParameters pour ajouter des paramètres de type à une méthode dynamique.You can get an array of GenericTypeParameterBuilder objects by using the TypeBuilder.DefineGenericParameters method to add type parameters to a dynamic type, thus making it a generic type, or by using the MethodBuilder.DefineGenericParameters method to add type parameters to a dynamic method. Utilisez les objets GenericTypeParameterBuilder pour ajouter des contraintes aux paramètres de type.Use the GenericTypeParameterBuilder objects to add constraints to the type parameters. Les contraintes sont de trois types :Constraints are of three kinds:

  • La contrainte de type de base spécifie que tout type assigné au paramètre de type générique doit dériver d’un type de base particulier.The base type constraint specifies that any type assigned to the generic type parameter must derive from a particular base type. Définissez cette contrainte à l’aide de la méthode SetBaseTypeConstraint.Set this constraint by using the SetBaseTypeConstraint method.

  • Une contrainte d’interface spécifie que tout type assigné au paramètre de type générique doit implémenter une interface particulière.An interface constraint specifies that any type assigned to the generic type parameter must implement a particular interface. Définissez les contraintes d’interface à l’aide de la méthode SetInterfaceConstraints.Set the interface constraints by using the SetInterfaceConstraints method.

  • Les contraintes spéciales spécifient que tout type assigné au paramètre de type générique doit avoir un constructeur sans paramètre, doit être un type référence ou un type valeur.Special constraints specify that any type assigned to the generic type parameter must have a parameterless constructor, must be a reference type, or must be a value type. Définissez les contraintes spéciales pour un paramètre de type à l’aide de la méthode SetGenericParameterAttributes.Set the special constraints for a type parameter by using the SetGenericParameterAttributes method.

Les contraintes d’interface et les contraintes spéciales ne peuvent pas être récupérées à l’aide des méthodes de la classe GenericTypeParameterBuilder.Interface constraints and special constraints cannot be retrieved using methods of the GenericTypeParameterBuilder class. Une fois que vous avez créé le type générique qui contient les paramètres de type, vous pouvez utiliser son objet Type pour refléter les contraintes.Once you have created the generic type that contains the type parameters, you can use its Type object to reflect the constraints. Utilisez la méthode Type.GetGenericArguments pour obtenir les paramètres de type, et pour chaque paramètre de type, utilisez la méthode Type.GetGenericParameterConstraints pour obtenir la contrainte de type de base et les contraintes d’interface, et la propriété Type.GenericParameterAttributes pour obtenir les contraintes spéciales.Use the Type.GetGenericArguments method to get the type parameters, and for each type parameter use the Type.GetGenericParameterConstraints method to get the base type constraint and interface constraints, and the Type.GenericParameterAttributes property to get the special constraints.

Propriétés

Assembly

Obtient un Assembly objet représentant l’assembly dynamique qui contient la définition de type générique à laquelle le paramètre de type actuel appartient.Gets an Assembly object representing the dynamic assembly that contains the generic type definition the current type parameter belongs to.

AssemblyQualifiedName

Obtient null dans tous les cas.Gets null in all cases.

Attributes
BaseType

Obtient la contrainte de type de base du paramètre de type générique actuel.Gets the base type constraint of the current generic type parameter.

ContainsGenericParameters

Obtient true dans tous les cas.Gets true in all cases.

CustomAttributes

Obtient une collection qui contient les attributs personnalisés de ce membre.Gets a collection that contains this member's custom attributes.

(Hérité de MemberInfo)
DeclaredConstructors

Obtient une collection des constructeurs déclarés par le type actuel.Gets a collection of the constructors declared by the current type.

(Hérité de TypeInfo)
DeclaredEvents

Obtient une collection des événements définis par le type actuel.Gets a collection of the events defined by the current type.

(Hérité de TypeInfo)
DeclaredFields

Obtient une collection des champs définis par le type actuel.Gets a collection of the fields defined by the current type.

(Hérité de TypeInfo)
DeclaredMembers

Obtient une collection du membre défini par le type actuel.Gets a collection of the members defined by the current type.

(Hérité de TypeInfo)
DeclaredMethods

Obtient une collection des méthodes définies par le type actuel.Gets a collection of the methods defined by the current type.

(Hérité de TypeInfo)
DeclaredNestedTypes

Obtient une collection des types imbriqués définis par le type actuel.Gets a collection of the nested types defined by the current type.

(Hérité de TypeInfo)
DeclaredProperties

Obtient la collection des propriétés définies par le type actuel.Gets a collection of the properties defined by the current type.

(Hérité de TypeInfo)
DeclaringMethod

Obtient un MethodInfo représentant la méthode de déclaration, si le GenericTypeParameterBuilder actuel représente un paramètre de type d'une méthode générique.Gets a MethodInfo that represents the declaring method, if the current GenericTypeParameterBuilder represents a type parameter of a generic method.

DeclaringType

Obtient la définition de type générique ou la définition de méthode générique à laquelle appartient le paramètre de type générique.Gets the generic type definition or generic method definition to which the generic type parameter belongs.

FullName

Obtient null dans tous les cas.Gets null in all cases.

GenericParameterAttributes

Obtient une combinaison d'indicateurs GenericParameterAttributes qui décrivent la covariance et des contraintes spéciales du paramètre de type générique actuel.Gets a combination of GenericParameterAttributes flags that describe the covariance and special constraints of the current generic type parameter.

GenericParameterPosition

Obtient la position du paramètre de type dans la liste des paramètres de type du type générique ou de la méthode qui a déclaré le paramètre.Gets the position of the type parameter in the type parameter list of the generic type or method that declared the parameter.

GenericTypeArguments
GenericTypeParameters

Obtient un tableau des paramètres de type génériques de l'instance actuelle.Gets an array of the generic type parameters of the current instance.

(Hérité de TypeInfo)
GUID

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

HasElementType

Obtient une valeur indiquant si le Type actuel englobe ou se réfère à un autre type, c'est-à-dire si le Type actuel est un tableau ou un pointeur ou encore s'il est passé par référence.Gets a value indicating whether the current Type encompasses or refers to another type; that is, whether the current Type is an array, a pointer, or is passed by reference.

(Hérité de Type)
ImplementedInterfaces

Obtient une collection d'interfaces implémentée par le type actuel.Gets a collection of the interfaces implemented by the current type.

(Hérité de TypeInfo)
IsAbstract

Obtient une valeur indiquant si le Type est abstrait et doit être substitué.Gets a value indicating whether the Type is abstract and must be overridden.

(Hérité de Type)
IsAnsiClass

Obtient une valeur indiquant si l'attribut de format de chaîne AnsiClass est sélectionné pour Type.Gets a value indicating whether the string format attribute AnsiClass is selected for the Type.

(Hérité de Type)
IsArray

Obtient une valeur qui indique si le type est un tableau.Gets a value that indicates whether the type is an array.

(Hérité de Type)
IsAutoClass

Obtient une valeur indiquant si l'attribut de format de chaîne AutoClass est sélectionné pour Type.Gets a value indicating whether the string format attribute AutoClass is selected for the Type.

(Hérité de Type)
IsAutoLayout

Obtient une valeur qui indique si les champs du type actuel sont placés automatiquement par le Common Language Runtime.Gets a value indicating whether the fields of the current type are laid out automatically by the common language runtime.

(Hérité de Type)
IsByRef

Obtient une valeur indiquant si Type est passé par référence.Gets a value indicating whether the Type is passed by reference.

(Hérité de Type)
IsByRefLike
IsClass

Obtient une valeur indiquant si le Type est une classe ou un délégué, c'est-à-dire ni un type valeur ni une interface.Gets a value indicating whether the Type is a class or a delegate; that is, not a value type or interface.

(Hérité de Type)
IsCollectible

Obtient une valeur qui indique si cet objet MemberInfo fait partie d’un assembly contenu dans un AssemblyLoadContext pouvant être collecté.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Hérité de MemberInfo)
IsCOMObject

Obtient une valeur indiquant si Type est un objet COM.Gets a value indicating whether the Type is a COM object.

(Hérité de Type)
IsConstructedGenericType

Obtient une valeur qui indique si cet objet représente un type générique construit.Gets a value that indicates whether this object represents a constructed generic type.

IsContextful

Obtient une valeur indiquant si Type peut être hébergé dans un contexte.Gets a value indicating whether the Type can be hosted in a context.

(Hérité de Type)
IsEnum
IsExplicitLayout

Obtient une valeur qui indique si les champs du type actuel sont placés aux offsets explicitement spécifiés.Gets a value indicating whether the fields of the current type are laid out at explicitly specified offsets.

(Hérité de Type)
IsGenericMethodParameter

Obtient une valeur indiquant si le Type actuel représente un paramètre de type dans la définition d’une méthode générique.Gets a value that indicates whether the current Type represents a type parameter in the definition of a generic method.

(Hérité de Type)
IsGenericParameter

Obtient true dans tous les cas.Gets true in all cases.

IsGenericType

Retourne false dans tous les cas.Returns false in all cases.

IsGenericTypeDefinition

Obtient false dans tous les cas.Gets false in all cases.

IsGenericTypeParameter

Obtient une valeur indiquant si le Type actuel représente un paramètre de type dans la définition d’un type générique.Gets a value that indicates whether the current Type represents a type parameter in the definition of a generic type.

(Hérité de Type)
IsImport

Obtient une valeur qui indique si le Type a un attribut appliqué ComImportAttribute, indiquant qu'il a été importé d'une bibliothèque de types COM.Gets a value indicating whether the Type has a ComImportAttribute attribute applied, indicating that it was imported from a COM type library.

(Hérité de Type)
IsInterface

Obtient une valeur indiquant si le Type est une interface, c'est-à-dire ni une classe ni un type valeur.Gets a value indicating whether the Type is an interface; that is, not a class or a value type.

(Hérité de Type)
IsLayoutSequential

Obtient une valeur qui indique si les champs du type actuel sont placés séquentiellement, en respectant l'ordre dans lequel ils ont été définis ou émis aux métadonnées.Gets a value indicating whether the fields of the current type are laid out sequentially, in the order that they were defined or emitted to the metadata.

(Hérité de Type)
IsMarshalByRef

Obtient une valeur indiquant si Type est marshalé par référence.Gets a value indicating whether the Type is marshaled by reference.

(Hérité de Type)
IsNested

Obtient une valeur indiquant si l'objet Type actuel représente un type dont la définition est imbriquée dans la définition d'un autre type.Gets a value indicating whether the current Type object represents a type whose definition is nested inside the definition of another type.

(Hérité de Type)
IsNestedAssembly

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement dans son propre assembly.Gets a value indicating whether the Type is nested and visible only within its own assembly.

(Hérité de Type)
IsNestedFamANDAssem

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement par rapport aux classes qui appartiennent à la fois à sa propre famille et à son propre assembly.Gets a value indicating whether the Type is nested and visible only to classes that belong to both its own family and its own assembly.

(Hérité de Type)
IsNestedFamily

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement dans sa propre famille.Gets a value indicating whether the Type is nested and visible only within its own family.

(Hérité de Type)
IsNestedFamORAssem

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement par rapport aux classes qui appartiennent à sa propre famille ou à son propre assembly.Gets a value indicating whether the Type is nested and visible only to classes that belong to either its own family or to its own assembly.

(Hérité de Type)
IsNestedPrivate

Obtient une valeur indiquant si le Type est imbriqué et déclaré privé.Gets a value indicating whether the Type is nested and declared private.

(Hérité de Type)
IsNestedPublic

Obtient une valeur indiquant si une classe est imbriquée et déclarée publique.Gets a value indicating whether a class is nested and declared public.

(Hérité de Type)
IsNotPublic

Obtient une valeur indiquant si Type n'est pas déclaré public.Gets a value indicating whether the Type is not declared public.

(Hérité de Type)
IsPointer

Obtient une valeur indiquant si Type est un pointeur.Gets a value indicating whether the Type is a pointer.

(Hérité de Type)
IsPrimitive

Obtient une valeur indiquant si le Type est l'un des types primitifs.Gets a value indicating whether the Type is one of the primitive types.

(Hérité de Type)
IsPublic

Obtient une valeur indiquant si Type est déclaré public.Gets a value indicating whether the Type is declared public.

(Hérité de Type)
IsSealed

Obtient une valeur indiquant si Type est déclaré sealed.Gets a value indicating whether the Type is declared sealed.

(Hérité de Type)
IsSecurityCritical

Obtient une valeur qui indique si le type actuel est critique de sécurité (security-critical) ou critique sécurisé (security-safe-critical) au niveau de confiance actuel et peut donc exécuter des opérations critiques.Gets a value that indicates whether the current type is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

(Hérité de Type)
IsSecuritySafeCritical

Obtient une valeur qui indique si le type actuel est critique sécurisé au niveau de confiance actuel, autrement dit s'il peut exécuter des opérations critiques et être accessible par du code transparent.Gets a value that indicates whether the current type is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(Hérité de Type)
IsSecurityTransparent

Obtient une valeur qui indique si le type actuel est transparent au niveau de confiance actuel et ne peut donc pas exécuter d'opérations critiques.Gets a value that indicates whether the current type is transparent at the current trust level, and therefore cannot perform critical operations.

(Hérité de Type)
IsSerializable
IsSignatureType

Obtient une valeur qui indique si le type est un type de signature.Gets a value that indicates whether the type is a signature type.

(Hérité de Type)
IsSpecialName

Obtient une valeur indiquant si le type a un nom qui nécessite un traitement spécial.Gets a value indicating whether the type has a name that requires special handling.

(Hérité de Type)
IsSZArray
IsTypeDefinition
IsUnicodeClass

Obtient une valeur indiquant si l'attribut de format de chaîne UnicodeClass est sélectionné pour Type.Gets a value indicating whether the string format attribute UnicodeClass is selected for the Type.

(Hérité de Type)
IsValueType

Obtient une valeur indiquant si le Type est un type valeur.Gets a value indicating whether the Type is a value type.

(Hérité de Type)
IsVariableBoundArray
IsVisible

Obtient une valeur qui indique si Type est accessible par code à l'extérieur de l'assembly.Gets a value indicating whether the Type can be accessed by code outside the assembly.

(Hérité de Type)
MemberType

Obtient une valeur MemberTypes qui indique que ce membre est un type ou un type imbriqué.Gets a MemberTypes value indicating that this member is a type or a nested type.

(Hérité de Type)
MetadataToken

Obtient une valeur qui identifie un élément de métadonnées.Gets a value that identifies a metadata element.

(Hérité de MemberInfo)
Module

Obtient le module dynamique qui contient le paramètre de type générique.Gets the dynamic module that contains the generic type parameter.

Name

Obtient le nom du paramètre de type générique.Gets the name of the generic type parameter.

Namespace

Obtient null dans tous les cas.Gets null in all cases.

ReflectedType

Obtient l’objet Type qui a été utilisé pour obtenir le GenericTypeParameterBuilder.Gets the Type object that was used to obtain the GenericTypeParameterBuilder.

StructLayoutAttribute

Obtient un StructLayoutAttribute qui décrit la disposition du type actuel.Gets a StructLayoutAttribute that describes the layout of the current type.

(Hérité de Type)
TypeHandle

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

TypeInitializer

Obtient l'initialiseur du type.Gets the initializer for the type.

(Hérité de Type)
UnderlyingSystemType

Obtient le paramètre de type générique actuel.Gets the current generic type parameter.

Méthodes

AsType()

Retourne le type actuel sous forme d'objet Type.Returns the current type as a Type object.

(Hérité de TypeInfo)
Equals(Object)

Teste si l’objet donné est une instance de EventToken et s’il est égal à l’instance actuelle.Tests whether the given object is an instance of EventToken and is equal to the current instance.

Equals(Type)

Détermine si le type de système sous-jacent du Type actuel est identique au type de système sous-jacent du Type spécifié.Determines if the underlying system type of the current Type is the same as the underlying system type of the specified Type.

(Hérité de Type)
FindInterfaces(TypeFilter, Object)

Retourne un tableau d'objets Type représentant une liste filtrée d'interfaces implémentées ou héritées par le Type actuel.Returns an array of Type objects representing a filtered list of interfaces implemented or inherited by the current Type.

(Hérité de Type)
FindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Retourne un tableau filtré d'objets MemberInfo du type du membre spécifié.Returns a filtered array of MemberInfo objects of the specified member type.

(Hérité de Type)
GetArrayRank()
GetAttributeFlagsImpl()

En cas de substitution dans une classe dérivée, implémente la propriété Attributes et obtient une combinaison de bits de valeurs d’énumération qui indique les attributs qui sont associés au Type.When overridden in a derived class, implements the Attributes property and gets a bitwise combination of enumeration values that indicate the attributes associated with the Type.

(Hérité de Type)
GetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Recherche un constructeur dont les paramètres correspondent aux types d’arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d’appel indiquées.Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

(Hérité de Type)
GetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])

Recherche un constructeur dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés, à l’aide des contraintes de liaison spécifiées.Searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints.

(Hérité de Type)
GetConstructor(Type[])

Recherche un constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau spécifié.Searches for a public instance constructor whose parameters match the types in the specified array.

(Hérité de Type)
GetConstructorImpl(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche un constructeur dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés, à l’aide des contraintes de liaison et de la convention d’appel spécifiées.When overridden in a derived class, searches for a constructor whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

(Hérité de Type)
GetConstructors()

Retourne tous les constructeurs publics définis pour le Type actuel.Returns all the public constructors defined for the current Type.

(Hérité de Type)
GetConstructors(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetCustomAttributes(Boolean)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetCustomAttributes(Type, Boolean)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetCustomAttributesData()

Renvoie une liste d’objets CustomAttributeData représentant des données sur les attributs qui ont été appliqués au membre cible.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Hérité de MemberInfo)
GetDeclaredEvent(String)

Retourne un objet qui représente l'événement public spécifié déclaré par le type actuel.Returns an object that represents the specified public event declared by the current type.

(Hérité de TypeInfo)
GetDeclaredField(String)

Retourne un objet qui représente le champ public spécifié déclaré par le type actuel.Returns an object that represents the specified public field declared by the current type.

(Hérité de TypeInfo)
GetDeclaredMethod(String)

Retourne un objet qui représente la méthode publique spécifiée déclarée par le type actuel.Returns an object that represents the specified public method declared by the current type.

(Hérité de TypeInfo)
GetDeclaredMethods(String)

Retourne une collection qui contient toutes les méthodes publiques déclarées sur le type actuel qui correspondent au nom spécifié.Returns a collection that contains all public methods declared on the current type that match the specified name.

(Hérité de TypeInfo)
GetDeclaredNestedType(String)

Retourne un objet qui représente le type imbriqué public spécifié déclaré par le type actuel.Returns an object that represents the specified public nested type declared by the current type.

(Hérité de TypeInfo)
GetDeclaredProperty(String)

Retourne un objet qui représente la propriété publique spécifiée déclarée par le type actuel.Returns an object that represents the specified public property declared by the current type.

(Hérité de TypeInfo)
GetDefaultMembers()

Recherche les membres définis pour le Type actuel dont le DefaultMemberAttribute est défini.Searches for the members defined for the current Type whose DefaultMemberAttribute is set.

(Hérité de Type)
GetElementType()

Lève une exception NotSupportedException dans tous les cas.Throws a NotSupportedException in all cases.

GetEnumName(Object)

Retourne le nom de la constante qui a la valeur spécifiée, pour le type énumération actuel.Returns the name of the constant that has the specified value, for the current enumeration type.

(Hérité de Type)
GetEnumNames()

Retourne les noms des membres du type énumération actuel.Returns the names of the members of the current enumeration type.

(Hérité de Type)
GetEnumUnderlyingType()

Retourne le type sous-jacent du type énumération actuel.Returns the underlying type of the current enumeration type.

(Hérité de Type)
GetEnumValues()

Retourne un tableau des valeurs des constantes dans le type énumération actuel.Returns an array of the values of the constants in the current enumeration type.

(Hérité de Type)
GetEvent(String)

Retourne l'objet EventInfo représentant l'événement public spécifié.Returns the EventInfo object representing the specified public event.

(Hérité de Type)
GetEvent(String, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetEvents()

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetEvents(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetField(String)

Recherche le champ public portant le nom spécifié.Searches for the public field with the specified name.

(Hérité de Type)
GetField(String, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetFields()

Retourne tous les champs publics du Type actuel.Returns all the public fields of the current Type.

(Hérité de Type)
GetFields(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetGenericArguments()

Non valide pour les paramètres de type générique.Not valid for generic type parameters.

GetGenericParameterConstraints()
GetGenericTypeDefinition()

Non valide pour les paramètres de type générique.Not valid for generic type parameters.

GetHashCode()

Retourne un code de hachage entier 32 bits pour l'instance actuelle.Returns a 32-bit integer hash code for the current instance.

GetInterface(String)

Recherche l'interface avec le nom spécifié.Searches for the interface with the specified name.

(Hérité de Type)
GetInterface(String, Boolean)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetInterfaceMap(Type)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetInterfaces()

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetMember(String)

Recherche les membres publics portant le nom spécifié.Searches for the public members with the specified name.

(Hérité de Type)
GetMember(String, BindingFlags)

Recherche les membres spécifiés, à l'aide des contraintes de liaison spécifiées.Searches for the specified members, using the specified binding constraints.

(Hérité de Type)
GetMember(String, MemberTypes, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetMembers()

Retourne tous les membres publics du Type actuel.Returns all the public members of the current Type.

(Hérité de Type)
GetMembers(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetMethod(String)

Recherche la méthode publique avec le nom spécifié.Searches for the public method with the specified name.

(Hérité de Type)
GetMethod(String, BindingFlags)

Recherche la méthode spécifiée, à l'aide des contraintes de liaison spécifiées.Searches for the specified method, using the specified binding constraints.

(Hérité de Type)
GetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent aux types d'arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d'appel indiquées.Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

(Hérité de Type)
GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés, à l'aide des contraintes de liaison spécifiées.Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints.

(Hérité de Type)
GetMethod(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent au nombre de paramètres génériques, aux types d'arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison et la convention d'appel indiquées.Searches for the specified method whose parameters match the specified generic parameter count, argument types and modifiers, using the specified binding constraints and the specified calling convention.

(Hérité de Type)
GetMethod(String, Int32, BindingFlags, Binder, Type[], ParameterModifier[])

Recherche la méthode spécifiée dont les paramètres correspondent au nombre de paramètres génériques, aux types d'arguments et aux modificateurs spécifiés, à l'aide des contraintes de liaison spécifiées.Searches for the specified method whose parameters match the specified generic parameter count, argument types and modifiers, using the specified binding constraints.

(Hérité de Type)
GetMethod(String, Int32, Type[])

Recherche la méthode publique spécifiée dont les paramètres correspondent au nombre d’arguments génériques et aux types d’arguments spécifiés.Searches for the specified public method whose parameters match the specified generic parameter count and argument types.

(Hérité de Type)
GetMethod(String, Int32, Type[], ParameterModifier[])

Recherche la méthode publique spécifiée dont les paramètres correspondent au nombre d’arguments génériques, aux modificateurs et aux types d’arguments spécifiés.Searches for the specified public method whose parameters match the specified generic parameter count, argument types and modifiers.

(Hérité de Type)
GetMethod(String, Type[])

Recherche la méthode publique spécifiée dont les paramètres correspondent aux types d'arguments spécifiés.Searches for the specified public method whose parameters match the specified argument types.

(Hérité de Type)
GetMethod(String, Type[], ParameterModifier[])

Recherche la méthode publique spécifiée dont les paramètres correspondent aux types d’arguments et modificateurs spécifiés.Searches for the specified public method whose parameters match the specified argument types and modifiers.

(Hérité de Type)
GetMethodImpl(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche la méthode spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés, à l'aide des contraintes de liaison et de la convention d'appel spécifiées.When overridden in a derived class, searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints and the specified calling convention.

(Hérité de Type)
GetMethodImpl(String, Int32, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche la méthode spécifiée dont les paramètres correspondent au nombre de paramètres, aux types d'arguments et aux modificateurs spécifiés, à l'aide des contraintes de liaison et de la convention d'appel spécifiées.When overridden in a derived class, searches for the specified method whose parameters match the specified generic parameter count, argument types and modifiers, using the specified binding constraints and the specified calling convention.

(Hérité de Type)
GetMethods()

Retourne toutes les méthodes publiques du Type actuel.Returns all the public methods of the current Type.

(Hérité de Type)
GetMethods(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetNestedType(String)

Recherche le type imbriqué public avec le nom spécifié.Searches for the public nested type with the specified name.

(Hérité de Type)
GetNestedType(String, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetNestedTypes()

Retourne les types publics imbriqués dans le Type actuel.Returns the public types nested in the current Type.

(Hérité de Type)
GetNestedTypes(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetProperties()

Retourne toutes les propriétés publiques du Type actuel.Returns all the public properties of the current Type.

(Hérité de Type)
GetProperties(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

GetProperty(String)

Recherche la propriété publique avec le nom spécifié.Searches for the public property with the specified name.

(Hérité de Type)
GetProperty(String, BindingFlags)

Recherche la propriété spécifiée, à l'aide des contraintes de liaison spécifiées.Searches for the specified property, using the specified binding constraints.

(Hérité de Type)
GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

Recherche la propriété spécifiée dont les paramètres correspondent aux types d’arguments et aux modificateurs spécifiés, en utilisant les contraintes de liaison indiquées.Searches for the specified property whose parameters match the specified argument types and modifiers, using the specified binding constraints.

(Hérité de Type)
GetProperty(String, Type)

Recherche la propriété publique à l'aide du nom et du type de retour spécifiés.Searches for the public property with the specified name and return type.

(Hérité de Type)
GetProperty(String, Type, Type[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d’arguments spécifiés.Searches for the specified public property whose parameters match the specified argument types.

(Hérité de Type)
GetProperty(String, Type, Type[], ParameterModifier[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés.Searches for the specified public property whose parameters match the specified argument types and modifiers.

(Hérité de Type)
GetProperty(String, Type[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d’arguments spécifiés.Searches for the specified public property whose parameters match the specified argument types.

(Hérité de Type)
GetPropertyImpl(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

En cas de substitution dans une classe dérivée, recherche la propriété spécifiée dont les paramètres correspondent aux types d'arguments et modificateurs spécifiés, en utilisant les contraintes de liaison indiquées.When overridden in a derived class, searches for the specified property whose parameters match the specified argument types and modifiers, using the specified binding constraints.

(Hérité de Type)
GetType()

Obtient le Type actuel.Gets the current Type.

(Hérité de Type)
GetTypeCodeImpl()

Retourne le code du type sous-jacent de cette instance Type.Returns the underlying type code of this Type instance.

(Hérité de Type)
HasElementTypeImpl()

En cas de substitution dans une classe dérivée, implémente la propriété HasElementType et détermine si le Type actuel englobe ou se réfère à un autre type ; c'est-à-dire si le Type actuel est un tableau ou un pointeur ou encore s'il est passé par référence.When overridden in a derived class, implements the HasElementType property and determines whether the current Type encompasses or refers to another type; that is, whether the current Type is an array, a pointer, or is passed by reference.

(Hérité de Type)
HasSameMetadataDefinitionAs(MemberInfo) (Hérité de MemberInfo)
InvokeMember(String, BindingFlags, Binder, Object, Object[])

Appelle le membre défini, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments spécifiée.Invokes the specified member, using the specified binding constraints and matching the specified argument list.

(Hérité de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Appelle le membre spécifié, à l'aide des contraintes de liaison spécifiées et correspondant à la liste d'arguments et à la culture spécifiées.Invokes the specified member, using the specified binding constraints and matching the specified argument list and culture.

(Hérité de Type)
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

IsArrayImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsArray et détermine si Type est un tableau.When overridden in a derived class, implements the IsArray property and determines whether the Type is an array.

(Hérité de Type)
IsAssignableFrom(Type)

Lève une exception NotSupportedException dans tous les cas.Throws a NotSupportedException exception in all cases.

IsAssignableFrom(TypeInfo)

Lève une exception NotSupportedException dans tous les cas.Throws a NotSupportedException exception in all cases.

IsByRefImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsByRef et détermine si le Type est passé par référence.When overridden in a derived class, implements the IsByRef property and determines whether the Type is passed by reference.

(Hérité de Type)
IsCOMObjectImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsCOMObject et détermine si le Type est un objet COM.When overridden in a derived class, implements the IsCOMObject property and determines whether the Type is a COM object.

(Hérité de Type)
IsContextfulImpl()

Implémente la propriété IsContextful et détermine si Type peut être hébergé dans un contexte.Implements the IsContextful property and determines whether the Type can be hosted in a context.

(Hérité de Type)
IsDefined(Type, Boolean)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

IsEnumDefined(Object)

Retourne une valeur qui indique si la valeur spécifiée existe dans le type énumération actuel.Returns a value that indicates whether the specified value exists in the current enumeration type.

(Hérité de Type)
IsEquivalentTo(Type)

Détermine si deux types COM ont la même identité et prennent en charge l'équivalence de type.Determines whether two COM types have the same identity and are eligible for type equivalence.

(Hérité de Type)
IsInstanceOfType(Object)
IsMarshalByRefImpl()

Implémente la propriété IsMarshalByRef et détermine si le Type est marshalé par référence.Implements the IsMarshalByRef property and determines whether the Type is marshaled by reference.

(Hérité de Type)
IsPointerImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsPointer et détermine si le Type est un pointeur.When overridden in a derived class, implements the IsPointer property and determines whether the Type is a pointer.

(Hérité de Type)
IsPrimitiveImpl()

En cas de substitution dans une classe dérivée, implémente la propriété IsPrimitive et détermine si Type est l'un des types primitifs.When overridden in a derived class, implements the IsPrimitive property and determines whether the Type is one of the primitive types.

(Hérité de Type)
IsSubclassOf(Type)

Non pris en charge pour les paramètres de type générique incomplets.Not supported for incomplete generic type parameters.

IsValueTypeImpl()

Implémente la propriété IsValueType et détermine si le Type est un type valeur, c'est-à-dire ni une classe ni une interface.Implements the IsValueType property and determines whether the Type is a value type; that is, not a class or an interface.

(Hérité de Type)
MakeArrayType()

Retourne le type d’un tableau unidimensionnel dont le type d’élément est le paramètre de type générique.Returns the type of a one-dimensional array whose element type is the generic type parameter.

MakeArrayType(Int32)

Retourne le type d’un tableau dont le type des éléments correspond au paramètre de type générique, avec le nombre spécifié de dimensions.Returns the type of an array whose element type is the generic type parameter, with the specified number of dimensions.

MakeByRefType()

Retourne un objet Type qui représente le paramètre de type générique actuel quand il est passé comme paramètre de référence.Returns a Type object that represents the current generic type parameter when passed as a reference parameter.

MakeGenericType(Type[])

Non valide pour les paramètres de type générique incomplets.Not valid for incomplete generic type parameters.

MakePointerType()

Retourne un objet Type qui représente un pointeur vers le paramètre de type générique actuel.Returns a Type object that represents a pointer to the current generic type parameter.

MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
SetBaseTypeConstraint(Type)

Définit le type de base un type doit hériter afin d’être substitué au paramètre de type.Sets the base type that a type must inherit in order to be substituted for the type parameter.

SetCustomAttribute(ConstructorInfo, Byte[])

Définit un attribut personnalisé à l’aide d’un objet blob d’attribut personnalisé spécifié.Sets a custom attribute using a specified custom attribute blob.

SetCustomAttribute(CustomAttributeBuilder)

Définit un attribut personnalisé à l’aide d’un générateur d’attributs personnalisés.Set a custom attribute using a custom attribute builder.

SetGenericParameterAttributes(GenericParameterAttributes)

Définit les caractéristiques de variance et les contraintes spéciales du paramètre générique, telles que la contrainte de constructeur sans paramètre.Sets the variance characteristics and special constraints of the generic parameter, such as the parameterless constructor constraint.

SetInterfaceConstraints(Type[])

Définit les interfaces qu’un type doit implémenter pour être substitué au paramètre de type.Sets the interfaces a type must implement in order to be substituted for the type parameter.

ToString()

Retourne une représentation sous forme de chaîne du paramètre de type générique actuel.Returns a string representation of the current generic type parameter.

Implémentations d’interfaces explicites

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

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MemberInfo)
_MemberInfo.GetType()

Obtient un objet Type représentant la classe MemberInfo.Gets a Type object representing the MemberInfo class.

(Hérité de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Hérité de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MemberInfo)
_Type.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de Type)
_Type.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(Hérité de Type)
_Type.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de Type)
_Type.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de Type)
ICustomAttributeProvider.GetCustomAttributes(Boolean) (Hérité de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (Hérité de MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean) (Hérité de MemberInfo)
IReflectableType.GetTypeInfo()

Retourne une représentation du type actuel en tant qu'objet TypeInfo.Returns a representation of the current type as a TypeInfo object.

(Hérité de TypeInfo)

Méthodes d’extension

GetCustomAttribute(MemberInfo, Type)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Indique si des attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Indique si les attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié, et, éventuellement, appliqués à ses ancêtres.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetTypeInfo(Type)

Retourne la représentation TypeInfo du type spécifié.Returns the TypeInfo representation of the specified type.

GetMetadataToken(MemberInfo)

Obtient un jeton de métadonnées pour le membre donné, s’il est disponible.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Retourne une valeur qui indique si un jeton de métadonnées est disponible pour le membre spécifié.Returns a value that indicates whether a metadata token is available for the specified member.

GetRuntimeEvent(Type, String)

Récupère un objet qui représente l’événement spécifié.Retrieves an object that represents the specified event.

GetRuntimeEvents(Type)

Récupère une collection qui représente tous les événements définis sur un type spécifié.Retrieves a collection that represents all the events defined on a specified type.

GetRuntimeField(Type, String)

Récupère un objet qui représente un champ spécifié.Retrieves an object that represents a specified field.

GetRuntimeFields(Type)

Récupère une collection qui représente tous les événements définis sur un type spécifié.Retrieves a collection that represents all the fields defined on a specified type.

GetRuntimeInterfaceMap(TypeInfo, Type)

Retourne un mappage d’interface pour le type et l’interface spécifiés.Returns an interface mapping for the specified type and the specified interface.

GetRuntimeMethod(Type, String, Type[])

Récupère un objet qui représente une méthode spécifiée.Retrieves an object that represents a specified method.

GetRuntimeMethods(Type)

Récupère une collection qui représente toutes les méthodes définies sur un type spécifié.Retrieves a collection that represents all methods defined on a specified type.

GetRuntimeProperties(Type)

Récupère une collection qui représente toutes les méthodes définies sur un type spécifié.Retrieves a collection that represents all the properties defined on a specified type.

GetRuntimeProperty(Type, String)

Récupère un objet qui représente une propriété spécifiée.Retrieves an object that represents a specified property.

GetConstructor(Type, Type[])
GetConstructors(Type)
GetConstructors(Type, BindingFlags)
GetDefaultMembers(Type)
GetEvent(Type, String)
GetEvent(Type, String, BindingFlags)
GetEvents(Type)
GetEvents(Type, BindingFlags)
GetField(Type, String)
GetField(Type, String, BindingFlags)
GetFields(Type)
GetFields(Type, BindingFlags)
GetGenericArguments(Type)
GetInterfaces(Type)
GetMember(Type, String)
GetMember(Type, String, BindingFlags)
GetMembers(Type)
GetMembers(Type, BindingFlags)
GetMethod(Type, String)
GetMethod(Type, String, BindingFlags)
GetMethod(Type, String, Type[])
GetMethods(Type)
GetMethods(Type, BindingFlags)
GetNestedType(Type, String, BindingFlags)
GetNestedTypes(Type, BindingFlags)
GetProperties(Type)
GetProperties(Type, BindingFlags)
GetProperty(Type, String)
GetProperty(Type, String, BindingFlags)
GetProperty(Type, String, Type)
GetProperty(Type, String, Type, Type[])
IsAssignableFrom(Type, Type)
IsInstanceOfType(Type, Object)

S’applique à

Voir aussi