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

ConstructorBuilder, classe

Définit et représente un constructeur de classe dynamique.

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

[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
public sealed class ConstructorBuilder : ConstructorInfo, 
	_ConstructorBuilder

Le type ConstructorBuilder expose les membres suivants.

  NomDescription
Propriété publiqueAttributesRécupère les attributs de ce constructeur. (Substitue MethodBase.Attributes.)
Propriété publiqueCallingConventionObtient une valeur CallingConventions qui varie selon que le type de déclaration est générique ou non. (Substitue MethodBase.CallingConvention.)
Propriété publiqueContainsGenericParametersObtient une valeur indiquant si la méthode générique contient des paramètres de type générique non assignés. (Hérité de MethodBase.)
Propriété publiqueCustomAttributesObtient une collection qui contient les attributs personnalisés de ce membre. (Hérité de MemberInfo.)
Propriété publiqueDeclaringTypeRécupère une référence à l'objet Type pour le type qui déclare ce membre. (Substitue MemberInfo.DeclaringType.)
Propriété publiqueInitLocalsObtient ou définit si les variables locales de ce constructeur doivent être initialisées à zéro.
Propriété publiqueIsAbstractObtient une valeur indiquant si la méthode est abstraite. (Hérité de MethodBase.)
Propriété publiqueIsAssemblyObtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par MethodAttributes.Assembly, c'est-à-dire si la méthode ou le constructeur est visible au maximum par d'autres types du même assembly, et n'est pas visible par des types dérivés à l'extérieur de l'assembly. (Hérité de MethodBase.)
Propriété publiqueIsConstructorObtient une valeur indiquant si la méthode est un constructeur. (Hérité de MethodBase.)
Propriété publiqueIsFamilyObtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par MethodAttributes.Family, c'est-à-dire si la méthode ou le constructeur est visible uniquement dans sa classe et dans ses classes dérivées. (Hérité de MethodBase.)
Propriété publiqueIsFamilyAndAssemblyObtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par MethodAttributes.FamANDAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées, mais uniquement si elles se trouvent dans le même assembly. (Hérité de MethodBase.)
Propriété publiqueIsFamilyOrAssemblyObtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par MethodAttributes.FamORAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées où qu'elles se trouvent, et par des classes du même assembly. (Hérité de MethodBase.)
Propriété publiqueIsFinalObtient une valeur indiquant si cette méthode est final. (Hérité de MethodBase.)
Propriété publiqueIsGenericMethodObtient une valeur indiquant si la méthode est générique. (Hérité de MethodBase.)
Propriété publiqueIsGenericMethodDefinitionObtient une valeur indiquant si la méthode est une définition de méthode générique. (Hérité de MethodBase.)
Propriété publiqueIsHideBySigObtient une valeur indiquant si seul un membre du même type, doté d'une signature identique, est caché dans la classe dérivée. (Hérité de MethodBase.)
Propriété publiqueIsPrivateObtient une valeur indiquant si ce membre est privé. (Hérité de MethodBase.)
Propriété publiqueIsPublicObtient une valeur indiquant s'il s'agit d'une méthode publique. (Hérité de MethodBase.)
Propriété publiqueIsSecurityCriticalObtient une valeur qui indique si la méthode ou le constructeur actuel est critique de sécurité (security-critical) ou critique sécurisé (security-safe-critical) au niveau de confiance actuel et peut par conséquent exécuter des opérations critiques. (Hérité de MethodBase.)
Propriété publiqueIsSecuritySafeCriticalObtient une valeur qui indique si la méthode ou le constructeur actuel est critique sécurisé au niveau de confiance actuel ; autrement dit, si la méthode ou le constructeur peut exécuter des opérations critiques et être accessible par du code transparent. (Hérité de MethodBase.)
Propriété publiqueIsSecurityTransparentObtient une valeur qui indique si la méthode ou le constructeur actuel est transparent au niveau de confiance actuel et ne peut par conséquent pas exécuter d'opérations critiques. (Hérité de MethodBase.)
Propriété publiqueIsSpecialNameObtient une valeur indiquant si cette méthode est dotée d'un nom spécial. (Hérité de MethodBase.)
Propriété publiqueIsStaticObtient une valeur indiquant si la méthode est static. (Hérité de MethodBase.)
Propriété publiqueIsVirtualObtient une valeur indiquant si la méthode est virtual. (Hérité de MethodBase.)
Propriété publiqueMemberTypeObtient une valeur MemberTypes indiquant que ce membre est un constructeur. (Hérité de ConstructorInfo.)
Propriété publiqueMetadataTokenObtient une valeur qui identifie un élément de métadonnées. (Hérité de MemberInfo.)
Propriété publiqueMethodHandleRécupère le handle interne de la méthode. Utilisez ce handle pour accéder au handle de métadonnées sous-jacent. (Substitue MethodBase.MethodHandle.)
Propriété publiqueMethodImplementationFlagsObtient les indicateurs MethodImplAttributes qui spécifient les attributs de l'implémentation d'une méthode. (Hérité de MethodBase.)
Propriété publiqueModuleObtient le module dynamique dans lequel ce constructeur est défini. (Substitue MemberInfo.Module.)
Propriété publiqueNameRécupère le nom de ce constructeur. (Substitue MemberInfo.Name.)
Propriété publiqueReflectedTypeContient une référence à l'objet Type à partir duquel cet objet a été obtenu. (Substitue MemberInfo.ReflectedType.)
Propriété publiqueReturnType Obsolète. Obtient null.
Propriété publiqueSignatureRécupère la signature du champ sous la forme d'une chaîne.
Début

  NomDescription
Méthode publiqueAddDeclarativeSecurityAjoute une sécurité déclarative à ce constructeur.
Méthode publiqueDefineParameterDéfinit un paramètre pour ce constructeur.
Méthode publiqueEqualsRetourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de ConstructorInfo.)
Méthode publiqueGetCustomAttributes(Boolean)Retourne tous les attributs personnalisés définis pour ce constructeur. (Substitue MemberInfo.GetCustomAttributes(Boolean).)
Méthode publiqueGetCustomAttributes(Type, Boolean)Retourne les attributs personnalisés identifiés par le type donné. (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 publiqueGetGenericArgumentsRetourne un tableau d'objets Type qui représentent les arguments de type d'une méthode générique ou les paramètres de type d'une définition de méthode générique. (Hérité de MethodBase.)
Méthode publiqueGetHashCodeRetourne le code de hachage de cette instance. (Hérité de ConstructorInfo.)
Méthode publiqueGetILGenerator()Obtient un ILGenerator pour ce constructeur.
Méthode publiqueGetILGenerator(Int32)Obtient un objet ILGenerator, avec la taille du flux MSIL spécifiée, permettant de construire un corps de méthode pour ce constructeur.
Méthode publiqueGetMethodBodyEn cas de substitution dans une classe dérivée, obtient un objet MethodBody qui donne accès au flux MSIL, aux variables locales et aux exceptions pour la méthode actuelle. (Hérité de MethodBase.)
Méthode publiqueGetMethodImplementationFlagsRetourne les indicateurs d'implémentation de méthodes de ce constructeur. (Substitue MethodBase.GetMethodImplementationFlags().)
Méthode publiqueGetModuleRetourne une référence au module qui contient ce constructeur.
Méthode publiqueGetParametersRetourne les paramètres de ce constructeur. (Substitue MethodBase.GetParameters().)
Méthode publiqueGetTokenRetourne MethodToken qui représente le jeton de ce constructeur.
Méthode publiqueGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueInvoke(Object[])Appelle le constructeur réfléchi par l'instance dotée des paramètres spécifiés, en fournissant des valeurs par défaut pour les paramètres peu utilisés. (Hérité de ConstructorInfo.)
Méthode publiqueInvoke(Object, Object[])Appelle la méthode ou le constructeur représentés par l'instance actuelle, à l'aide des paramètres spécifiés. (Hérité de MethodBase.)
Méthode publiqueInvoke(BindingFlags, Binder, Object[], CultureInfo)Appelle le constructeur réfléchi de manière dynamique par cette instance sur l'objet donné, et passe les paramètres spécifiés, avec les contraintes du binder donné. (Substitue ConstructorInfo.Invoke(BindingFlags, Binder, Object[], CultureInfo).)
Méthode publiqueInvoke(Object, BindingFlags, Binder, Object[], CultureInfo)Appelle de manière dynamique le constructeur réfléchi par cette instance avec les arguments spécifiés et les contraintes du Binder spécifié. (Substitue MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo).)
Méthode publiqueIsDefinedVérifie si le type d'attribut personnalisé spécifié est défini. (Substitue MemberInfo.IsDefined(Type, Boolean).)
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 publiqueSetImplementationFlagsDéfinit les indicateurs d'implémentation de méthodes de ce constructeur.
Méthode publiqueSetMethodBodyCrée le corps du constructeur à l'aide d'un tableau d'octets d'instructions MSIL (Microsoft Intermediate Language) spécifié.
Méthode publiqueSetSymCustomAttributeDéfinit l'attribut personnalisé de ce constructeur associé aux informations de symbole.
Méthode publiqueToStringRetourne cette instance de ConstructorBuilder en tant que String. (Substitue Object.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 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
Implémentation d'interface expliciteMéthode privée_ConstructorBuilder.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.
Implémentation d'interface expliciteMéthode privée_ConstructorBuilder.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_ConstructorBuilder.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_ConstructorBuilder.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet.
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.GetTypeObtient un objet Type représentant le type ConstructorInfo. (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.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 ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.Invoke_2Fournit des objets COM avec un accès indépendant de la version à la méthode MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo). (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.Invoke_3Fournit des objets COM avec un accès indépendant de la version à la méthode MethodBase.Invoke(Object, Object[]). (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.Invoke_4Fournit des objets COM avec un accès indépendant de la version à la méthode ConstructorInfo.Invoke(BindingFlags, Binder, Object[], CultureInfo). (Hérité de ConstructorInfo.)
Implémentation d'interface expliciteMéthode privée_ConstructorInfo.Invoke_5Fournit des objets COM avec un accès indépendant de la version à la méthode ConstructorInfo.Invoke(Object[]). (Hérité de ConstructorInfo.)
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_MethodBase.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.GetTypePour obtenir une description de ce membre, consultez _MethodBase.GetType. (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.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 MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsAbstractPour obtenir une description de ce membre, consultez _MethodBase.IsAbstract. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsAssemblyPour obtenir une description de ce membre, consultez _MethodBase.IsAssembly. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsConstructorPour obtenir une description de ce membre, consultez _MethodBase.IsConstructor. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFamilyPour obtenir une description de ce membre, consultez _MethodBase.IsFamily. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFamilyAndAssemblyPour obtenir une description de ce membre, consultez _MethodBase.IsFamilyAndAssembly. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFamilyOrAssemblyPour obtenir une description de ce membre, consultez _MethodBase.IsFamilyOrAssembly. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFinalPour obtenir une description de ce membre, consultez _MethodBase.IsFinal. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsHideBySigPour obtenir une description de ce membre, consultez _MethodBase.IsHideBySig. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsPrivatePour obtenir une description de ce membre, consultez _MethodBase.IsPrivate. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsPublicPour obtenir une description de ce membre, consultez _MethodBase.IsPublic. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsSpecialNamePour obtenir une description de ce membre, consultez _MethodBase.IsSpecialName. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsStaticPour obtenir une description de ce membre, consultez _MethodBase.IsStatic. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsVirtualPour obtenir une description de ce membre, consultez _MethodBase.IsVirtual. (Hérité de MethodBase.)
Début

ConstructorBuilder permet la description complète d'un constructeur en langage MSIL (Microsoft Intermediate Language), avec notamment le nom, les attributs, la signature et le corps du constructeur. Il est utilisé en association avec la classe TypeBuilder pour créer des classes au moment de l'exécution. Appelez DefineConstructor pour obtenir une instance de ConstructorBuilder.

Si vous ne définissez pas de constructeur pour votre type dynamique, un constructeur par défaut est fourni automatiquement et appelle le constructeur par défaut de la classe de base.

Si vous utilisez ConstructorBuilder pour définir un constructeur pour votre type dynamique, aucun constructeur par défaut n'est fourni. Les options suivantes vous permettent de fournir un constructeur par défaut en complément du constructeur que vous avez défini :

  • Si vous souhaitez un constructeur par défaut qui appelle simplement le constructeur par défaut de la classe de base, vous pouvez utiliser la méthode TypeBuilder.DefineDefaultConstructor pour le créer (et éventuellement y restreindre l'accès). Ne fournissez pas d'implémentation pour ce constructeur par défaut. Sinon, une exception est levée lorsque vous tentez d'utiliser le constructeur. Aucune exception n'est levée lorsque la méthode TypeBuilder.CreateType est appelée.

  • Si vous souhaitez que le constructeur par défaut ne se contente pas d'appeler le constructeur par défaut de la classe de base, qu'il appelle un autre constructeur de la classe de base ou qu'il effectue une toute autre opération, vous devez utiliser la méthode TypeBuilder.DefineConstructor pour créer un ConstructorBuilder et fournir votre propre implémentation.

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.

L'exemple de code suivant illustre l'utilisation contextuelle de ConstructorBuilder.



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

class TestCtorBuilder {

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

   	   ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
									"Point.dll");

	   TypeBuilder pointTypeBld = pointModule.DefineType("Point",
						              TypeAttributes.Public);

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


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

	   ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
					  MethodAttributes.Public,
					  CallingConventions.Standard,
					  ctorParams);
	   ILGenerator ctorIL = pointCtor.GetILGenerator();

	   // NOTE: ldarg.0 holds the "this" reference - ldarg.1, ldarg.2, and ldarg.3
	   // hold the actual passed parameters. ldarg.0 is used by instance methods
	   // to hold a reference to the current calling object instance. Static methods
	   // do not use arg.0, since they are not instantiated and hence no reference
	   // is needed to distinguish them. 

           ctorIL.Emit(OpCodes.Ldarg_0);

	   // Here, we wish to create an instance of System.Object by invoking its
  	   // constructor, as specified above.

           ctorIL.Emit(OpCodes.Call, objCtor);

	   // Now, we'll load the current instance ref in arg 0, along
	   // with the value of parameter "x" stored in arg 1, into stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_1);
           ctorIL.Emit(OpCodes.Stfld, xField); 

	   // Now, we store arg 2 "y" in the current instance with stfld.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_2);
           ctorIL.Emit(OpCodes.Stfld, yField); 

	   // Last of all, arg 3 "z" gets stored in the current instance.

           ctorIL.Emit(OpCodes.Ldarg_0);
           ctorIL.Emit(OpCodes.Ldarg_3);
           ctorIL.Emit(OpCodes.Stfld, zField); 

           // Our work complete, we return.

	   ctorIL.Emit(OpCodes.Ret); 

	   // Now, let's create three very simple methods so we can see our fields.

	   string[] mthdNames = new string[] {"GetX", "GetY", "GetZ"}; 

           foreach (string mthdName in mthdNames) {
              MethodBuilder getFieldMthd = pointTypeBld.DefineMethod(
				           mthdName, 
				           MethodAttributes.Public,
                                           typeof(int), 
                                           null);
	      ILGenerator mthdIL = getFieldMthd.GetILGenerator();
	   
	      mthdIL.Emit(OpCodes.Ldarg_0);
  	      switch (mthdName) {
	         case "GetX": mthdIL.Emit(OpCodes.Ldfld, xField);
			      break;
	         case "GetY": mthdIL.Emit(OpCodes.Ldfld, yField);
			      break;
	         case "GetZ": mthdIL.Emit(OpCodes.Ldfld, zField);
			      break;

	      }
	      mthdIL.Emit(OpCodes.Ret);

           }
	   // Finally, we create the type.

 	   pointType = pointTypeBld.CreateType();

	   // Let's save it, just for posterity.
	   
	   myAsmBuilder.Save("Point.dll");
	
	   return pointType;

 	}

	public static void Main() {
	
	   Type myDynamicType = null;
           object aPoint = null;
	   Type[] aPtypes = new Type[] {typeof(int), typeof(int), typeof(int)};
           object[] aPargs = new object[] {4, 5, 6};
	
	   // Call the  method to build our dynamic class.

	   myDynamicType = DynamicPointTypeGen();

	   Console.WriteLine("Some information about my new Type '{0}':",
			      myDynamicType.FullName);
	   Console.WriteLine("Assembly: '{0}'", myDynamicType.Assembly);
	   Console.WriteLine("Attributes: '{0}'", myDynamicType.Attributes);
	   Console.WriteLine("Module: '{0}'", myDynamicType.Module);
	   Console.WriteLine("Members: "); 
	   foreach (MemberInfo member in myDynamicType.GetMembers()) {
		Console.WriteLine("-- {0} {1};", member.MemberType, member.Name);
	   }

           Console.WriteLine("---");

	   // Let's take a look at the constructor we created.

	   ConstructorInfo myDTctor = myDynamicType.GetConstructor(aPtypes);
           Console.WriteLine("Constructor: {0};", myDTctor.ToString());

           Console.WriteLine("---");
	  
           // Now, we get to use our dynamically-created class by invoking the constructor. 

	   aPoint = myDTctor.Invoke(aPargs);
           Console.WriteLine("aPoint is type {0}.", aPoint.GetType());
	   	   

	   // Finally, let's reflect on the instance of our new type - aPoint - and
	   // make sure everything proceeded according to plan.

	   Console.WriteLine("aPoint.x = {0}",
			     myDynamicType.InvokeMember("GetX",
						        BindingFlags.InvokeMethod,
							null,
							aPoint,
							new object[0]));
	   Console.WriteLine("aPoint.y = {0}",
			     myDynamicType.InvokeMember("GetY",
						        BindingFlags.InvokeMethod,
							null,
							aPoint,
							new object[0]));
	   Console.WriteLine("aPoint.z = {0}",
			     myDynamicType.InvokeMember("GetZ",
						        BindingFlags.InvokeMethod,
							null,
							aPoint,
							new object[0]));

	    

	   // +++ OUTPUT +++
	   // Some information about my new Type 'Point':
	   // Assembly: 'MyDynamicAssembly, Version=0.0.0.0'
	   // Attributes: 'AutoLayout, AnsiClass, NotPublic, Public'
	   // Module: 'PointModule'
	   // Members: 
	   // -- Field x;
	   // -- Field y;
	   // -- Field z;
           // -- Method GetHashCode;
           // -- Method Equals;
           // -- Method ToString;
           // -- Method GetType;
           // -- Constructor .ctor;
	   // ---
	   // Constructor: Void .ctor(Int32, Int32, Int32);
	   // ---
	   // aPoint is type Point.
	   // aPoint.x = 4
	   // aPoint.y = 5
	   // aPoint.z = 6
	    
	}

}



.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
Afficher:
© 2014 Microsoft