Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

ConstructorBuilder (Clase)

Define y representa a un constructor de una clase dinámica.

Espacio de nombres:  System.Reflection.Emit
Ensamblado:  mscorlib (en mscorlib.dll)

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

El tipo ConstructorBuilder expone los siguientes miembros.

  NombreDescripción
Propiedad públicaAttributesRecupera los atributos de este constructor. (Invalida a MethodBase.Attributes).
Propiedad públicaCallingConventionObtiene un valor de CallingConventions que depende de que el tipo declarativo sea genérico. (Invalida a MethodBase.CallingConvention).
Propiedad públicaContainsGenericParametersObtiene un valor que indica si el método genérico contiene parámetros de tipo genérico sin asignar. (Se hereda de MethodBase).
Propiedad públicaCustomAttributesObtiene una colección que contiene los atributos personalizados de este miembro. (Se hereda de MemberInfo).
Propiedad públicaDeclaringTypeRecupera una referencia al objeto Type del tipo que declara este miembro. (Invalida a MemberInfo.DeclaringType).
Propiedad públicaInitLocalsObtiene o establece si las variables locales de este constructor deben inicializarse en cero.
Propiedad públicaIsAbstractObtiene un valor que indica si el método es abstracto. (Se hereda de MethodBase).
Propiedad públicaIsAssemblyObtiene un valor que indica si MethodAttributes.Assembly describe la visibilidad posible de este método o constructor; es decir, el método o el constructor es visible como mucho para otros tipos del mismo ensamblado y no es visible para los tipos derivados fuera del ensamblado. (Se hereda de MethodBase).
Propiedad públicaIsConstructorObtiene un valor que indica si el método es un constructor. (Se hereda de MethodBase).
Propiedad públicaIsFamilyObtiene un valor que indica si MethodAttributes.Family describe la visibilidad de este método o constructor; es decir, el método o el constructor sólo es visible dentro de su clase y clases derivadas. (Se hereda de MethodBase).
Propiedad públicaIsFamilyAndAssemblyObtiene un valor que indica si MethodAttributes.FamANDAssem describe la visibilidad de este método o constructor; es decir, las clases derivadas pueden llamar al método o constructor, pero sólo si están en el mismo ensamblado. (Se hereda de MethodBase).
Propiedad públicaIsFamilyOrAssemblyObtiene un valor que indica si MethodAttributes.FamORAssem describe la visibilidad posible de este método o constructor; es decir, las clases derivadas pueden llamar al método o constructor con independencia de dónde se encuentren, así como las clases del mismo ensamblado. (Se hereda de MethodBase).
Propiedad públicaIsFinalObtiene un valor que indica si este método es final. (Se hereda de MethodBase).
Propiedad públicaIsGenericMethodObtiene un valor que indica si el método es genérico. (Se hereda de MethodBase).
Propiedad públicaIsGenericMethodDefinitionObtiene un valor que indica si el método es una definición de método genérico. (Se hereda de MethodBase).
Propiedad públicaIsHideBySigObtiene un valor que indica si sólo hay un miembro del mismo tipo y con idéntica firma oculto en la clase derivada. (Se hereda de MethodBase).
Propiedad públicaIsPrivateObtiene un valor que indica si este miembro es privado. (Se hereda de MethodBase).
Propiedad públicaIsPublicObtiene un valor que indica si éste es un método público. (Se hereda de MethodBase).
Propiedad públicaIsSecurityCriticalObtiene un valor que indica si el método o el constructor actual es crítico para la seguridad o es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual y, por tanto, puede realizar operaciones críticas. (Se hereda de MethodBase).
Propiedad públicaIsSecuritySafeCriticalObtiene un valor que indica si el método o el constructor actual es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y está disponible desde código transparente. (Se hereda de MethodBase).
Propiedad públicaIsSecurityTransparentObtiene un valor que indica si el método o el constructor actual es transparente en el nivel de confianza actual y, por tanto, no puede realizar operaciones críticas. (Se hereda de MethodBase).
Propiedad públicaIsSpecialNameObtiene un valor que indica si este método tiene un nombre especial. (Se hereda de MethodBase).
Propiedad públicaIsStaticObtiene un valor que indica si el método es static. (Se hereda de MethodBase).
Propiedad públicaIsVirtualObtiene un valor que indica si el método es virtual. (Se hereda de MethodBase).
Propiedad públicaMemberTypeObtiene un valor de MemberTypes que indica que este miembro es un constructor. (Se hereda de ConstructorInfo).
Propiedad públicaMetadataTokenObtiene un valor que identifica un elemento de metadatos. (Se hereda de MemberInfo).
Propiedad públicaMethodHandleRecupera el identificador interno para el método. Utilice este identificador para tener acceso al identificador de metadatos subyacente. (Invalida a MethodBase.MethodHandle).
Propiedad públicaMethodImplementationFlagsObtiene las marcas MethodImplAttributes que especifican los atributos de una implementación de método. (Se hereda de MethodBase).
Propiedad públicaModuleObtiene el módulo dinámico en el que se define este constructor. (Invalida a MemberInfo.Module).
Propiedad públicaNameRecupera el nombre de este constructor. (Invalida a MemberInfo.Name).
Propiedad públicaReflectedTypeContiene una referencia al objeto Type a partir de la cual se obtuvo el objeto en cuestión. (Invalida a MemberInfo.ReflectedType).
Propiedad públicaReturnType Obsoleta. Obtiene null.
Propiedad públicaSignatureRecupera la firma del campo en formato de cadena.
Arriba

  NombreDescripción
Método públicoAddDeclarativeSecurityAgrega seguridad declarativa a este constructor.
Método públicoDefineParameterDefine un parámetro de este constructor.
Método públicoEquals Devuelve un valor que indica si esta instancia equivale al objeto especificado. (Se hereda de ConstructorInfo).
Método públicoGetCustomAttributes(Boolean)Devuelve todos los atributos personalizados definidos para este constructor. (Invalida a MemberInfo.GetCustomAttributes(Boolean)).
Método públicoGetCustomAttributes(Type, Boolean)Devuelve los atributos personalizados identificados por el tipo dado. (Invalida a MemberInfo.GetCustomAttributes(Type, Boolean)).
Método públicoGetCustomAttributesDataDevuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se han aplicado al miembro de destino. (Se hereda de MemberInfo).
Método públicoGetGenericArgumentsDevuelve una matriz de objetos Type que representan los argumentos de tipo de un método genérico o los parámetros de tipo de una definición de método genérico. (Se hereda de MethodBase).
Método públicoGetHashCodeDevuelve el código hash de esta instancia. (Se hereda de ConstructorInfo).
Método públicoGetILGenerator()Obtiene un objeto ILGenerator para este constructor.
Método públicoGetILGenerator(Int32)Obtiene un objeto ILGenerator, con el tamaño de la secuencia de MSIL especificado, que se puede utilizar para crear un cuerpo de método para este constructor.
Método públicoGetMethodBodyCuando se reemplaza en una clase derivada, obtiene un objeto MethodBody que proporciona el acceso a la secuencia de MSIL, las variables locales y las excepciones del método actual. (Se hereda de MethodBase).
Método públicoGetMethodImplementationFlagsDevuelve las marcas de implementación de método de este constructor. (Invalida a MethodBase.GetMethodImplementationFlags()).
Método públicoGetModuleDevuelve una referencia al módulo que contiene este constructor.
Método públicoGetParametersDevuelve los parámetros de este constructor. (Invalida a MethodBase.GetParameters()).
Método públicoGetTokenDevuelve el MethodToken que representa al símbolo (token) de este constructor.
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoInvoke(Object[])Invoca al constructor reflejado por esta instancia que posee los parámetros especificados, proporcionando valores predeterminados para los parámetros no utilizados frecuentemente. (Se hereda de ConstructorInfo).
Método públicoInvoke(Object, Object[])Invoca el método o constructor representado por la instancia actual, utilizando los parámetros especificados. (Se hereda de MethodBase).
Método públicoInvoke(BindingFlags, Binder, Object[], CultureInfo)Invoca dinámicamente al constructor que refleja esta instancia sobre el objeto dado, pasando los parámetros especificados y considerando las restricciones del enlazador dado. (Invalida a ConstructorInfo.Invoke(BindingFlags, Binder, Object[], CultureInfo)).
Método públicoInvoke(Object, BindingFlags, Binder, Object[], CultureInfo)Se invoca dinámicamente al constructor reflejado por esta instancia con los argumentos especificados considerando las restricciones del Binder especificado. (Invalida a MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)).
Método públicoIsDefinedComprueba si se ha definido el tipo de atributo personalizado especificado. (Invalida a MemberInfo.IsDefined(Type, Boolean)).
Método públicoSetCustomAttribute(CustomAttributeBuilder)Establece un atributo personalizado utilizando un generador de atributos personalizados.
Método públicoSetCustomAttribute(ConstructorInfo, Byte[])Establezca un atributo personalizado mediante el objeto binario de atributo personalizado especificado.
Método públicoSetImplementationFlagsEstablece las marcas de implementación de métodos para este constructor.
Método públicoSetMethodBodyCrea el cuerpo del constructor mediante una matriz de bytes especificada de las instrucciones del Lenguaje intermedio de Microsoft (MSIL).
Método públicoSetSymCustomAttributeEstablece el atributo personalizado de este constructor asociado a información simbólica.
Método públicoToStringDevuelve la instancia ConstructorBuilder como String. (Invalida a Object.ToString()).
Arriba

  NombreDescripción
Método de extensión públicoGetCustomAttribute(Type)Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttribute(Type, Boolean)Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttribute<T>()Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttribute<T>(Boolean)Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes()Sobrecargado. Recupera una colección de atributos personalizados que se aplican a un miembro especificado. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes(Type)Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes<T>()Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes<T>(Boolean)Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. (Definido por CustomAttributeExtensions).
Método de extensión públicoIsDefinedIndica si se deben aplicar atributos personalizados de un tipo especificado a un miembro especificado. (Definido por CustomAttributeExtensions).
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privado_ConstructorBuilder.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.
Implementación explícita de interfacesMétodo privado_ConstructorBuilder.GetTypeInfoRecupera la información de tipo de un objeto, que se puede utilizar después para obtener la información de tipo de una interfaz.
Implementación explícita de interfacesMétodo privado_ConstructorBuilder.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

Implementación explícita de interfacesMétodo privado_ConstructorBuilder.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto.
Implementación explícita de interfacesMétodo privado_ConstructorInfo.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.GetTypeObtiene un objeto Type que representa el tipo ConstructorInfo. (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.GetTypeInfoRecupera la información de tipo de un objeto, que se puede utilizar después para obtener la información de tipo de una interfaz. (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.Invoke_2Proporciona el acceso independiente de la versión de los objetos COM al método MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo). (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.Invoke_3Proporciona el acceso independiente de la versión de los objetos COM al método MethodBase.Invoke(Object, Object[]). (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.Invoke_4Proporciona el acceso independiente de la versión de los objetos COM al método ConstructorInfo.Invoke(BindingFlags, Binder, Object[], CultureInfo). (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_ConstructorInfo.Invoke_5Proporciona el acceso independiente de la versión de los objetos COM al método ConstructorInfo.Invoke(Object[]). (Se hereda de ConstructorInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetTypeObjeto Type que representa la clase MemberInfo. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetTypeInfoRecupera la información de tipo de un objeto, que se puede utilizar después para obtener la información de tipo de una interfaz. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MethodBase.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de MethodBase).
Implementación explícita de interfacesMétodo privado_MethodBase.GetTypePara obtener una descripción de este miembro, vea _MethodBase.GetType. (Se hereda de MethodBase).
Implementación explícita de interfacesMétodo privado_MethodBase.GetTypeInfoRecupera la información de tipo de un objeto, que se puede utilizar después para obtener la información de tipo de una interfaz. (Se hereda de MethodBase).
Implementación explícita de interfacesMétodo privado_MethodBase.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Se hereda de MethodBase).
Implementación explícita de interfacesMétodo privado_MethodBase.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsAbstractPara obtener una descripción de este miembro, vea _MethodBase.IsAbstract. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsAssemblyPara obtener una descripción de este miembro, vea _MethodBase.IsAssembly. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsConstructorPara obtener una descripción de este miembro, vea _MethodBase.IsConstructor. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsFamilyPara obtener una descripción de este miembro, vea _MethodBase.IsFamily. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsFamilyAndAssemblyPara obtener una descripción de este miembro, vea _MethodBase.IsFamilyAndAssembly. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsFamilyOrAssemblyPara obtener una descripción de este miembro, vea _MethodBase.IsFamilyOrAssembly. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsFinalPara obtener una descripción de este miembro, vea _MethodBase.IsFinal. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsHideBySigPara obtener una descripción de este miembro, vea _MethodBase.IsHideBySig. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsPrivatePara obtener una descripción de este miembro, vea _MethodBase.IsPrivate. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsPublicPara obtener una descripción de este miembro, vea _MethodBase.IsPublic. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsSpecialNamePara obtener una descripción de este miembro, vea _MethodBase.IsSpecialName. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsStaticPara obtener una descripción de este miembro, vea _MethodBase.IsStatic. (Se hereda de MethodBase).
Implementación explícita de interfacesPropiedad privada_MethodBase.IsVirtualPara obtener una descripción de este miembro, vea _MethodBase.IsVirtual. (Se hereda de MethodBase).
Arriba

Se utiliza ConstructorBuilder para describir completamente un constructor en el Lenguaje intermedio de Microsoft (MSIL), incluidos el nombre, los atributos, la firma y el cuerpo del constructor. Se utiliza junto con la clase TypeBuilder para crear clases en tiempo de ejecución. Llame a DefineConstructor para obtener una instancia de ConstructorBuilder.

Si no define un constructor para su tipo dinámico, automáticamente se proporciona un constructor predeterminado y llama al constructor predeterminado de la clase base.

Si usa ConstructorBuilder para definir un constructor para su tipo dinámico, no se proporciona un constructor predeterminado. Tiene las opciones siguientes para proporcionar un constructor predeterminado además del constructor definido:

  • Si desea un constructor predeterminado que llame simplemente al constructor predeterminado de la clase base, puede utilizar el método TypeBuilder.DefineDefaultConstructor para crear uno (y opcionalmente restringir el acceso a él). No proporcione una implementación para este constructor predeterminado. En caso contrario, se produce una excepción al intentar utilizar el constructor. No se producen excepciones cuando se llama al método TypeBuilder.CreateType.

  • Si desea un constructor predeterminado que haga algo más que simplemente llamar al constructor predeterminado de la clase base, que llame a otro constructor de la clase base o que haga algo completamente distinto, debe usar el método TypeBuilder.DefineConstructor para crear un ConstructorBuilder y proporcionar su propia implementación.

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de propiedad Resources: MayLeakOnAbort. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

En el ejemplo de código siguiente se muestra el uso contextual 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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 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 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft