Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

GenericTypeParameterBuilder classe

 

Date de publication : novembre 2016

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. Cette classe ne peut pas être héritée.

Espace de noms:   System.Reflection.Emit
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Reflection.MemberInfo
    System.Type
      System.Reflection.TypeInfo
        System.Reflection.Emit.GenericTypeParameterBuilder

[ComVisibleAttribute(true)]
public sealed class GenericTypeParameterBuilder : TypeInfo

NomDescription
System_CAPS_pubpropertyAssembly

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.(Remplace Type.Assembly.)

System_CAPS_pubpropertyAssemblyQualifiedName

Obtient null dans tous les cas.(Remplace Type.AssemblyQualifiedName.)

System_CAPS_pubpropertyAttributes

Obtient les attributs associés à Type.(Hérité de Type.)

System_CAPS_pubpropertyBaseType

Obtient la contrainte de type de base du paramètre de type générique actuel.(Remplace Type.BaseType.)

System_CAPS_pubpropertyContainsGenericParameters

Obtient true dans tous les cas.(Remplace Type.ContainsGenericParameters.)

System_CAPS_pubpropertyCustomAttributes

Obtient une collection qui contient les attributs personnalisés du membre.(Hérité de MemberInfo.)

System_CAPS_pubpropertyDeclaredConstructors

Obtient une collection des constructeurs déclarés par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaredEvents

Obtient une collection des événements définis par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaredFields

Obtient une collection des champs définis par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaredMembers

Obtient une collection du membre défini par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaredMethods

Obtient une collection des méthodes définies par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaredNestedTypes

Obtient une collection des types imbriqués définis par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaredProperties

Obtient la collection des propriétés définies par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyDeclaringMethod

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.(Remplace Type.DeclaringMethod.)

System_CAPS_pubpropertyDeclaringType

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.(Remplace Type.DeclaringType.)

System_CAPS_pubpropertyFullName

Obtient null dans tous les cas.(Remplace Type.FullName.)

System_CAPS_pubpropertyGenericParameterAttributes

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.(Remplace Type.GenericParameterAttributes.)

System_CAPS_pubpropertyGenericParameterPosition

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.(Remplace Type.GenericParameterPosition.)

System_CAPS_pubpropertyGenericTypeArguments

Obtient un tableau des arguments de type générique pour ce type.(Hérité de Type.)

System_CAPS_pubpropertyGenericTypeParameters

Obtient un tableau des paramètres de type génériques de l’instance actuelle.(Hérité de TypeInfo.)

System_CAPS_pubpropertyGUID

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GUID.)

System_CAPS_pubpropertyHasElementType

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.(Hérité de Type.)

System_CAPS_pubpropertyImplementedInterfaces

Obtient une collection d'interfaces implémentée par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubpropertyIsAbstract

Obtient une valeur indiquant si le Type est abstrait et doit être substitué.(Hérité de Type.)

System_CAPS_pubpropertyIsAnsiClass

Obtient une valeur indiquant si l'attribut de format de chaîne AnsiClass est sélectionné pour Type.(Hérité de Type.)

System_CAPS_pubpropertyIsArray

Obtient une valeur qui indique si le type est un tableau.(Hérité de Type.)

System_CAPS_pubpropertyIsAutoClass

Obtient une valeur indiquant si l'attribut de format de chaîne AutoClass est sélectionné pour Type.(Hérité de Type.)

System_CAPS_pubpropertyIsAutoLayout

Obtient une valeur qui indique si les champs du type actuel sont placés automatiquement par le Common Language Runtime.(Hérité de Type.)

System_CAPS_pubpropertyIsByRef

Obtient une valeur indiquant si Type est passé par référence.(Hérité de Type.)

System_CAPS_pubpropertyIsClass

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.(Hérité de Type.)

System_CAPS_pubpropertyIsCOMObject

Obtient une valeur indiquant si Type est un objet COM.(Hérité de Type.)

System_CAPS_pubpropertyIsConstructedGenericType

Obtient une valeur qui indique si cet objet représente un type générique construit.(Remplace Type.IsConstructedGenericType.)

System_CAPS_pubpropertyIsContextful

Obtient une valeur indiquant si Type peut être hébergé dans un contexte.(Hérité de Type.)

System_CAPS_pubpropertyIsEnum

Obtient une valeur indiquant si le Type actuel représente une énumération.(Hérité de Type.)

System_CAPS_pubpropertyIsExplicitLayout

Obtient une valeur qui indique si les champs du type actuel sont placés aux offsets explicitement spécifiés.(Hérité de Type.)

System_CAPS_pubpropertyIsGenericParameter

Obtient true dans tous les cas.(Remplace Type.IsGenericParameter.)

System_CAPS_pubpropertyIsGenericType

Retourne false dans tous les cas.(Remplace Type.IsGenericType.)

System_CAPS_pubpropertyIsGenericTypeDefinition

Obtient false dans tous les cas.(Remplace Type.IsGenericTypeDefinition.)

System_CAPS_pubpropertyIsImport

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.(Hérité de Type.)

System_CAPS_pubpropertyIsInterface

Obtient une valeur indiquant si le Type est une interface, c'est-à-dire ni une classe ni un type valeur.(Hérité de Type.)

System_CAPS_pubpropertyIsLayoutSequential

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.(Hérité de Type.)

System_CAPS_pubpropertyIsMarshalByRef

Obtient une valeur indiquant si Type est marshalé par référence.(Hérité de Type.)

System_CAPS_pubpropertyIsNested

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.(Hérité de Type.)

System_CAPS_pubpropertyIsNestedAssembly

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement dans son propre assembly.(Hérité de Type.)

System_CAPS_pubpropertyIsNestedFamANDAssem

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.(Hérité de Type.)

System_CAPS_pubpropertyIsNestedFamily

Obtient une valeur indiquant si le Type est imbriqué et visible uniquement dans sa propre famille.(Hérité de Type.)

System_CAPS_pubpropertyIsNestedFamORAssem

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.(Hérité de Type.)

System_CAPS_pubpropertyIsNestedPrivate

Obtient une valeur indiquant si le Type est imbriqué et déclaré privé.(Hérité de Type.)

System_CAPS_pubpropertyIsNestedPublic

Obtient une valeur indiquant si une classe est imbriquée et déclarée publique.(Hérité de Type.)

System_CAPS_pubpropertyIsNotPublic

Obtient une valeur indiquant si Type n'est pas déclaré public.(Hérité de Type.)

System_CAPS_pubpropertyIsPointer

Obtient une valeur indiquant si Type est un pointeur.(Hérité de Type.)

System_CAPS_pubpropertyIsPrimitive

Obtient une valeur indiquant si le Type est l'un des types primitifs.(Hérité de Type.)

System_CAPS_pubpropertyIsPublic

Obtient une valeur indiquant si Type est déclaré public.(Hérité de Type.)

System_CAPS_pubpropertyIsSealed

Obtient une valeur indiquant si Type est déclaré sealed.(Hérité de Type.)

System_CAPS_pubpropertyIsSecurityCritical

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.(Hérité de Type.)

System_CAPS_pubpropertyIsSecuritySafeCritical

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.(Hérité de Type.)

System_CAPS_pubpropertyIsSecurityTransparent

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.(Hérité de Type.)

System_CAPS_pubpropertyIsSerializable

Obtient une valeur indiquant si le Type est sérialisable.(Hérité de Type.)

System_CAPS_pubpropertyIsSpecialName

Obtient une valeur indiquant si le type a un nom qui nécessite un traitement spécial.(Hérité de Type.)

System_CAPS_pubpropertyIsUnicodeClass

Obtient une valeur indiquant si l'attribut de format de chaîne UnicodeClass est sélectionné pour Type.(Hérité de Type.)

System_CAPS_pubpropertyIsValueType

Obtient une valeur indiquant si le Type est un type valeur.(Hérité de Type.)

System_CAPS_pubpropertyIsVisible

Obtient une valeur qui indique si Type est accessible par code à l'extérieur de l'assembly.(Hérité de Type.)

System_CAPS_pubpropertyMemberType

Obtient une valeur MemberTypes qui indique que ce membre est un type ou un type imbriqué.(Hérité de Type.)

System_CAPS_pubpropertyMetadataToken

Obtient une valeur qui identifie un élément de métadonnées.(Hérité de MemberInfo.)

System_CAPS_pubpropertyModule

Obtient le module dynamique qui contient le paramètre de type générique.(Remplace Type.Module.)

System_CAPS_pubpropertyName

Obtient le nom du paramètre de type générique.(Remplace MemberInfo.Name.)

System_CAPS_pubpropertyNamespace

Obtient null dans tous les cas.(Remplace Type.Namespace.)

System_CAPS_pubpropertyReflectedType

Obtient l’objet Type qui a été utilisé pour obtenir le GenericTypeParameterBuilder.(Remplace Type.ReflectedType.)

System_CAPS_pubpropertyStructLayoutAttribute

Obtient un StructLayoutAttribute qui décrit la disposition du type actuel.(Hérité de Type.)

System_CAPS_pubpropertyTypeHandle

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.TypeHandle.)

System_CAPS_pubpropertyTypeInitializer

Obtient l'initialiseur du type.(Hérité de Type.)

System_CAPS_pubpropertyUnderlyingSystemType

Obtient le paramètre de type générique actuel.(Remplace Type.UnderlyingSystemType.)

NomDescription
System_CAPS_pubmethodAsType()

Retourne le type actuel sous forme d'objet Type.(Hérité de TypeInfo.)

System_CAPS_pubmethodEquals(Object)

Teste si l’objet donné est une instance de EventToken et s’il est égal à l’instance actuelle.(Remplace Type.Equals(Object).)

System_CAPS_pubmethodEquals(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é.(Hérité de Type.)

System_CAPS_pubmethodFindInterfaces(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.(Hérité de Type.)

System_CAPS_pubmethodFindMembers(MemberTypes, BindingFlags, MemberFilter, Object)

Retourne un tableau filtré d'objets MemberInfo du type du membre spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetArrayRank()

Obtient le nombre de dimensions dans un tableau.(Hérité de Type.)

System_CAPS_pubmethodGetConstructor(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.(Hérité de Type.)

System_CAPS_pubmethodGetConstructor(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.(Hérité de Type.)

System_CAPS_pubmethodGetConstructor(Type[])

Recherche un constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetConstructors()

Retourne tous les constructeurs publics définis pour le Type actuel.(Hérité de Type.)

System_CAPS_pubmethodGetConstructors(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetConstructors(BindingFlags).)

System_CAPS_pubmethodGetCustomAttributes(Boolean)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace MemberInfo.GetCustomAttributes(Boolean).)

System_CAPS_pubmethodGetCustomAttributes(Type, Boolean)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace MemberInfo.GetCustomAttributes(Type, Boolean).)

System_CAPS_pubmethodGetCustomAttributesData()

Retourne une liste de CustomAttributeData objets représentant des données relatives aux attributs qui ont été appliqués au membre cible.(Hérité de MemberInfo.)

System_CAPS_pubmethodGetDeclaredEvent(String)

Retourne un objet qui représente l'événement public spécifié déclaré par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubmethodGetDeclaredField(String)

Retourne un objet qui représente le champ public spécifié déclaré par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubmethodGetDeclaredMethod(String)

Retourne un objet qui représente la méthode publique spécifiée déclarée par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubmethodGetDeclaredMethods(String)

Retourne une collection qui contient toutes les méthodes publiques déclarées sur le type actuel qui correspondent au nom spécifié.(Hérité de TypeInfo.)

System_CAPS_pubmethodGetDeclaredNestedType(String)

Retourne un objet qui représente le type imbriqué public spécifié déclaré par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubmethodGetDeclaredProperty(String)

Retourne un objet qui représente la propriété publique spécifiée déclarée par le type actuel.(Hérité de TypeInfo.)

System_CAPS_pubmethodGetDefaultMembers()

Recherche les membres définis pour le Type actuel dont le DefaultMemberAttribute est défini.(Hérité de Type.)

System_CAPS_pubmethodGetElementType()

Lève une exception NotSupportedException dans tous les cas.(Remplace Type.GetElementType().)

System_CAPS_pubmethodGetEnumName(Object)

Retourne le nom de la constante qui a la valeur spécifiée, pour le type énumération actuel.(Hérité de Type.)

System_CAPS_pubmethodGetEnumNames()

Retourne les noms des membres du type énumération actuel.(Hérité de Type.)

System_CAPS_pubmethodGetEnumUnderlyingType()

Retourne le type sous-jacent du type énumération actuel.(Hérité de Type.)

System_CAPS_pubmethodGetEnumValues()

Retourne un tableau des valeurs des constantes dans le type énumération actuel.(Hérité de Type.)

System_CAPS_pubmethodGetEvent(String)

Retourne l'objet EventInfo représentant l'événement public spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetEvent(String, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetEvent(String, BindingFlags).)

System_CAPS_pubmethodGetEvents()

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetEvents().)

System_CAPS_pubmethodGetEvents(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetEvents(BindingFlags).)

System_CAPS_pubmethodGetField(String)

Recherche le champ public portant le nom spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetField(String, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetField(String, BindingFlags).)

System_CAPS_pubmethodGetFields()

Retourne tous les champs publics du Type actuel.(Hérité de Type.)

System_CAPS_pubmethodGetFields(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetFields(BindingFlags).)

System_CAPS_pubmethodGetGenericArguments()

Non valide pour les paramètres de type générique.(Remplace Type.GetGenericArguments().)

System_CAPS_pubmethodGetGenericParameterConstraints()

Retourne un tableau d'objets Type qui représentent les contraintes qui s'exercent sur le paramètre de type générique actuel.(Hérité de Type.)

System_CAPS_pubmethodGetGenericTypeDefinition()

Non valide pour les paramètres de type générique.(Remplace Type.GetGenericTypeDefinition().)

System_CAPS_pubmethodGetHashCode()

Retourne un code de hachage entier 32 bits pour l’instance actuelle.(Remplace Type.GetHashCode().)

System_CAPS_pubmethodGetInterface(String)

Recherche l'interface avec le nom spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetInterface(String, Boolean)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetInterface(String, Boolean).)

System_CAPS_pubmethodGetInterfaceMap(Type)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetInterfaceMap(Type).)

System_CAPS_pubmethodGetInterfaces()

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetInterfaces().)

System_CAPS_pubmethodGetMember(String)

Recherche les membres publics portant le nom spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetMember(String, BindingFlags)

Recherche les membres spécifiés, à l'aide des contraintes de liaison spécifiées.(Hérité de Type.)

System_CAPS_pubmethodGetMember(String, MemberTypes, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetMember(String, MemberTypes, BindingFlags).)

System_CAPS_pubmethodGetMembers()

Retourne tous les membres publics du Type actuel.(Hérité de Type.)

System_CAPS_pubmethodGetMembers(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetMembers(BindingFlags).)

System_CAPS_pubmethodGetMethod(String)

Recherche la méthode publique avec le nom spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetMethod(String, BindingFlags)

Recherche la méthode spécifiée, à l'aide des contraintes de liaison spécifiées.(Hérité de Type.)

System_CAPS_pubmethodGetMethod(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.(Hérité de Type.)

System_CAPS_pubmethodGetMethod(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.(Hérité de Type.)

System_CAPS_pubmethodGetMethod(String, Type[])

Recherche la méthode publique spécifiée dont les paramètres correspondent aux types d'arguments spécifiés.(Hérité de Type.)

System_CAPS_pubmethodGetMethod(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.(Hérité de Type.)

System_CAPS_pubmethodGetMethods()

Retourne toutes les méthodes publiques du Type actuel.(Hérité de Type.)

System_CAPS_pubmethodGetMethods(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetMethods(BindingFlags).)

System_CAPS_pubmethodGetNestedType(String)

Recherche le type imbriqué public avec le nom spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetNestedType(String, BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetNestedType(String, BindingFlags).)

System_CAPS_pubmethodGetNestedTypes()

Retourne les types publics imbriqués dans le Type actuel.(Hérité de Type.)

System_CAPS_pubmethodGetNestedTypes(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetNestedTypes(BindingFlags).)

System_CAPS_pubmethodGetProperties()

Retourne toutes les propriétés publiques du Type actuel.(Hérité de Type.)

System_CAPS_pubmethodGetProperties(BindingFlags)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.GetProperties(BindingFlags).)

System_CAPS_pubmethodGetProperty(String)

Recherche la propriété publique avec le nom spécifié.(Hérité de Type.)

System_CAPS_pubmethodGetProperty(String, BindingFlags)

Recherche la propriété spécifiée, à l'aide des contraintes de liaison spécifiées.(Hérité de Type.)

System_CAPS_pubmethodGetProperty(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.(Hérité de Type.)

System_CAPS_pubmethodGetProperty(String, Type)

Recherche la propriété publique à l'aide du nom et du type de retour spécifiés.(Hérité de Type.)

System_CAPS_pubmethodGetProperty(String, Type, Type[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d'arguments spécifiés.(Hérité de Type.)

System_CAPS_pubmethodGetProperty(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.(Hérité de Type.)

System_CAPS_pubmethodGetProperty(String, Type[])

Recherche la propriété publique spécifiée dont les paramètres correspondent aux types d'arguments spécifiés.(Hérité de Type.)

System_CAPS_pubmethodGetType()

Obtient le Type actuel.(Hérité de Type.)

System_CAPS_pubmethodInvokeMember(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.(Hérité de Type.)

System_CAPS_pubmethodInvokeMember(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.(Hérité de Type.)

System_CAPS_pubmethodInvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).)

System_CAPS_pubmethodIsAssignableFrom(Type)

Lève une exception NotSupportedException dans tous les cas.(Remplace Type.IsAssignableFrom(Type).)

System_CAPS_pubmethodIsAssignableFrom(TypeInfo)

Lève une exception NotSupportedException dans tous les cas.(Remplace TypeInfo.IsAssignableFrom(TypeInfo).)

System_CAPS_pubmethodIsDefined(Type, Boolean)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace MemberInfo.IsDefined(Type, Boolean).)

System_CAPS_pubmethodIsEnumDefined(Object)

Retourne une valeur qui indique si la valeur spécifiée existe dans le type énumération actuel.(Hérité de Type.)

System_CAPS_pubmethodIsEquivalentTo(Type)

Détermine si deux types COM ont la même identité et prennent en charge l'équivalence de type.(Hérité de Type.)

System_CAPS_pubmethodIsInstanceOfType(Object)

Détermine si l'objet spécifié est une instance du Type actuel.(Hérité de Type.)

System_CAPS_pubmethodIsSubclassOf(Type)

Non pris en charge pour les paramètres de type générique incomplets.(Remplace Type.IsSubclassOf(Type).)

System_CAPS_pubmethodMakeArrayType()

Retourne le type d’un tableau unidimensionnel dont le type d’élément est le paramètre de type générique.(Remplace Type.MakeArrayType().)

System_CAPS_pubmethodMakeArrayType(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.(Remplace Type.MakeArrayType(Int32).)

System_CAPS_pubmethodMakeByRefType()

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.(Remplace Type.MakeByRefType().)

System_CAPS_pubmethodMakeGenericType(Type[])

Non valide pour les paramètres de type générique incomplets.(Remplace Type.MakeGenericType(Type[]).)

System_CAPS_pubmethodMakePointerType()

Retourne un objet Type qui représente un pointeur vers le paramètre de type générique actuel.(Remplace Type.MakePointerType().)

System_CAPS_pubmethodSetBaseTypeConstraint(Type)

Définit le type de base un type doit hériter afin d’être substitué au paramètre de type.

System_CAPS_pubmethodSetCustomAttribute(ConstructorInfo, Byte[])

Définit un attribut personnalisé à l’aide d’un objet blob d’attribut personnalisé spécifié.

System_CAPS_pubmethodSetCustomAttribute(CustomAttributeBuilder)

Définit un attribut personnalisé à l’aide d’un générateur d’attributs personnalisés.

System_CAPS_pubmethodSetGenericParameterAttributes(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.

System_CAPS_pubmethodSetInterfaceConstraints(Type[])

Définit les interfaces qu’un type doit implémenter pour être substitué au paramètre de type.

System_CAPS_pubmethodToString()

Retourne une représentation sous forme de chaîne du paramètre de type générique actuel.(Remplace Type.ToString().)

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIReflectableType.GetTypeInfo()

Retourne une représentation du type actuel en tant qu'objet TypeInfo.(Hérité de TypeInfo.)

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

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.(Hérité de MemberInfo.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_MemberInfo.GetType()

Obtient un Type objet représentant le MemberInfo (classe).(Hérité de MemberInfo.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_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.(Hérité de MemberInfo.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_MemberInfo.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).(Hérité de MemberInfo.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_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.(Hérité de MemberInfo.)

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

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.(Hérité de Type.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_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.(Hérité de Type.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Type.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).(Hérité de Type.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_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.(Hérité de Type.)

NomDescription
System_CAPS_pubmethodGetCustomAttribute(Type)

Surchargé. Récupère un attribut personnalisé d’un type spécifié qui est appliqué à un membre spécifié.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttribute(Type, Boolean)

Surchargé. Récupère un attribut personnalisé d’un type spécifié qui est appliqué à un membre spécifié et éventuellement inspecte les ancêtres de ce membre.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttribute<T>()

Surchargé. Récupère un attribut personnalisé d’un type spécifié qui est appliqué à un membre spécifié.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttribute<T>(Boolean)

Surchargé. Récupère un attribut personnalisé d’un type spécifié qui est appliqué à un membre spécifié et éventuellement inspecte les ancêtres de ce membre.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttributes()

Surchargé. Récupère une collection d’attributs personnalisés qui sont appliqués à un membre spécifié.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttributes(Type)

Surchargé. Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un membre spécifié.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttributes<T>(Boolean)

Surchargé. Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un membre spécifié et éventuellement inspecte les ancêtres de ce membre.(Défini par CustomAttributeExtensions.)

System_CAPS_pubmethodGetRuntimeEvent(String)

Récupère un objet qui représente l’événement spécifié.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeEvents()

Récupère une collection qui représente tous les événements définis sur un type spécifié.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeField(String)

Récupère un objet qui représente un champ spécifié.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeFields()

Récupère une collection qui représente tous les champs définis sur un type spécifié.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeInterfaceMap(Type)

Retourne un mappage d’interface pour le type spécifié et de l’interface spécifiée.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeMethod(String, Type[])

Récupère un objet qui représente une méthode spécifiée.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeMethods()

Récupère une collection qui représente toutes les méthodes définies sur un type spécifié.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeProperties()

Récupère une collection qui représente toutes les propriétés définies sur un type spécifié.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetRuntimeProperty(String)

Récupère un objet qui représente une propriété spécifiée.(Défini par RuntimeReflectionExtensions.)

System_CAPS_pubmethodGetTypeInfo()

Retourne le TypeInfo représentant le type spécifié.(Défini par IntrospectionExtensions.)

System_CAPS_pubmethodIsDefined(Type)

Surchargé. Indique si des attributs personnalisés d’un type spécifié sont appliqués à un membre spécifié.(Défini par CustomAttributeExtensions.)

You can get an array of T:System.Reflection.Emit.GenericTypeParameterBuilder objects by using the M:System.Reflection.Emit.TypeBuilder.DefineGenericParameters(System.String[]) method to add type parameters to a dynamic type, thus making it a generic type, or by using the M:System.Reflection.Emit.MethodBuilder.DefineGenericParameters(System.String[]) method to add type parameters to a dynamic method. Use the T:System.Reflection.Emit.GenericTypeParameterBuilder objects to add constraints to the type parameters. Constraints are of three kinds:

  • The base type constraint specifies that any type assigned to the generic type parameter must derive from a particular base type. Set this constraint by using the M:System.Reflection.Emit.GenericTypeParameterBuilder.SetBaseTypeConstraint(System.Type) method.

  • An interface constraint specifies that any type assigned to the generic type parameter must implement a particular interface. Set the interface constraints by using the M:System.Reflection.Emit.GenericTypeParameterBuilder.SetInterfaceConstraints(System.Type[]) method.

  • Special constraints specify that any type assigned to the generic type parameter must have a default constructor, must be a reference type, or must be a value type. Set the special constraints for a type parameter by using the M:System.Reflection.Emit.GenericTypeParameterBuilder.SetGenericParameterAttributes(System.Reflection.GenericParameterAttributes) method.

Interface constraints and special constraints cannot be retrieved using methods of the T:System.Reflection.Emit.GenericTypeParameterBuilder class. Once you have created the generic type that contains the type parameters, you can use its T:System.Type object to reflect the constraints. Use the M:System.Type.GetGenericArguments method to get the type parameters, and for each type parameter use the M:System.Type.GetGenericParameterConstraints method to get the base type constraint and interface constraints, and the P:System.Type.GenericParameterAttributes property to get the special constraints.

The following code example creates a generic type with two type parameters, and saves them in the assembly GenericEmitExample1.dll. You can use the MSIL Disassembler (Ildasm.exe) to view the generated types. 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 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
 */

.NET Framework
Disponible depuis 2.0
Silverlight
Disponible depuis 2.0

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: