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

TypeBuilder (Clase)

Define y crea nuevas instancias de clases en tiempo de ejecución.

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

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

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

El tipo TypeBuilder expone los siguientes miembros.

  NombreDescripción
Propiedad públicaAssemblyRecupera el ensamblado dinámico que contiene la definición de este tipo. (Invalida a Type.Assembly).
Propiedad públicaAssemblyQualifiedNameDevuelve el nombre completo de este tipo calificado por el nombre de presentación del ensamblado. (Invalida a Type.AssemblyQualifiedName).
Propiedad públicaAttributesObtiene los atributos asociados a Type. (Se hereda de Type).
Propiedad públicaBaseTypeRecupera el tipo base de este tipo. (Invalida a Type.BaseType).
Propiedad públicaContainsGenericParametersObtiene un valor que indica si el objeto Type actual tiene parámetros de tipo que no han sido reemplazados por tipos específicos. (Se hereda de Type).
Propiedad públicaCustomAttributesObtiene una colección que contiene los atributos personalizados de este miembro. (Se hereda de MemberInfo).
Propiedad públicaDeclaredConstructorsObtiene una colección de los constructores declarados por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredEventsObtiene una colección de los eventos definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredFieldsObtiene una colección de los campos definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredMembersObtiene una colección de los miembros definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredMethodsObtiene una colección de los métodos definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredNestedTypesObtiene una colección de los tipos anidados definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredPropertiesObtiene una colección de las propiedades definidas por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaringMethodObtiene el método que declaró el parámetro de tipo genérico actual. (Invalida a Type.DeclaringMethod).
Propiedad públicaDeclaringTypeDevuelve el tipo que declara este tipo. (Invalida a Type.DeclaringType).
Propiedad públicaFullNameRecupera la ruta de acceso completa de este tipo. (Invalida a Type.FullName).
Propiedad públicaGenericParameterAttributesObtiene un valor que indica la covarianza y las restricciones especiales del parámetro de tipo genérico actual. (Invalida a Type.GenericParameterAttributes).
Propiedad públicaGenericParameterPositionObtiene la posición del parámetro de tipo en la lista de parámetros de tipo del tipo genérico que declaró el parámetro. (Invalida a Type.GenericParameterPosition).
Propiedad públicaGenericTypeArgumentsObtiene una matriz de los argumentos de tipo genérico para este tipo. (Se hereda de Type).
Propiedad públicaGenericTypeParametersObtiene una matriz de los parámetros genéricos del tipo actual. (Se hereda de TypeInfo).
Propiedad públicaGUIDRecupera el GUID de este tipo. (Invalida a Type.GUID).
Propiedad públicaHasElementTypeObtiene un valor que indica si el objeto Type actual engloba o hace referencia a otro tipo; es decir, si el objeto Type actual es una matriz o un puntero, o si se pasa por referencia. (Se hereda de Type).
Propiedad públicaImplementedInterfacesObtiene una colección de las interfaces implementadas por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaIsAbstractObtiene un valor que indica si Type es abstracto y se debe invalidar. (Se hereda de Type).
Propiedad públicaIsAnsiClassObtiene un valor que indica si se selecciona el atributo de formato de cadena AnsiClass para el objeto Type. (Se hereda de Type).
Propiedad públicaIsArrayObtiene un valor que indica si Type es una matriz. (Se hereda de Type).
Propiedad públicaIsAutoClassObtiene un valor que indica si se selecciona el atributo de formato de cadena AutoClass para el objeto Type. (Se hereda de Type).
Propiedad públicaIsAutoLayoutObtiene un valor que indica si los campos de tipo de la actual se disponen automáticamente mediante Common Language Runtime. (Se hereda de Type).
Propiedad públicaIsByRefObtiene un valor que indica si Type se pasa por referencia. (Se hereda de Type).
Propiedad públicaIsClassObtiene un valor que indica si Type es una clase, es decir, no es un tipo de valor ni una interfaz. (Se hereda de Type).
Propiedad públicaIsCOMObjectObtiene un valor que indica si Type es un objeto COM. (Se hereda de Type).
Propiedad públicaIsConstructedGenericTypeObtiene un valor que indica si este objeto representa un tipo genérico construido. (Invalida a Type.IsConstructedGenericType).
Propiedad públicaIsContextfulObtiene un valor que indica si Type puede estar hospedado en un contexto. (Se hereda de Type).
Propiedad públicaIsEnumObtiene un valor que indica si el objeto Type actual representa una enumeración. (Se hereda de Type).
Propiedad públicaIsExplicitLayoutObtiene un valor que indica si los campos del tipo actual se disponen en los desplazamientos especificados explícitamente. (Se hereda de Type).
Propiedad públicaIsGenericParameterObtiene un valor que indica si el tipo actual es un parámetro de tipo genérico. (Invalida a Type.IsGenericParameter).
Propiedad públicaIsGenericTypeObtiene un valor que indica si el tipo actual es genérico. (Invalida a Type.IsGenericType).
Propiedad públicaIsGenericTypeDefinitionObtiene un valor que indica si el objeto TypeBuilder actual representa una definición de tipo genérico, a partir de la cual se pueden construir otros tipos genéricos. (Invalida a Type.IsGenericTypeDefinition).
Propiedad públicaIsImportObtiene un valor que indica si el objeto Type tiene aplicado un atributo ComImportAttribute, lo que indica que se ha importado de una biblioteca de tipos COM. (Se hereda de Type).
Propiedad públicaIsInterfaceObtiene un valor que indica si Type es una interfaz, es decir, no es una clase ni un tipo de valor. (Se hereda de Type).
Propiedad públicaIsLayoutSequentialObtiene un valor que indica si los campos del tipo actual se disponen secuencialmente, en el orden que se definieron o emitieron en los metadatos. (Se hereda de Type).
Propiedad públicaIsMarshalByRefObtiene un valor que indica si las referencias de Type se calculan por referencia. (Se hereda de Type).
Propiedad públicaIsNestedObtiene un valor que indica si el objeto Type actual representa un tipo cuya definición está anidada dentro de la definición de otro tipo. (Se hereda de Type).
Propiedad públicaIsNestedAssemblyObtiene un valor que indica si Type está anidado y solo se ve dentro de su propio ensamblado. (Se hereda de Type).
Propiedad públicaIsNestedFamANDAssemObtiene un valor que indica si Type está anidado y solo está visible para las clases que pertenezcan tanto a su propia familia como a su propio ensamblado. (Se hereda de Type).
Propiedad públicaIsNestedFamilyObtiene un valor que indica si Type está anidado y solo se ve dentro de su propia familia. (Se hereda de Type).
Propiedad públicaIsNestedFamORAssemObtiene un valor que indica si Type está anidado y solo está visible para las clases que pertenezcan a su propia familia o a su propio ensamblado. (Se hereda de Type).
Propiedad públicaIsNestedPrivateObtiene un valor que indica si Type está anidado y se ha declarado privado. (Se hereda de Type).
Propiedad públicaIsNestedPublicObtiene un valor que indica si hay una clase anidada que se ha declarado pública. (Se hereda de Type).
Propiedad públicaIsNotPublicObtiene un valor que indica si el objeto Type no se ha declarado público. (Se hereda de Type).
Propiedad públicaIsPointerObtiene un valor que indica si el objeto Type es un puntero. (Se hereda de Type).
Propiedad públicaIsPrimitiveObtiene un valor que indica si el objeto Type es uno de los tipos primitivos. (Se hereda de Type).
Propiedad públicaIsPublicObtiene un valor que indica si el objeto Type se ha declarado público. (Se hereda de Type).
Propiedad públicaIsSealedObtiene un valor que indica si Type se declaró "sealed". (Se hereda de Type).
Propiedad públicaIsSecurityCriticalObtiene un valor que indica si el tipo actual es crítico para la seguridad o es crítico para la seguridad y disponible desde código transparente y, por tanto, puede realizar operaciones críticas. (Invalida a Type.IsSecurityCritical).
Propiedad públicaIsSecuritySafeCriticalObtiene un valor que indica si el tipo actual es crítico para la seguridad y disponible desde código transparente; es decir, si puede realizar operaciones críticas y está disponible desde código transparente. (Invalida a Type.IsSecuritySafeCritical).
Propiedad públicaIsSecurityTransparentObtiene un valor que indica si el tipo actual es transparente y, por tanto, no puede realizar operaciones críticas. (Invalida a Type.IsSecurityTransparent).
Propiedad públicaIsSerializableObtiene un valor que indica si el objeto Type es serializable. (Se hereda de Type).
Propiedad públicaIsSpecialNameObtiene un valor que indica si Type tiene un nombre que requiere un tratamiento especial. (Se hereda de Type).
Propiedad públicaIsUnicodeClassObtiene un valor que indica si se selecciona el atributo de formato de cadena UnicodeClass para el objeto Type. (Se hereda de Type).
Propiedad públicaIsValueTypeObtiene un valor que indica si el objeto Type es un tipo de valor. (Se hereda de Type).
Propiedad públicaIsVisibleObtiene un valor que indica si se puede obtener acceso al objeto Type mediante el código fuera del ensamblado. (Se hereda de Type).
Propiedad públicaMemberTypeObtiene un valor de MemberTypes que indica que este miembro es un tipo o un tipo anidado. (Se hereda de Type).
Propiedad públicaMetadataTokenObtiene un valor que identifica un elemento de metadatos. (Se hereda de MemberInfo).
Propiedad públicaModuleRecupera el módulo dinámico que contiene la definición de este tipo. (Invalida a Type.Module).
Propiedad públicaNameRecupera el nombre de este tipo. (Invalida a MemberInfo.Name).
Propiedad públicaNamespaceRecupera el espacio de nombres en el que está definido este TypeBuilder. (Invalida a Type.Namespace).
Propiedad públicaPackingSizeRecupera el tamaño de paquete de este tipo.
Propiedad públicaReflectedTypeDevuelve el tipo utilizado para obtener este tipo. (Invalida a Type.ReflectedType).
Propiedad públicaSizeRecupera el tamaño total de un tipo.
Propiedad públicaStructLayoutAttributeObtiene una clase StructLayoutAttribute que describe el diseño del tipo actual. (Se hereda de Type).
Propiedad públicaTypeHandleNo es compatible en módulos dinámicos. (Invalida a Type.TypeHandle).
Propiedad públicaTypeInitializerObtiene el inicializador del objeto Type. (Se hereda de Type).
Propiedad públicaTypeTokenDevuelve el símbolo (token) de tipo de este tipo.
Propiedad públicaUnderlyingSystemTypeDevuelve el tipo de sistema subyacente para este TypeBuilder. (Invalida a Type.UnderlyingSystemType).
Arriba

  NombreDescripción
Método públicoAddDeclarativeSecurityAgrega seguridad declarativa a este tipo.
Método públicoAddInterfaceImplementationAgrega una interfaz que implementa este tipo.
Método públicoAsTypeDevuelve el tipo actual como un objeto Type. (Se hereda de TypeInfo).
Método públicoCreateTypeCrea un objeto Type para la clase. Después de definir los campos y los métodos en la clase, se llama a CreateType para cargar el objeto Type.
Método públicoCreateTypeInfoObtiene un objeto TypeInfo que representa este tipo.
Método públicoDefineConstructor(MethodAttributes, CallingConventions, Type[])Agrega un nuevo constructor al tipo, con los atributos y signatura especificados.
Método públicoDefineConstructor(MethodAttributes, CallingConventions, Type[], Type[][], Type[][])Agrega un nuevo constructor al tipo, con los atributos, la signatura y los modificadores personalizados especificados.
Método públicoDefineDefaultConstructorDefine el constructor predeterminado. El constructor definido aquí simplemente llamará al constructor predeterminado del elemento principal.
Método públicoDefineEventAgrega un nuevo evento al tipo, con el nombre, los atributos y el tipo de evento especificados.
Método públicoDefineField(String, Type, FieldAttributes)Agrega un nuevo campo al tipo, con el nombre, los atributos y el tipo de campo especificados.
Método públicoDefineField(String, Type, Type[], Type[], FieldAttributes)Agrega un nuevo campo al tipo, con el nombre, los atributos, el tipo de campo y los modificadores personalizados especificados.
Método públicoDefineGenericParametersDefine los parámetros de tipo genérico para el tipo actual, especificando su número y sus nombres, y devuelve una matriz de objetos GenericTypeParameterBuilder que se pueden utilizar para establecer sus restricciones.
Método públicoDefineInitializedDataDefine un campo de datos inicializado en la sección .sdata del archivo ejecutable portable (PE).
Método públicoDefineMethod(String, MethodAttributes)Agrega un nuevo método al tipo, con el nombre y los atributos de método especificados.
Método públicoDefineMethod(String, MethodAttributes, CallingConventions)Agrega un nuevo método al tipo, con la convención de llamada, el nombre y los atributos de método especificados.
Método públicoDefineMethod(String, MethodAttributes, Type, Type[])Agrega un nuevo método al tipo, con la signatura de método, el nombre y los atributos de método especificados.
Método públicoDefineMethod(String, MethodAttributes, CallingConventions, Type, Type[])Agrega un nuevo método al tipo, con la signatura de método, la convención de llamada, el nombre y los atributos de método especificados.
Método públicoDefineMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])Agrega un nuevo método al tipo, con el nombre, los atributos de método, la convención de llamada, la signatura de método, y los modificadores personalizados especificados.
Método públicoDefineMethodOverrideEspecifica un cuerpo de método determinado que implementa una declaración de método específica, posiblemente con otro nombre.
Método públicoDefineNestedType(String)Define un tipo anidado a partir de su nombre.
Método públicoDefineNestedType(String, TypeAttributes)Define un tipo anidado a partir del nombre y los atributos.
Método públicoDefineNestedType(String, TypeAttributes, Type)Define un tipo anidado a partir del nombre, los atributos y el tipo que extiende.
Método públicoDefineNestedType(String, TypeAttributes, Type, Int32)Define un tipo anidado a partir del nombre, los atributos, el tamaño total del tipo y el tipo que extiende.
Método públicoDefineNestedType(String, TypeAttributes, Type, PackingSize)Define un tipo anidado a partir del nombre, los atributos, el tipo que extiende y el tamaño de empaquetado.
Método públicoDefineNestedType(String, TypeAttributes, Type, Type[])Define un tipo anidado a partir del nombre, los atributos, el tipo que extiende y las interfaces que implementa.
Método públicoDefineNestedType(String, TypeAttributes, Type, PackingSize, Int32)Define un tipo anidado a partir del nombre, los atributos, el tamaño y el tipo que extiende.
Método públicoDefinePInvokeMethod(String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)Define un método PInvoke a partir del nombre, el nombre de la DLL en la que se define el método, los atributos del método, la convención de llamadas del método, el tipo de valor devuelto del método, los tipos de los parámetros del método y las marcas de PInvoke.
Método públicoDefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], CallingConvention, CharSet)Define un método PInvoke a partir del nombre, el nombre de la DLL en la que se define el método, el nombre del punto de entrada, los atributos del método, la convención de llamadas del método, el tipo de valor devuelto del método, los tipos de los parámetros del método y las marcas de PInvoke.
Método públicoDefinePInvokeMethod(String, String, String, MethodAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], CallingConvention, CharSet)Define un método PInvoke a partir del nombre, el nombre de la DLL en la que se define el método, el nombre del punto de entrada, los atributos del método, la convención de llamadas del método, el tipo de valor devuelto del método, los tipos de los parámetros del método, las marcas de PInvoke y los modificadores personalizados de los parámetros y del tipo de valor devuelto.
Método públicoDefineProperty(String, PropertyAttributes, Type, Type[])Agrega una nueva propiedad al tipo, con el nombre y la signatura de propiedad especificados.
Método públicoDefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[])Agrega una nueva propiedad al tipo, con el nombre, los atributos, la convención de llamada y la firma de propiedad especificados.
Método públicoDefineProperty(String, PropertyAttributes, Type, Type[], Type[], Type[], Type[][], Type[][])Agrega una nueva propiedad al tipo, con el nombre, la signatura de propiedad y los modificadores personalizados especificados.
Método públicoDefineProperty(String, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][])Agrega una nueva propiedad al tipo, con el nombre, la convención de llamada, la firma de propiedad y los modificadores personalizados especificados.
Método públicoDefineTypeInitializerDefine el inicializador para este tipo.
Método públicoDefineUninitializedDataDefine un campo de datos sin inicializar en la sección .sdata del archivo portable ejecutable (PE).
Método públicoEquals(Object)Determina si el tipo de sistema subyacente del objeto Type actual es igual que el tipo de sistema subyacente del objeto Object especificado. (Se hereda de Type).
Método públicoEquals(Type)Determina si el tipo de sistema subyacente del objeto Type actual es igual que el tipo de sistema subyacente del objeto Type especificado. (Se hereda de Type).
Método públicoFindInterfacesDevuelve una matriz de objetos Type que representa una lista filtrada de interfaces implementadas o heredadas por el objeto Type actual. (Se hereda de Type).
Método públicoFindMembersDevuelve una matriz filtrada de objetos MemberInfo del tipo del miembro especificado. (Se hereda de Type).
Método públicoGetArrayRankObtiene el número de dimensiones de Array. (Se hereda de Type).
Método públicoGetConstructor(Type[])Busca un constructor de instancia público cuyos parámetros coincidan con los tipos de la matriz especificada. (Se hereda de Type).
Método públicoMiembro estáticoGetConstructor(Type, ConstructorInfo)Devuelve el constructor del tipo genérico construido especificado que corresponde al constructor especificado de la definición de tipo genérico.
Método públicoGetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])Busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, mediante las restricciones de enlace también especificadas. (Se hereda de Type).
Método públicoGetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])Busca un constructor cuyos parámetros coincidan con los modificadores y tipos de argumento especificados, mediante las restricciones de enlace indicadas y la convención de llamadas también especificada. (Se hereda de Type).
Método públicoGetConstructors()Devuelve todos los constructores públicos definidos para el objeto Type actual. (Se hereda de Type).
Método públicoGetConstructors(BindingFlags)Devuelve una matriz de objetos ConstructorInfo que representa a los constructores públicos y no públicos definidos para esta clase, tal y como se especifica. (Invalida a Type.GetConstructors(BindingFlags)).
Método públicoGetCustomAttributes(Boolean)Devuelve todos los atributos personalizados definidos para este tipo. (Invalida a MemberInfo.GetCustomAttributes(Boolean)).
Método públicoGetCustomAttributes(Type, Boolean)Devuelve todos los atributos personalizados del tipo actual que se pueden asignar a un tipo especificado. (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úblicoGetDeclaredEventDevuelve un objeto que representa el evento público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredFieldDevuelve un objeto que representa el campo público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredMethodDevuelve un objeto que representa el método público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredMethodsDevuelve una colección que contiene todos los métodos públicos declarados en el tipo actual que coinciden con el nombre especificado. (Se hereda de TypeInfo).
Método públicoGetDeclaredNestedTypeDevuelve un objeto que representa el tipo anidado público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredPropertyDevuelve un objeto que representa la propiedad pública especificada declarada por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDefaultMembersBusca los miembros definidos para el objeto Type actual cuya clase DefaultMemberAttribute esté establecida. (Se hereda de Type).
Método públicoGetElementTypeCuando se llama a este método, siempre se produce NotSupportedException. (Invalida a Type.GetElementType()).
Método públicoGetEnumNameDevuelve el nombre de la constante que tiene el valor especificado para el tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEnumNamesDevuelve los nombres de los miembros del tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEnumUnderlyingTypeDevuelve el tipo subyacente del tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEnumValuesDevuelve una matriz con los valores de las constantes en el tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEvent(String)Devuelve el objeto EventInfo que representa el evento público especificado. (Se hereda de Type).
Método públicoGetEvent(String, BindingFlags)Devuelve el evento con el nombre especificado. (Invalida a Type.GetEvent(String, BindingFlags)).
Método públicoGetEvents()Devuelve los eventos públicos declarados o heredados por este tipo. (Invalida a Type.GetEvents()).
Método públicoGetEvents(BindingFlags)Devuelve los eventos públicos y no públicos declarados por este tipo. (Invalida a Type.GetEvents(BindingFlags)).
Método públicoGetField(String)Busca el campo público con el nombre especificado. (Se hereda de Type).
Método públicoGetField(String, BindingFlags)Devuelve el campo especificado por el nombre dado. (Invalida a Type.GetField(String, BindingFlags)).
Método públicoMiembro estáticoGetField(Type, FieldInfo)Devuelve el campo del tipo genérico construido especificado que corresponde al campo especificado de la definición de tipo genérico.
Método públicoGetFields()Devuelve todos los campos públicos del objeto Type actual. (Se hereda de Type).
Método públicoGetFields(BindingFlags)Devuelve los campos públicos y no públicos declarados por este tipo. (Invalida a Type.GetFields(BindingFlags)).
Método públicoGetGenericArgumentsDevuelve una matriz de objetos Type que representan los argumentos de tipo de un tipo genérico o los parámetros de tipo de una definición de tipo genérico. (Invalida a Type.GetGenericArguments()).
Método públicoGetGenericParameterConstraintsDevuelve una matriz de objetos Type que representan las restricciones en el parámetro de tipo genérico actual. (Se hereda de Type).
Método públicoGetGenericTypeDefinitionDevuelve un objeto Type que representa una definición de tipo genérico a partir de la cual se puede obtener el tipo actual. (Invalida a Type.GetGenericTypeDefinition()).
Método públicoGetHashCodeDevuelve el código hash de esta instancia. (Se hereda de Type).
Método públicoGetInterface(String)Busca la interfaz con el nombre especificado. (Se hereda de Type).
Método públicoGetInterface(String, Boolean)Devuelve la interfaz implementada por esta clase (directa o indirectamente) con el nombre completo que coincide con el nombre de la interfaz dada. (Invalida a Type.GetInterface(String, Boolean)).
Método públicoGetInterfaceMapDevuelve una asignación de interfaz para la interfaz solicitada. (Invalida a Type.GetInterfaceMap(Type)).
Método públicoGetInterfacesDevuelve una matriz de todas las interfaces implementadas en este tipo y sus tipos base. (Invalida a Type.GetInterfaces()).
Método públicoGetMember(String)Busca los miembros públicos con el nombre especificado. (Se hereda de Type).
Método públicoGetMember(String, BindingFlags)Busca los miembros especificados mediante las restricciones de enlace especificadas. (Se hereda de Type).
Método públicoGetMember(String, MemberTypes, BindingFlags)Devuelve todos los miembros públicos y no públicos declarados o heredados por este tipo, tal como se especifica. (Invalida a Type.GetMember(String, MemberTypes, BindingFlags)).
Método públicoGetMembers()Devuelve todos los miembros públicos del objeto Type actual. (Se hereda de Type).
Método públicoGetMembers(BindingFlags)Devuelve los miembros para los miembros públicos y no públicos declarados o heredados por este tipo. (Invalida a Type.GetMembers(BindingFlags)).
Método públicoGetMethod(String)Busca el método público con el nombre especificado. (Se hereda de Type).
Método públicoGetMethod(String, BindingFlags)Busca el método especificado mediante las restricciones de enlace especificadas. (Se hereda de Type).
Método públicoGetMethod(String, Type[])Busca el método público especificado cuyos parámetros coincidan con los tipos de argumentos especificados. (Se hereda de Type).
Método públicoMiembro estáticoGetMethod(Type, MethodInfo)Devuelve el método del tipo genérico construido especificado que corresponde al método especificado de la definición de tipo genérico.
Método públicoGetMethod(String, Type[], ParameterModifier[])Busca el método público especificado cuyos parámetros coincidan con los tipos y modificadores de argumento especificados. (Se hereda de Type).
Método públicoGetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. (Se hereda de Type).
Método públicoGetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, usando las restricciones de enlace indicadas y la convención de llamada especificada. (Se hereda de Type).
Método públicoGetMethods()Devuelve todos los métodos públicos del objeto Type actual. (Se hereda de Type).
Método públicoGetMethods(BindingFlags)Devuelve los métodos públicos y no públicos declarados o heredados por este tipo, tal como se especifica. (Invalida a Type.GetMethods(BindingFlags)).
Método públicoGetNestedType(String)Busca el tipo anidado público con el nombre especificado. (Se hereda de Type).
Método públicoGetNestedType(String, BindingFlags)Devuelve los campos públicos y no públicos anidados, declarados por este tipo. (Invalida a Type.GetNestedType(String, BindingFlags)).
Método públicoGetNestedTypes()Devuelve los tipos públicos anidados en el objeto Type actual. (Se hereda de Type).
Método públicoGetNestedTypes(BindingFlags)Devuelve los tipos públicos y no públicos anidados, declarados o heredados por este tipo. (Invalida a Type.GetNestedTypes(BindingFlags)).
Método públicoGetProperties()Devuelve todas las propiedades públicas del objeto Type actual. (Se hereda de Type).
Método públicoGetProperties(BindingFlags)Devuelve todas las propiedades públicas y no públicas declaradas o heredadas por este tipo, tal como se especifica. (Invalida a Type.GetProperties(BindingFlags)).
Método públicoGetProperty(String)Busca la propiedad pública con el nombre especificado. (Se hereda de Type).
Método públicoGetProperty(String, BindingFlags)Busca la propiedad especificada, mediante las restricciones de enlace especificadas. (Se hereda de Type).
Método públicoGetProperty(String, Type)Busca la propiedad pública con el nombre especificado y el tipo de valor devuelto. (Se hereda de Type).
Método públicoGetProperty(String, Type[])Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados. (Se hereda de Type).
Método públicoGetProperty(String, Type, Type[])Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados. (Se hereda de Type).
Método públicoGetProperty(String, Type, Type[], ParameterModifier[])Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos y modificadores de los argumentos especificados. (Se hereda de Type).
Método públicoGetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])Busca la propiedad especificada cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. (Se hereda de Type).
Método públicoGetType()Obtiene el objeto Type actual. (Se hereda de Type).
Método públicoInvokeMember(String, BindingFlags, Binder, Object, Object[])Invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y compara la lista de argumentos indicada. (Se hereda de Type).
Método públicoInvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)Invoca al miembro especificado, aplica las restricciones de enlace especificadas y compara la lista de argumentos y la referencia cultural igualmente especificadas. (Se hereda de Type).
Método públicoInvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])Invoca al miembro especificado. El método al que se va a invocar debe estar accesible y proporcionar la coincidencia más específica con la lista de argumentos especificada, teniendo en cuenta las restricciones del enlazador predeterminado y los atributos de invocación indicados. (Invalida a Type.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])).
Método públicoIsAssignableFrom(Type)Obtiene un valor que indica si el objeto Type especificado puede asignarse a este objeto. (Invalida a Type.IsAssignableFrom(Type)).
Método públicoIsAssignableFrom(TypeInfo)Obtiene un valor que indica si el objeto TypeInfo especificado puede asignarse a este objeto. (Invalida a TypeInfo.IsAssignableFrom(TypeInfo)).
Método públicoIsCreatedDevuelve un valor que indica si se ha creado el tipo dinámico actual.
Método públicoIsDefinedDetermina si un atributo personalizado se aplica al tipo actual. (Invalida a MemberInfo.IsDefined(Type, Boolean)).
Método públicoIsEnumDefinedDevuelve un valor que indica si el valor especificado existe en el tipo de enumeración actual. (Se hereda de Type).
Método públicoIsEquivalentToDetermina si dos tipos COM tienen la misma identidad y se pueden usar para la equivalencia de tipos. (Se hereda de Type).
Método públicoIsInstanceOfTypeDetermina si el objeto especificado es una instancia del objeto Type actual. (Se hereda de Type).
Método públicoIsSubclassOfDetermina si este tipo se deriva de un tipo especificado. (Invalida a Type.IsSubclassOf(Type)).
Método públicoMakeArrayType()Devuelve un objeto Type que representa una matriz unidimensional del tipo actual, con un límite inferior de cero. (Invalida a Type.MakeArrayType()).
Método públicoMakeArrayType(Int32)Devuelve un objeto Type que representa una matriz del tipo actual, con el número de dimensiones especificado. (Invalida a Type.MakeArrayType(Int32)).
Método públicoMakeByRefTypeDevuelve un objeto Type que representa el tipo actual cuando se pasa como un parámetro ref (ByRef en Visual Basic). (Invalida a Type.MakeByRefType()).
Método públicoMakeGenericTypeSustituye los elementos de una matriz de tipos por los parámetros de la definición de tipo genérico actual y devuelve el tipo construido resultante. (Invalida a Type.MakeGenericType(Type[])).
Método públicoMakePointerTypeDevuelve un objeto Type que representa el tipo de un puntero no administrado al tipo actual. (Invalida a Type.MakePointerType()).
Método públicoSetCustomAttribute(CustomAttributeBuilder)Establece un atributo personalizado utilizando un generador de atributos personalizados.
Método públicoSetCustomAttribute(ConstructorInfo, Byte[])Establece un atributo personalizado mediante un objeto binario de atributo especificado y personalizado.
Método públicoSetParentEstablece el tipo base del tipo actualmente en construcción.
Método públicoToStringDevuelve el nombre del tipo sin incluir el espacio de nombres. (Invalida a Type.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úblicoGetRuntimeEventRecupera un objeto que representa el evento especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeEventsRecupera una colección que representa todos los eventos definidos en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeFieldRecupera un objeto que representa un campo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeFieldsRecupera una colección que representa todos los campos definidos en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeInterfaceMapDevuelve una asignación de interfaz para el tipo de interfaz y la interfaz especificada. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeMethodRecupera un objeto que representa un método especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeMethodsRecupera una colección que representa todos los métodos definidos en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimePropertiesRecupera una colección que representa todas las propiedades definidas en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimePropertyRecupera un objeto que representa una propiedad especificada. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetTypeInfoDevuelve la representación de TypeInfo del tipo especificado. (Definido por IntrospectionExtensions).
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
Campo públicoMiembro estáticoUnspecifiedTypeSizeIndica que el tamaño total del tipo no está especificado.
Arriba

  NombreDescripción
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_Type.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de Type).
Implementación explícita de interfacesMétodo privado_Type.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 Type).
Implementación explícita de interfacesMétodo privado_Type.GetTypeInfoCount

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

(Se hereda de Type).
Implementación explícita de interfacesMétodo privado_Type.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de Type).
Implementación explícita de interfacesMétodo privado_TypeBuilder.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.
Implementación explícita de interfacesMétodo privado_TypeBuilder.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_TypeBuilder.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_TypeBuilder.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto.
Implementación explícita de interfacesMétodo privadoIReflectableType.GetTypeInfoDevuelve una representación del tipo actual en forma de objeto TypeInfo. (Se hereda de TypeInfo).
Arriba

TypeBuilder es la clase raíz que se usa para controlar la creación de clases dinámicas en tiempo de ejecución. TypeBuilder proporciona un conjunto de rutinas que se usan para definir clases, agregar métodos y campos, y crear la clase durante el tiempo de ejecución. Se puede crear un nuevo TypeBuilder a partir de un módulo dinámico.

Para crear un tipo de matriz, tipo de puntero o tipo ByRef para un tipo incompleto representado por un objeto TypeBuilder, use el método MakeArrayType, MakePointerType o MakeByRefType, respectivamente.

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.

Esta sección contiene dos ejemplos de código. En el primer ejemplo se muestra cómo crear un tipo dinámico con un campo, constructor, propiedad y método. En el segundo ejemplo se compila dinámicamente un método a partir de los datos proporcionados por el usuario.

Ejemplo uno

En el ejemplo de código siguiente se muestra cómo definir un ensamblado dinámico con un módulo. El módulo en el ensamblado del ejemplo contiene un tipo, MyDynamicType, que tiene un campo privado, una propiedad que obtiene y establece el campo privado, constructores que inicializan el campo privado, y un método que multiplica un número proporcionado por usuario por el valor de campo privado y devuelve el resultado.

Se especifica el campo AssemblyBuilderAccess.RunAndSave cuando se crea el ensamblado. Se utiliza el código del ensamblado inmediatamente y el ensamblado también se guarda en el disco para que se pueda examinar con Ildasm.exe (Desensamblador de IL) o utilizar en otro programa.


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
 */


Ejemplo dos

En el siguiente código de ejemplo se muestra cómo crear un tipo dinámico mediante 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

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