Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

TypeBuilder, classe

Définit et crée de nouvelles instances de classes au moment de l'exécution.

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

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

[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
public sealed class TypeBuilder : TypeInfo, 
	_TypeBuilder

Le type TypeBuilder expose les membres suivants.

  NomDescription
Propriété publiqueAssemblyRécupère l'assembly dynamique qui contient cette définition de type. (Substitue Type.Assembly.)
Propriété publiqueAssemblyQualifiedNameRetourne le nom complet de ce type, qualifié par le nom complet de l'assembly. (Substitue Type.AssemblyQualifiedName.)
Propriété publiqueAttributesObtient les attributs associés à Type. (Hérité de Type.)
Propriété publiqueBaseTypeRécupère le type de base de ce type. (Substitue Type.BaseType.)
Propriété publiqueContainsGenericParametersObtient une valeur indiquant si l'objet Type actif a des paramètres de type qui n'ont pas été remplacés par des types spécifiques. (Hérité de Type.)
Propriété publiqueCustomAttributesObtient une collection qui contient les attributs personnalisés de ce membre. (Hérité de MemberInfo.)
Propriété publiqueDeclaredConstructorsObtient une collection des constructeurs déclarés par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaredEventsObtient une collection des événements définis par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaredFieldsObtient une collection des champs définis par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaredMembersObtient une collection du membre défini par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaredMethodsObtient une collection des méthodes définies par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaredNestedTypesObtient une collection des types imbriqués définis par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaredPropertiesObtient une collection des propriétés définies par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueDeclaringMethodObtient la méthode qui a déclaré le paramètre de type générique actuel. (Substitue Type.DeclaringMethod.)
Propriété publiqueDeclaringTypeRetourne le type qui a déclaré ce type. (Substitue Type.DeclaringType.)
Propriété publiqueFullNameRécupère le chemin d'accès complet de ce type. (Substitue Type.FullName.)
Propriété publiqueGenericParameterAttributesObtient une valeur indiquant la covariance et les contraintes spéciales du paramètre de type générique actuel. (Substitue Type.GenericParameterAttributes.)
Propriété publiqueGenericParameterPositionObtient la position d'un paramètre de type dans la liste des paramètres de type du type générique qui a déclaré le paramètre. (Substitue Type.GenericParameterPosition.)
Propriété publiqueGenericTypeArgumentsObtient un tableau des arguments de type générique pour ce type. (Hérité de Type.)
Propriété publiqueGenericTypeParametersObtient un tableau des paramètres génériques du type actuel. (Hérité de TypeInfo.)
Propriété publiqueGUIDRécupère le GUID de ce type. (Substitue Type.GUID.)
Propriété publiqueHasElementTypeObtient une valeur indiquant si le Type en cours englobe ou se réfère à un autre type, c'est-à-dire si le Type en cours est un tableau ou un pointeur ou encore s'il est passé par référence. (Hérité de Type.)
Propriété publiqueImplementedInterfacesObtient une collection d'interfaces implémentée par le type actuel. (Hérité de TypeInfo.)
Propriété publiqueIsAbstractObtient une valeur indiquant si le Type est abstrait et doit être substitué. (Hérité de Type.)
Propriété publiqueIsAnsiClassObtient une valeur indiquant si l'attribut de format de chaîne AnsiClass est sélectionné pour Type. (Hérité de Type.)
Propriété publiqueIsArrayObtient une valeur indiquant si Type est un tableau. (Hérité de Type.)
Propriété publiqueIsAutoClassObtient une valeur indiquant si l'attribut de format de chaîne AutoClass est sélectionné pour Type. (Hérité de Type.)
Propriété publiqueIsAutoLayoutObtient une valeur qui indique si les champs du type actuel sont placés automatiquement par le common language runtime. (Hérité de Type.)
Propriété publiqueIsByRefObtient une valeur indiquant si Type est passé par référence. (Hérité de Type.)
Propriété publiqueIsClassObtient une valeur indiquant si le Type est une classe, c'est-à-dire ni un type valeur ni une interface. (Hérité de Type.)
Propriété publiqueIsCOMObjectObtient une valeur indiquant si Type est un objet COM. (Hérité de Type.)
Propriété publiqueIsConstructedGenericTypeObtient une valeur qui indique si cet objet représente un type générique construit. (Substitue Type.IsConstructedGenericType.)
Propriété publiqueIsContextfulObtient une valeur indiquant si Type peut être hébergé dans un contexte. (Hérité de Type.)
Propriété publiqueIsEnumObtient une valeur indiquant si le Type actuel représente une énumération. (Hérité de Type.)
Propriété publiqueIsExplicitLayoutObtient une valeur qui indique si les champs du type actuel sont placés aux offsets explicitement spécifiés. (Hérité de Type.)
Propriété publiqueIsGenericParameterObtient une valeur indiquant si le type actuel est un paramètre de type générique. (Substitue Type.IsGenericParameter.)
Propriété publiqueIsGenericTypeObtient une valeur indiquant si le type actuel est un type générique. (Substitue Type.IsGenericType.)
Propriété publiqueIsGenericTypeDefinitionObtient une valeur qui indique si le TypeBuilder actuel représente une définition de type générique, à partir de laquelle d'autres types génériques peuvent être construits. (Substitue Type.IsGenericTypeDefinition.)
Propriété publiqueIsImportObtient 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.)
Propriété publiqueIsInterfaceObtient une valeur indiquant si le Type est une interface, c'est-à-dire ni une classe ni un type valeur. (Hérité de Type.)
Propriété publiqueIsLayoutSequentialObtient 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.)
Propriété publiqueIsMarshalByRefObtient une valeur indiquant si Type est marshalé par référence. (Hérité de Type.)
Propriété publiqueIsNestedObtient 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.)
Propriété publiqueIsNestedAssemblyObtient une valeur indiquant si le Type est imbriqué et visible uniquement dans son propre assembly. (Hérité de Type.)
Propriété publiqueIsNestedFamANDAssemObtient 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.)
Propriété publiqueIsNestedFamilyObtient une valeur indiquant si le Type est imbriqué et visible uniquement dans sa propre famille. (Hérité de Type.)
Propriété publiqueIsNestedFamORAssemObtient 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.)
Propriété publiqueIsNestedPrivateObtient une valeur indiquant si le Type est imbriqué et déclaré privé. (Hérité de Type.)
Propriété publiqueIsNestedPublicObtient une valeur indiquant si une classe est imbriquée et déclarée publique. (Hérité de Type.)
Propriété publiqueIsNotPublicObtient une valeur indiquant si Type n'est pas déclaré public. (Hérité de Type.)
Propriété publiqueIsPointerObtient une valeur indiquant si Type est un pointeur. (Hérité de Type.)
Propriété publiqueIsPrimitiveObtient une valeur indiquant si le Type est l'un des types primitifs. (Hérité de Type.)
Propriété publiqueIsPublicObtient une valeur indiquant si Type est déclaré public. (Hérité de Type.)
Propriété publiqueIsSealedObtient une valeur indiquant si le Type est déclaré sealed. (Hérité de Type.)
Propriété publiqueIsSecurityCriticalObtient une valeur qui indique si le type actuel est critique de sécurité (security-critical) ou critique sécurisé (security-safe-critical) et peut par conséquent exécuter des opérations critiques. (Substitue Type.IsSecurityCritical.)
Propriété publiqueIsSecuritySafeCriticalObtient une valeur qui indique si le type actuel est critique sécurisé ; autrement dit, s'il peut exécuter des opérations critiques et être accessible par du code transparent. (Substitue Type.IsSecuritySafeCritical.)
Propriété publiqueIsSecurityTransparentObtient une valeur qui indique si le type actuel est transparent et ne peut par conséquent pas exécuter d'opérations critiques. (Substitue Type.IsSecurityTransparent.)
Propriété publiqueIsSerializableObtient une valeur indiquant si le Type est sérialisable. (Hérité de Type.)
Propriété publiqueIsSpecialNameObtient une valeur indiquant si le Type a un nom qui nécessite un traitement spécial. (Hérité de Type.)
Propriété publiqueIsUnicodeClassObtient une valeur indiquant si l'attribut de format de chaîne UnicodeClass est sélectionné pour Type. (Hérité de Type.)
Propriété publiqueIsValueTypeObtient une valeur indiquant si le Type est un type valeur. (Hérité de Type.)
Propriété publiqueIsVisibleObtient une valeur qui indique si Type est accessible par code à l'extérieur de l'assembly. (Hérité de Type.)
Propriété publiqueMemberTypeObtient une valeur MemberTypes qui indique que ce membre est un type ou un type imbriqué. (Hérité de Type.)
Propriété publiqueMetadataTokenObtient une valeur qui identifie un élément de métadonnées. (Hérité de MemberInfo.)
Propriété publiqueModuleRécupère le module dynamique qui contient cette définition de type. (Substitue Type.Module.)
Propriété publiqueNameRécupère le nom de ce type. (Substitue MemberInfo.Name.)
Propriété publiqueNamespaceRécupère l'espace de noms dans lequel ce TypeBuilder est défini. (Substitue Type.Namespace.)
Propriété publiquePackingSizeRécupère la taille de compactage de ce type.
Propriété publiqueReflectedTypeRetourne le type utilisé pour obtenir ce type. (Substitue Type.ReflectedType.)
Propriété publiqueSizeRécupère la taille totale d'un type.
Propriété publiqueStructLayoutAttributeObtient un StructLayoutAttribute qui décrit la disposition du type actuel. (Hérité de Type.)
Propriété publiqueTypeHandleNon pris en charge dans les modules dynamiques. (Substitue Type.TypeHandle.)
Propriété publiqueTypeInitializerObtient l'initialiseur de Type. (Hérité de Type.)
Propriété publiqueTypeTokenRetourne le jeton de type de ce type.
Propriété publiqueUnderlyingSystemTypeRetourne le type de système sous-jacent pour ce TypeBuilder. (Substitue Type.UnderlyingSystemType.)
Début

  NomDescription
Méthode publiqueAddDeclarativeSecurityAjoute une sécurité déclarative à ce type.
Méthode publiqueAddInterfaceImplementationAjoute une interface implémentée par ce type.
Méthode publiqueAsTypeRetourne le type actuel sous forme d'objet Type. (Hérité de TypeInfo.)
Méthode publiqueCreateTypeCrée un objet Type pour la classe. Une fois les champs et les méthodes définis sur la classe, CreateType est appelé pour charger son objet Type.
Méthode publiqueCreateTypeInfoObtient un TypeInfo qui représente ce type.
Méthode publiqueDefineConstructor(MethodAttributes, CallingConventions, Type[])Ajoute un nouveau constructeur au type avec les attributs et la signature donnés.
Méthode publiqueDefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])Ajoute un nouveau constructeur au type avec les attributs, la signature et les modificateurs personnalisés donnés.
Méthode publiqueDefineDefaultConstructorDéfinit le constructeur par défaut. Le constructeur défini ici appellera simplement le constructeur par défaut du parent.
Méthode publiqueDefineEventAjoute un nouvel événement au type avec le nom, les attributs et le type d'événement donnés.
Méthode publiqueDefineField(String, Type, FieldAttributes)Ajoute un nouveau champ au type, avec le nom, les attributs et le type de champ donnés.
Méthode publiqueDefineField(String, Type, Type[], Type[], FieldAttributes)Ajoute un nouveau champ au type avec le nom, les attributs, le type de champ et les modificateurs personnalisés donnés.
Méthode publiqueDefineGenericParametersDéfinit les paramètres de type générique pour le type actuel, en spécifiant leur nombre ainsi que leur nom, et retourne un tableau d'objets GenericTypeParameterBuilder qui peuvent être utilisés pour définir leurs contraintes.
Méthode publiqueDefineInitializedDataDéfinit un champ de données initialisé dans la section .sdata du fichier exécutable portable.
Méthode publiqueDefineMethod(String, MethodAttributes)Ajoute une nouvelle méthode au type avec le nom et les attributs de méthode spécifiés.
Méthode publiqueDefineMethod(String, MethodAttributes, CallingConventions)Ajoute une nouvelle méthode au type avec le nom, les attributs de méthode et la convention d'appel spécifiés.
Méthode publiqueDefineMethod(String, MethodAttributes, Type, Type[])Ajoute une nouvelle méthode au type avec le nom, les attributs de méthode et la signature de méthode spécifiés.
Méthode publiqueDefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])Ajoute une nouvelle méthode au type avec le nom, les attributs de méthode, la convention d'appel et la signature de méthode spécifiés.
Méthode publiqueDefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])Ajoute une nouvelle méthode au type avec le nom, les attributs de méthode, la convention d'appel, la signature de méthode et les modificateurs personnalisés spécifiés.
Méthode publiqueDefineMethodOverrideSpécifie un corps de méthode donné qui implémente une déclaration de méthode donnée, éventuellement avec un autre nom.
Méthode publiqueDefineNestedType(String)Définit un type imbriqué en fonction de son nom.
Méthode publiqueDefineNestedType(String, TypeAttributes)Définit un type imbriqué en fonction de son nom et de ses attributs.
Méthode publiqueDefineNestedType(String, TypeAttributes, Type)Définit un type imbriqué en fonction de son nom, de ses attributs et du type qu'il étend.
Méthode publiqueDefineNestedType(String, TypeAttributes, Type, Int32)Définit un type imbriqué en fonction de son nom, de ses attributs, de la taille totale du type et du type qu'il étend.
Méthode publiqueDefineNestedType(String, TypeAttributes, Type, PackingSize)Définit un type imbriqué en fonction de son nom, de ses attributs, du type qu'il étend et de la taille de compactage.
Méthode publiqueDefineNestedType(String, TypeAttributes, Type, Type[])Définit un type imbriqué en fonction de son nom, de ses attributs, du type qu'il étend et de l'interface qu'il implémente.
Méthode publiqueDefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)Définit un type imbriqué en fonction de son nom, de ses attributs, de sa taille et du type qu'il étend.
Méthode publiqueDefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)Définit une méthode PInvoke en fonction de son nom, du nom de la DLL dans laquelle la méthode a été définie, des attributs de la méthode, de sa convention d'appel, de son type de retour, des types de ses paramètres et des indicateurs PInvoke.
Méthode publiqueDefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)Définit une méthode PInvoke en fonction de son nom, du nom de la DLL dans laquelle la méthode a été définie, du nom du point d'entrée, des attributs de la méthode, de sa convention d'appel, de son type de retour, des types de ses paramètres et des indicateurs PInvoke.
Méthode publiqueDefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)Définit une méthode PInvoke en fonction de son nom, du nom de la DLL dans laquelle la méthode a été définie, du nom du point d'entrée, des attributs de la méthode, de sa convention d'appel, de son type de retour, des types de ses paramètres, des indicateurs PInvoke et des modificateurs personnalisés pour les paramètres et le type de retour.
Méthode publiqueDefineProperty(String, PropertyAttributes, Type, Type[])Ajoute une nouvelle propriété au type avec le nom et la signature de propriété donnés.
Méthode publiqueDefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])Ajoute une nouvelle propriété au type avec le nom, les attributs, la convention d'appel et la signature de propriété donnés.
Méthode publiqueDefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])Ajoute une nouvelle propriété au type avec le nom, la signature de propriété et les modificateurs personnalisés donnés.
Méthode publiqueDefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])Ajoute une nouvelle propriété au type avec le nom, la convention d'appel, la signature de propriété et les modificateurs personnalisés donnés.
Méthode publiqueDefineTypeInitializerDéfinit l'initialiseur de ce type.
Méthode publiqueDefineUninitializedDataDéfinit un champ de données non initialisé dans la section .sdata du fichier exécutable portable (PE, Portable Executable).
Méthode publiqueEquals(Object)Détermine si le type de système sous-jacent du Type en cours est identique au type de système sous-jacent du Object spécifié. (Hérité de Type.)
Méthode publiqueEquals(Type)Détermine si le type de système sous-jacent du Type en cours est identique au type de système sous-jacent du Type spécifié. (Hérité de Type.)
Méthode publiqueFindInterfacesRetourne un tableau d'objets Type représentant une liste filtrée d'interfaces implémentées ou héritées par le Type en cours. (Hérité de Type.)
Méthode publiqueFindMembersRetourne un tableau filtré d'objets MemberInfo du type du membre spécifié. (Hérité de Type.)
Méthode publiqueGetArrayRankObtient le nombre de dimensions dans un Array. (Hérité de Type.)
Méthode publiqueGetConstructor(Type[])Recherche un constructeur d'instance public dont les paramètres correspondent aux types contenus dans le tableau spécifié. (Hérité de Type.)
Méthode publiqueMembre statiqueGetConstructor(Type, ConstructorInfo)Retourne le constructeur du type générique construit spécifié qui correspond au constructeur spécifié de la définition de type générique.
Méthode publiqueGetConstructor(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.)
Méthode publiqueGetConstructor(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.)
Méthode publiqueGetConstructors()Retourne tous les constructeurs publics définis pour le Type en cours. (Hérité de Type.)
Méthode publiqueGetConstructors(BindingFlags)Retourne un tableau d'objets ConstructorInfo représentant les constructeurs publics et non publics définis pour cette classe, comme spécifié. (Substitue Type.GetConstructors(BindingFlags).)
Méthode publiqueGetCustomAttributes(Boolean)Retourne tous les attributs personnalisés définis pour ce type. (Substitue MemberInfo.GetCustomAttributes(Boolean).)
Méthode publiqueGetCustomAttributes(Type, Boolean)Retourne tous les attributs personnalisés du type actuel qui peuvent être assignés à un type spécifié. (Substitue MemberInfo.GetCustomAttributes(Type, Boolean).)
Méthode publiqueGetCustomAttributesDataRetourne une liste d'objets CustomAttributeData représentant des données relatives aux attributs qui ont été appliqués au membre cible. (Hérité de MemberInfo.)
Méthode publiqueGetDeclaredEventRetourne un objet qui représente l'événement public spécifié déclaré par le type actuel. (Hérité de TypeInfo.)
Méthode publiqueGetDeclaredFieldRetourne un objet qui représente le champ public spécifié déclaré par le type actuel. (Hérité de TypeInfo.)
Méthode publiqueGetDeclaredMethodRetourne un objet qui représente la méthode publique spécifiée déclarée par le type actuel. (Hérité de TypeInfo.)
Méthode publiqueGetDeclaredMethodsRetourne 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.)
Méthode publiqueGetDeclaredNestedTypeRetourne un objet qui représente le type imbriqué public spécifié déclaré par le type actuel. (Hérité de TypeInfo.)
Méthode publiqueGetDeclaredPropertyRetourne un objet qui représente la propriété publique spécifiée déclarée par le type actuel. (Hérité de TypeInfo.)
Méthode publiqueGetDefaultMembersRecherche les membres définis pour le Type en cours dont le DefaultMemberAttribute est défini. (Hérité de Type.)
Méthode publiqueGetElementTypeL'appel de cette méthode lève toujours NotSupportedException. (Substitue Type.GetElementType().)
Méthode publiqueGetEnumNameRetourne le nom de la constante qui a la valeur spécifiée, pour le type énumération actuel. (Hérité de Type.)
Méthode publiqueGetEnumNamesRetourne les noms des membres du type énumération actuel. (Hérité de Type.)
Méthode publiqueGetEnumUnderlyingTypeRetourne le type sous-jacent du type énumération actuel. (Hérité de Type.)
Méthode publiqueGetEnumValuesRetourne un tableau des valeurs des constantes dans le type énumération actuel. (Hérité de Type.)
Méthode publiqueGetEvent(String)Retourne l'objet EventInfo représentant l'événement public spécifié. (Hérité de Type.)
Méthode publiqueGetEvent(String, BindingFlags)Retourne l'événement avec le nom spécifié. (Substitue Type.GetEvent(String, BindingFlags).)
Méthode publiqueGetEvents()Retourne les événements publics déclarés ou hérités par ce type. (Substitue Type.GetEvents().)
Méthode publiqueGetEvents(BindingFlags)Retourne les événements publics et non publics déclarés par ce type. (Substitue Type.GetEvents(BindingFlags).)
Méthode publiqueGetField(String)Recherche le champ public portant le nom spécifié. (Hérité de Type.)
Méthode publiqueGetField(String, BindingFlags)Retourne le champ spécifié par le nom donné. (Substitue Type.GetField(String, BindingFlags).)
Méthode publiqueMembre statiqueGetField(Type, FieldInfo)Retourne le champ du type générique construit spécifié qui correspond au champ spécifié de la définition de type générique.
Méthode publiqueGetFields()Retourne tous les champs publics du Type en cours. (Hérité de Type.)
Méthode publiqueGetFields(BindingFlags)Retourne les champs publics et non publics déclarés par ce type. (Substitue Type.GetFields(BindingFlags).)
Méthode publiqueGetGenericArgumentsRetourne un tableau d'objets Type qui représentent les arguments de type d'un type générique ou les paramètres de type d'une définition de type générique. (Substitue Type.GetGenericArguments().)
Méthode publiqueGetGenericParameterConstraintsRetourne 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.)
Méthode publiqueGetGenericTypeDefinitionRetourne un objet Type qui représente une définition de type générique à partir de laquelle le type actuel peut être obtenu. (Substitue Type.GetGenericTypeDefinition().)
Méthode publiqueGetHashCodeRetourne le code de hachage de cette instance. (Hérité de Type.)
Méthode publiqueGetInterface(String)Recherche l'interface avec le nom spécifié. (Hérité de Type.)
Méthode publiqueGetInterface(String, Boolean)Retourne l'interface implémentée (directement ou indirectement) par cette classe avec le nom qualifié complet correspondant au nom d'interface donné. (Substitue Type.GetInterface(String, Boolean).)
Méthode publiqueGetInterfaceMapRetourne un mappage d'interface pour l'interface demandée. (Substitue Type.GetInterfaceMap(Type).)
Méthode publiqueGetInterfacesRetourne un tableau de toutes les interfaces implémentées sur ce type et sur ses types de base. (Substitue Type.GetInterfaces().)
Méthode publiqueGetMember(String)Recherche les membres publics portant le nom spécifié. (Hérité de Type.)
Méthode publiqueGetMember(String, BindingFlags)Recherche les membres spécifiés, à l'aide des contraintes de liaison spécifiées. (Hérité de Type.)
Méthode publiqueGetMember(String, MemberTypes, BindingFlags)Retourne tous les membres publics et non publics déclarés ou hérités par ce type, comme spécifié. (Substitue Type.GetMember(String, MemberTypes, BindingFlags).)
Méthode publiqueGetMembers()Retourne tous les membres publics du Type en cours. (Hérité de Type.)
Méthode publiqueGetMembers(BindingFlags)Retourne les membres pour les membres publics et non publics déclarés ou hérités par ce type. (Substitue Type.GetMembers(BindingFlags).)
Méthode publiqueGetMethod(String)Recherche la méthode publique avec le nom spécifié. (Hérité de Type.)
Méthode publiqueGetMethod(String, BindingFlags)Recherche la méthode spécifiée, à l'aide des contraintes de liaison spécifiées. (Hérité de Type.)
Méthode publiqueGetMethod(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.)
Méthode publiqueMembre statiqueGetMethod(Type, MethodInfo)Retourne la méthode du type générique construit spécifié qui correspond à la méthode spécifiée de la définition de type générique.
Méthode publiqueGetMethod(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.)
Méthode publiqueGetMethod(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.)
Méthode publiqueGetMethod(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.)
Méthode publiqueGetMethods()Retourne toutes les méthodes publiques du Type en cours. (Hérité de Type.)
Méthode publiqueGetMethods(BindingFlags)Retourne toutes les méthodes publiques et non publiques déclarées ou héritées par ce type, comme spécifié. (Substitue Type.GetMethods(BindingFlags).)
Méthode publiqueGetNestedType(String)Recherche le type imbriqué public avec le nom spécifié. (Hérité de Type.)
Méthode publiqueGetNestedType(String, BindingFlags)Retourne les types imbriqués publics et non publics déclarés par ce type. (Substitue Type.GetNestedType(String, BindingFlags).)
Méthode publiqueGetNestedTypes()Retourne les types publics imbriqués dans le Type actuel. (Hérité de Type.)
Méthode publiqueGetNestedTypes(BindingFlags)Retourne les types imbriqués publics et non publics déclarés ou hérités par ce type. (Substitue Type.GetNestedTypes(BindingFlags).)
Méthode publiqueGetProperties()Retourne toutes les propriétés publiques du Type en cours. (Hérité de Type.)
Méthode publiqueGetProperties(BindingFlags)Retourne toutes les propriétés publiques et non publiques déclarées ou héritées par ce type, comme spécifié. (Substitue Type.GetProperties(BindingFlags).)
Méthode publiqueGetProperty(String)Recherche la propriété publique avec le nom spécifié. (Hérité de Type.)
Méthode publiqueGetProperty(String, BindingFlags)Recherche la propriété spécifiée, à l'aide des contraintes de liaison spécifiées. (Hérité de Type.)
Méthode publiqueGetProperty(String, Type)Recherche la propriété publique à l'aide du nom et du type de retour spécifiés. (Hérité de Type.)
Méthode publiqueGetProperty(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.)
Méthode publiqueGetProperty(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.)
Méthode publiqueGetProperty(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.)
Méthode publiqueGetProperty(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.)
Méthode publiqueGetType()Obtient le Type en cours. (Hérité de Type.)
Méthode publiqueInvokeMember(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.)
Méthode publiqueInvokeMember(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.)
Méthode publiqueInvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])Appelle le membre spécifié. La méthode à appeler doit être accessible et fournir la correspondance la plus proche avec la liste d'arguments spécifiée, avec les contraintes du binder et des attributs d'appel spécifiés. (Substitue Type.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).)
Méthode publiqueIsAssignableFrom(Type)Obtient une valeur qui indique si un objet Type spécifié peut être assigné à cet objet. (Substitue Type.IsAssignableFrom(Type).)
Méthode publiqueIsAssignableFrom(TypeInfo)Obtient une valeur qui indique si un objet TypeInfo spécifié peut être assigné à cet objet. (Substitue TypeInfo.IsAssignableFrom(TypeInfo).)
Méthode publiqueIsCreatedRetourne une valeur indiquant si le type dynamique actuel a été créé.
Méthode publiqueIsDefinedDétermine si un attribut personnalisé est appliqué au type actuel. (Substitue MemberInfo.IsDefined(Type, Boolean).)
Méthode publiqueIsEnumDefinedRetourne une valeur qui indique si la valeur spécifiée existe dans le type énumération actuel. (Hérité de Type.)
Méthode publiqueIsEquivalentToDétermine si deux types COM ont la même identité et prennent en charge l'équivalence de type. (Hérité de Type.)
Méthode publiqueIsInstanceOfTypeDétermine si l'objet spécifié est une instance du Type en cours. (Hérité de Type.)
Méthode publiqueIsSubclassOfDétermine si ce type est dérivé d'un type spécifié. (Substitue Type.IsSubclassOf(Type).)
Méthode publiqueMakeArrayType()Retourne un objet Type qui représente un tableau unidimensionnel du type actuel, avec une limite inférieure de zéro. (Substitue Type.MakeArrayType().)
Méthode publiqueMakeArrayType(Int32)Retourne un objet Type qui représente un tableau du type actuel, avec le nombre spécifié de dimensions. (Substitue Type.MakeArrayType(Int32).)
Méthode publiqueMakeByRefTypeRetourne un objet Type qui représente le type actuel lorsqu'il est passé en tant que paramètre ref (ByRef en Visual Basic). (Substitue Type.MakeByRefType().)
Méthode publiqueMakeGenericTypeSubstitue les éléments d'un tableau de types aux paramètres de type de la définition de type générique actuelle et retourne le type construit résultant. (Substitue Type.MakeGenericType(Type[]).)
Méthode publiqueMakePointerTypeRetourne un objet Type qui représente le type d'un pointeur non managé vers le type actuel. (Substitue Type.MakePointerType().)
Méthode publiqueSetCustomAttribute(CustomAttributeBuilder)Définit un attribut personnalisé à l'aide d'un générateur d'attributs personnalisés.
Méthode publiqueSetCustomAttribute(ConstructorInfo, Byte[])Définit un attribut personnalisé à l'aide d'un objet blob d'attribut personnalisé spécifié.
Méthode publiqueSetParentDéfinit le type de base du type actuellement en construction.
Méthode publiqueToStringRetourne le nom du type sans l'espace de noms. (Substitue Type.ToString().)
Début

  NomDescription
Méthode d'extension publiqueGetCustomAttribute(Type)Surchargé. Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttribute(Type, Boolean)Surchargé. 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. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttribute<T>()Surchargé. Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttribute<T>(Boolean)Surchargé. 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. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttributes()Surchargé. Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttributes(Type)Surchargé. Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttributes<T>()Surchargé. Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetCustomAttributes<T>(Boolean)Surchargé. 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. (Défini par CustomAttributeExtensions.)
Méthode d'extension publiqueGetRuntimeEventRécupère un objet qui représente l'événement spécifié. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimeEventsRécupère une collection qui représente tous les événements définis sur un type spécifié. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimeFieldRécupère un objet qui représente un champ spécifié. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimeFieldsRécupère une collection qui représente tous les événements définis sur un type spécifié. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimeInterfaceMapRetourne un mappage d'interface pour le type et l'interface spécifiés. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimeMethodRécupère un objet qui représente une méthode spécifiée. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimeMethodsRécupère une collection qui représente toutes les méthodes définies sur un type spécifié. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimePropertiesRécupère une collection qui représente toutes les méthodes définies sur un type spécifié. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetRuntimePropertyRécupère un objet qui représente une propriété spécifiée. (Défini par RuntimeReflectionExtensions.)
Méthode d'extension publiqueGetTypeInfoRetourne la représentation TypeInfo du type spécifié. (Défini par IntrospectionExtensions.)
Méthode d'extension publiqueIsDefinedIndique si des attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié. (Défini par CustomAttributeExtensions.)
Début

  NomDescription
Champ publicMembre statiqueUnspecifiedTypeSizeReprésente la non-spécification de la taille totale pour le type.
Début

  NomDescription
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetTypeObtient un objet Type représentant la classe MemberInfo. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetTypeInfoRé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.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_Type.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Type.)
Implémentation d'interface expliciteMéthode privée_Type.GetTypeInfoRé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.)
Implémentation d'interface expliciteMéthode privée_Type.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Type.)
Implémentation d'interface expliciteMéthode privée_Type.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de Type.)
Implémentation d'interface expliciteMéthode privée_TypeBuilder.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.
Implémentation d'interface expliciteMéthode privée_TypeBuilder.GetTypeInfoRécupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.
Implémentation d'interface expliciteMéthode privée_TypeBuilder.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).
Implémentation d'interface expliciteMéthode privée_TypeBuilder.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet.
Implémentation d'interface expliciteMéthode privéeIReflectableType.GetTypeInfoRetourne une représentation du type actuel en tant qu'objet TypeInfo en cours. (Hérité de TypeInfo.)
Début

TypeBuilder est la classe racine utilisée pour contrôler la création de classes dynamiques dans le runtime. TypeBuilder fournit un jeu de routines qui sont utilisées pour définir des classes, ajouter des méthodes et des champs et créer la classe dans le runtime. Il est possible de créer un nouveau TypeBuilder à partir d'un module dynamique.

Pour créer un type de tableau, un type pointeur ou un type byref pour un type incomplet représenté par un objet TypeBuilder, utilisez la méthode MakeArrayType, la méthode MakePointerType ou la méthode MakeByRefType, respectivement.

RemarqueRemarque

L'attribut HostProtectionAttribute appliqué à ce type ou membre a la valeur de propriété Resources suivante : MayLeakOnAbort. HostProtectionAttribute n'affecte pas les applications bureautiques (qui sont généralement démarrées en double-cliquant sur une icône, en tapant une commande ou en entrant une URL dans un navigateur). Pour plus d'informations, consultez la classe HostProtectionAttribute ou Attributs de programmation et de protection des hôtes SQL Server.

Cette section comprend deux exemples de code. Le premier exemple montre la façon de créer un type dynamique avec un champ, un constructeur, une propriété et une méthode. Le deuxième exemple montre comment une méthode peut être dynamiquement générée à partir d'entrées d'utilisateur.

Premier exemple

L'exemple de code suivant montre la façon de définir un assembly dynamique avec un seul module. Dans cet exemple d'assembly, le module contient un seul type, MyDynamicType, qui a un champ privé, une propriété qui obtient et définit le champ privé, des constructeurs qui initialisent le champ privé, et une méthode qui multiplie un nombre fourni par l'utilisateur par la valeur du champ privé et qui retourne le résultat.

Le champ AssemblyBuilderAccess.RunAndSave est spécifié quand l'assembly est créé. Le code assembleur est utilisé immédiatement, et l'assembly est également enregistré sur le disque afin qu'il puisse être examiné par Ildasm.exe (Désassembleur IL) ou utilisé dans un autre programme.


using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoAssemblyBuilder
{
    public static void Main()
    {
        // An assembly consists of one or more modules, each of which
        // contains zero or more types. This code creates a single-module
        // assembly, the most common case. The module contains one type,
        // named "MyDynamicType", that has a private field, a property 
        // that gets and sets the private field, constructors that 
        // initialize the private field, and a method that multiplies 
        // a user-supplied number by the private field value and returns
        // the result. In C# the type might look like this:
        /*
        public class MyDynamicType
        {
            private int m_number;

            public MyDynamicType() : this(42) {}
            public MyDynamicType(int initNumber)
            {
                m_number = initNumber;
            }

            public int Number
            {
                get { return m_number; }
                set { m_number = value; }
            }

            public int MyMethod(int multiplier)
            {
                return m_number * multiplier;
            }
        }
        */

        AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
        AssemblyBuilder ab = 
            AppDomain.CurrentDomain.DefineDynamicAssembly(
                aName, 
                AssemblyBuilderAccess.RunAndSave);

        // For a single-module assembly, the module name is usually
        // the assembly name plus an extension.
        ModuleBuilder mb = 
            ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");

        TypeBuilder tb = mb.DefineType(
            "MyDynamicType", 
             TypeAttributes.Public);

        // Add a private field of type int (Int32).
        FieldBuilder fbNumber = tb.DefineField(
            "m_number", 
            typeof(int), 
            FieldAttributes.Private);

        // Define a constructor that takes an integer argument and 
        // stores it in the private field. 
        Type[] parameterTypes = { typeof(int) };
        ConstructorBuilder ctor1 = tb.DefineConstructor(
            MethodAttributes.Public, 
            CallingConventions.Standard, 
            parameterTypes);

        ILGenerator ctor1IL = ctor1.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before calling the base
        // class constructor. Specify the default constructor of the 
        // base class (System.Object) by passing an empty array of 
        // types (Type.EmptyTypes) to GetConstructor.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ctor1IL.Emit(OpCodes.Call, 
            typeof(object).GetConstructor(Type.EmptyTypes));
        // Push the instance on the stack before pushing the argument
        // that is to be assigned to the private field m_number.
        ctor1IL.Emit(OpCodes.Ldarg_0);
        ctor1IL.Emit(OpCodes.Ldarg_1);
        ctor1IL.Emit(OpCodes.Stfld, fbNumber);
        ctor1IL.Emit(OpCodes.Ret);

        // Define a default constructor that supplies a default value
        // for the private field. For parameter types, pass the empty
        // array of types or pass null.
        ConstructorBuilder ctor0 = tb.DefineConstructor(
            MethodAttributes.Public, 
            CallingConventions.Standard, 
            Type.EmptyTypes);

        ILGenerator ctor0IL = ctor0.GetILGenerator();
        // For a constructor, argument zero is a reference to the new
        // instance. Push it on the stack before pushing the default
        // value on the stack, then call constructor ctor1.
        ctor0IL.Emit(OpCodes.Ldarg_0);
        ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
        ctor0IL.Emit(OpCodes.Call, ctor1);
        ctor0IL.Emit(OpCodes.Ret);

        // Define a property named Number that gets and sets the private 
        // field.
        //
        // The last argument of DefineProperty is null, because the
        // property has no parameters. (If you don't specify null, you must
        // specify an array of Type objects. For a parameterless property,
        // use the built-in array with no elements: Type.EmptyTypes)
        PropertyBuilder pbNumber = tb.DefineProperty(
            "Number", 
            PropertyAttributes.HasDefault, 
            typeof(int), 
            null);

        // The property "set" and property "get" methods require a special
        // set of attributes.
        MethodAttributes getSetAttr = MethodAttributes.Public | 
            MethodAttributes.SpecialName | MethodAttributes.HideBySig;

        // Define the "get" accessor method for Number. The method returns
        // an integer and has no arguments. (Note that null could be 
        // used instead of Types.EmptyTypes)
        MethodBuilder mbNumberGetAccessor = tb.DefineMethod(
            "get_Number", 
            getSetAttr, 
            typeof(int), 
            Type.EmptyTypes);

        ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
        // For an instance property, argument zero is the instance. Load the 
        // instance, then load the private field and return, leaving the
        // field value on the stack.
        numberGetIL.Emit(OpCodes.Ldarg_0);
        numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
        numberGetIL.Emit(OpCodes.Ret);

        // Define the "set" accessor method for Number, which has no return
        // type and takes one argument of type int (Int32).
        MethodBuilder mbNumberSetAccessor = tb.DefineMethod(
            "set_Number", 
            getSetAttr, 
            null, 
            new Type[] { typeof(int) });

        ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
        // Load the instance and then the numeric argument, then store the
        // argument in the field.
        numberSetIL.Emit(OpCodes.Ldarg_0);
        numberSetIL.Emit(OpCodes.Ldarg_1);
        numberSetIL.Emit(OpCodes.Stfld, fbNumber);
        numberSetIL.Emit(OpCodes.Ret);

        // Last, map the "get" and "set" accessor methods to the 
        // PropertyBuilder. The property is now complete. 
        pbNumber.SetGetMethod(mbNumberGetAccessor);
        pbNumber.SetSetMethod(mbNumberSetAccessor);

        // Define a method that accepts an integer argument and returns
        // the product of that integer and the private field m_number. This
        // time, the array of parameter types is created on the fly.
        MethodBuilder meth = tb.DefineMethod(
            "MyMethod", 
            MethodAttributes.Public, 
            typeof(int), 
            new Type[] { typeof(int) });

        ILGenerator methIL = meth.GetILGenerator();
        // To retrieve the private instance field, load the instance it
        // belongs to (argument zero). After loading the field, load the 
        // argument one and then multiply. Return from the method with 
        // the return value (the product of the two numbers) on the 
        // execution stack.
        methIL.Emit(OpCodes.Ldarg_0);
        methIL.Emit(OpCodes.Ldfld, fbNumber);
        methIL.Emit(OpCodes.Ldarg_1);
        methIL.Emit(OpCodes.Mul);
        methIL.Emit(OpCodes.Ret);

        // Finish the type.
        Type t = tb.CreateType();

        // The following line saves the single-module assembly. This
        // requires AssemblyBuilderAccess to include Save. You can now
        // type "ildasm MyDynamicAsm.dll" at the command prompt, and 
        // examine the assembly. You can also write a program that has
        // a reference to the assembly, and use the MyDynamicType type.
        // 
        ab.Save(aName.Name + ".dll");

        // Because AssemblyBuilderAccess includes Run, the code can be
        // executed immediately. Start by getting reflection objects for
        // the method and the property.
        MethodInfo mi = t.GetMethod("MyMethod");
        PropertyInfo pi = t.GetProperty("Number");

        // Create an instance of MyDynamicType using the default 
        // constructor. 
        object o1 = Activator.CreateInstance(t);

        // Display the value of the property, then change it to 127 and 
        // display it again. Use null to indicate that the property
        // has no index.
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null));
        pi.SetValue(o1, 127, null);
        Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null));

        // Call MyMethod, passing 22, and display the return value, 22
        // times 127. Arguments must be passed as an array, even when
        // there is only one.
        object[] arguments = { 22 };
        Console.WriteLine("o1.MyMethod(22): {0}", 
            mi.Invoke(o1, arguments));

        // Create an instance of MyDynamicType using the constructor
        // that specifies m_Number. The constructor is identified by
        // matching the types in the argument array. In this case, 
        // the argument array is created on the fly. Display the 
        // property value.
        object o2 = Activator.CreateInstance(t, 
            new object[] { 5280 });
        Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, null));
    }
}

/* This code produces the following output:

o1.Number: 42
o1.Number: 127
o1.MyMethod(22): 2794
o2.Number: 5280
 */


Deuxième exemple

L'exemple de code suivant montre comment générer un type dynamique à l'aide de TypeBuilder.



using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;


class TestILGenerator {

  	public static Type DynamicDotProductGen() {
	  
	   Type ivType = null;
	   Type[] ctorParams = new Type[] { typeof(int),
		               		    typeof(int),
					    typeof(int)};
 	
	   AppDomain myDomain = Thread.GetDomain();
	   AssemblyName myAsmName = new AssemblyName();
	   myAsmName.Name = "IntVectorAsm";
	
	   AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
					  myAsmName, 
					  AssemblyBuilderAccess.RunAndSave);

   	   ModuleBuilder IntVectorModule = myAsmBuilder.DefineDynamicModule("IntVectorModule",
									    "Vector.dll");

	   TypeBuilder ivTypeBld = IntVectorModule.DefineType("IntVector",
						              TypeAttributes.Public);

	   FieldBuilder xField = ivTypeBld.DefineField("x", typeof(int),
                                                       FieldAttributes.Private);
	   FieldBuilder yField = ivTypeBld.DefineField("y", typeof(int), 
                                                       FieldAttributes.Private);
	   FieldBuilder zField = ivTypeBld.DefineField("z", typeof(int),
                                                       FieldAttributes.Private);


           Type objType = Type.GetType("System.Object"); 
           ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

	   ConstructorBuilder ivCtor = ivTypeBld.DefineConstructor(
					  MethodAttributes.Public,
					  CallingConventions.Standard,
					  ctorParams);
	   ILGenerator ctorIL = ivCtor.GetILGenerator();
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Call, objCtor);
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField); 
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField); 
           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField); 
	   ctorIL.Emit(OpCodes.Ret); 


	   // This method will find the dot product of the stored vector
	   // with another.

	   Type[] dpParams = new Type[] { ivTypeBld };

           // Here, you create a MethodBuilder containing the
	   // name, the attributes (public, static, private, and so on),
	   // the return type (int, in this case), and a array of Type
	   // indicating the type of each parameter. Since the sole parameter
	   // is a IntVector, the very class you're creating, you will
	   // pass in the TypeBuilder (which is derived from Type) instead of 
	   // a Type object for IntVector, avoiding an exception. 

	   // -- This method would be declared in C# as:
	   //    public int DotProduct(IntVector aVector)

           MethodBuilder dotProductMthd = ivTypeBld.DefineMethod(
	    		                  "DotProduct", 
				          MethodAttributes.Public,
                                          typeof(int), 
                                          dpParams);

	   // A ILGenerator can now be spawned, attached to the MethodBuilder.

	   ILGenerator mthdIL = dotProductMthd.GetILGenerator();
	   
 	   // Here's the body of our function, in MSIL form. We're going to find the
	   // "dot product" of the current vector instance with the passed vector 
	   // instance. For reference purposes, the equation is:
	   // (x1 * x2) + (y1 * y2) + (z1 * z2) = the dot product

	   // First, you'll load the reference to the current instance "this"
	   // stored in argument 0 (ldarg.0) onto the stack. Ldfld, the subsequent
	   // instruction, will pop the reference off the stack and look up the
	   // field "x", specified by the FieldInfo token "xField".

	   mthdIL.Emit(OpCodes.Ldarg_0);
	   mthdIL.Emit(OpCodes.Ldfld, xField);

	   // That completed, the value stored at field "x" is now atop the stack.
	   // Now, you'll do the same for the object reference we passed as a
	   // parameter, stored in argument 1 (ldarg.1). After Ldfld executed,
	   // you'll have the value stored in field "x" for the passed instance
	   // atop the stack.

	   mthdIL.Emit(OpCodes.Ldarg_1);
	   mthdIL.Emit(OpCodes.Ldfld, xField);

           // There will now be two values atop the stack - the "x" value for the
	   // current vector instance, and the "x" value for the passed instance.
	   // You'll now multiply them, and push the result onto the evaluation stack.

	   mthdIL.Emit(OpCodes.Mul_Ovf_Un);

	   // Now, repeat this for the "y" fields of both vectors.

	   mthdIL.Emit(OpCodes.Ldarg_0);
	   mthdIL.Emit(OpCodes.Ldfld, yField);
	   mthdIL.Emit(OpCodes.Ldarg_1);
	   mthdIL.Emit(OpCodes.Ldfld, yField);
	   mthdIL.Emit(OpCodes.Mul_Ovf_Un);

	   // At this time, the results of both multiplications should be atop
	   // the stack. You'll now add them and push the result onto the stack.

	   mthdIL.Emit(OpCodes.Add_Ovf_Un);

	   // Multiply both "z" field and push the result onto the stack.
	   mthdIL.Emit(OpCodes.Ldarg_0);
	   mthdIL.Emit(OpCodes.Ldfld, zField);
	   mthdIL.Emit(OpCodes.Ldarg_1);
	   mthdIL.Emit(OpCodes.Ldfld, zField);
	   mthdIL.Emit(OpCodes.Mul_Ovf_Un);

	   // Finally, add the result of multiplying the "z" fields with the
	   // result of the earlier addition, and push the result - the dot product -
	   // onto the stack.
	   mthdIL.Emit(OpCodes.Add_Ovf_Un);

	   // The "ret" opcode will pop the last value from the stack and return it
	   // to the calling method. You're all done!

	   mthdIL.Emit(OpCodes.Ret);


 	   ivType = ivTypeBld.CreateType();

	   return ivType;

 	}

	public static void Main() {
	
	   Type IVType = null;
           object aVector1 = null;
           object aVector2 = null;
	   Type[] aVtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aVargs1 = new object[] {10, 10, 10};
           object[] aVargs2 = new object[] {20, 20, 20};
	
	   // Call the  method to build our dynamic class.

	   IVType = DynamicDotProductGen();

           Console.WriteLine("---");

	   ConstructorInfo myDTctor = IVType.GetConstructor(aVtypes);
	   aVector1 = myDTctor.Invoke(aVargs1);
	   aVector2 = myDTctor.Invoke(aVargs2);

	   object[] passMe = new object[1];
           passMe[0] = (object)aVector2; 

	   Console.WriteLine("(10, 10, 10) . (20, 20, 20) = {0}",
			     IVType.InvokeMember("DotProduct",
						  BindingFlags.InvokeMethod,
						  null,
						  aVector1,
						  passMe));

	    

	   // +++ OUTPUT +++
	   // ---
	   // (10, 10, 10) . (20, 20, 20) = 600 
	    
	}

}



.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2015 Microsoft