AssemblyBuilder Clase
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

AssemblyBuilder (Clase)

 

Define y representa un ensamblado dinámico.

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

System.Object
  System.Reflection.Assembly
    System.Reflection.Emit.AssemblyBuilder

[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, MayLeakOnAbort = true)]
public sealed class AssemblyBuilder : Assembly, _AssemblyBuilder

NombreDescripción
System_CAPS_pubpropertyCodeBase

Obtiene la ubicación del ensamblado tal y como se especificó originalmente (como en un objeto AssemblyName).(Reemplaza a Assembly.CodeBase).

System_CAPS_pubpropertyCustomAttributes

Obtiene una colección que contiene los atributos personalizados de este ensamblado.(Heredado de Assembly.)

System_CAPS_pubpropertyDefinedTypes

Obtiene una colección de los tipos definidos en este ensamblado.(Heredado de Assembly.)

System_CAPS_pubpropertyEntryPoint

Devuelve el punto de entrada de este ensamblado.(Reemplaza a Assembly.EntryPoint).

System_CAPS_pubpropertyEscapedCodeBase

Obtiene el identificador URI, incluidos los caracteres de escape, que representa el código base.(Heredado de Assembly.)

System_CAPS_pubpropertyEvidence

Obtiene la evidencia para este ensamblado.(Reemplaza a Assembly.Evidence).

System_CAPS_pubpropertyExportedTypes

Obtiene una colección de los tipos públicos definidos en este ensamblado que se pueden ver desde fuera del ensamblado.(Heredado de Assembly.)

System_CAPS_pubpropertyFullName

Obtiene el nombre para mostrar del ensamblado dinámico actual.(Reemplaza a Assembly.FullName).

System_CAPS_pubpropertyGlobalAssemblyCache

Obtiene un valor que indica si el ensamblado se ha cargado desde la caché global de ensamblados.(Reemplaza a Assembly.GlobalAssemblyCache).

System_CAPS_pubpropertyHostContext

Obtiene el contexto del host donde se está creando el ensamblado dinámico.(Reemplaza a Assembly.HostContext).

System_CAPS_pubpropertyImageRuntimeVersion

Obtiene l versión de Common Language Runtime (CLR) que se guardará en el archivo que contiene el manifiesto.(Reemplaza a Assembly.ImageRuntimeVersion).

System_CAPS_pubpropertyIsDynamic

Obtiene un valor que indica que el ensamblado actual es un ensamblado dinámico.(Reemplaza a Assembly.IsDynamic).

System_CAPS_pubpropertyIsFullyTrusted

Obtiene un valor que indica si el ensamblado actual se carga con plena confianza.(Heredado de Assembly.)

System_CAPS_pubpropertyLocation

Obtiene la ubicación, en formato de código base, del archivo cargado que contiene el manifiesto si no se han creado instantáneas.(Reemplaza a Assembly.Location).

System_CAPS_pubpropertyManifestModule

Obtiene el módulo del AssemblyBuilder actual que contiene el manifiesto del ensamblado.(Reemplaza a Assembly.ManifestModule).

System_CAPS_pubpropertyModules

Obtiene una colección que contiene los módulos de este ensamblado.(Heredado de Assembly.)

System_CAPS_pubpropertyPermissionSet

Obtiene el conjunto de permisos del ensamblado dinámico actual.(Reemplaza a Assembly.PermissionSet).

System_CAPS_pubpropertyReflectionOnly

Obtiene un valor que indica si el ensamblado dinámico está en el contexto de solo reflexión.(Reemplaza a Assembly.ReflectionOnly).

System_CAPS_pubpropertySecurityRuleSet

Obtiene un valor que indica el conjunto de reglas de seguridad que Common Language Runtime (CLR) aplica para este ensamblado.(Reemplaza a Assembly.SecurityRuleSet).

NombreDescripción
System_CAPS_pubmethodAddResourceFile(String, String)

Agrega un archivo de recursos existente a este ensamblado.

System_CAPS_pubmethodAddResourceFile(String, String, ResourceAttributes)

Agrega un archivo de recursos existente a este ensamblado.

System_CAPS_pubmethodCreateInstance(String)

Localiza el tipo especificado en este ensamblado y crea una instancia del tipo mediante el activador del sistema, realizando una búsqueda en la que se distingue entre mayúsculas y minúsculas.(Heredado de Assembly.)

System_CAPS_pubmethodCreateInstance(String, Boolean)

Ubica el tipo especificado de este ensamblado y crea una instancia de dicho tipo mediante el activador del sistema, con búsqueda de mayúsculas y minúsculas opcional.(Heredado de Assembly.)

System_CAPS_pubmethodCreateInstance(String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])

Ubica el tipo especificado en este ensamblado y crea una instancia de dicho tipo mediante el activador del sistema, con búsqueda de mayúsculas y minúsculas opcional y con los atributos de referencia cultural, argumentos, enlace y activación.(Heredado de Assembly.)

System_CAPS_pubmethodSystem_CAPS_staticDefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)

Define un ensamblado dinámico con el nombre y los derechos de acceso especificados.

System_CAPS_pubmethodSystem_CAPS_staticDefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)

Define un nuevo ensamblado con el nombre, los derechos de acceso y los atributos especificados.

System_CAPS_pubmethodDefineDynamicModule(String)

Define un módulo dinámico transitorio con nombre en este ensamblado.

System_CAPS_pubmethodDefineDynamicModule(String, Boolean)

Define un módulo dinámico transitorio con nombre en este ensamblado y especifica si se debe emitir información de símbolos.

System_CAPS_pubmethodDefineDynamicModule(String, String)

Define un módulo dinámico con persistencia con el nombre especificado que se guardará en el archivo especificado. No se emitirá información de símbolos.

System_CAPS_pubmethodDefineDynamicModule(String, String, Boolean)

Define un módulo dinámico con persistencia, especificando el nombre del módulo, el nombre del archivo en el que se guardará el módulo y si se debe emitir información de símbolos mediante el escritor de símbolos predeterminado.

System_CAPS_pubmethodDefineResource(String, String, String)

Define un recurso administrado independiente para este ensamblado con el atributo de recurso público predeterminado.

System_CAPS_pubmethodDefineResource(String, String, String, ResourceAttributes)

Define un recurso administrado independiente para este ensamblado. Los atributos se pueden especificar para el recurso administrado.

System_CAPS_pubmethodDefineUnmanagedResource(Byte[])

Define un recurso no administrado para este ensamblado como blob opaco de bytes.

System_CAPS_pubmethodDefineUnmanagedResource(String)

Define un archivo de recurso no administrado para este ensamblado con el nombre del archivo de recursos.

System_CAPS_pubmethodDefineVersionInfoResource()

Define un recurso de información de versión sin administrar mediante la información especificada en el objeto AssemblyName del ensamblado y los atributos personalizados del ensamblado.

System_CAPS_pubmethodDefineVersionInfoResource(String, String, String, String, String)

Define un recurso de información de versión no administrado para este ensamblado con las especificaciones dadas.

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si esta instancia es igual que el objeto especificado.(Reemplaza a Assembly.Equals(Object)).

System_CAPS_pubmethodGetCustomAttributes(Boolean)

Devuelve todos los atributos personalizados que se aplicaron al AssemblyBuilder actual.(Reemplaza a Assembly.GetCustomAttributes(Boolean)).

System_CAPS_pubmethodGetCustomAttributes(Type, Boolean)

Devuelve todos los atributos personalizados que se aplicaron al AssemblyBuilder actual y que derivan de un tipo de atributo especificado.(Reemplaza a Assembly.GetCustomAttributes(Type, Boolean)).

System_CAPS_pubmethodGetCustomAttributesData()

Devuelve objetos CustomAttributeData que contienen información sobre los atributos que se aplicaron al AssemblyBuilder actual.(Reemplaza a Assembly.GetCustomAttributesData()).

System_CAPS_pubmethodGetDynamicModule(String)

Devuelve el módulo dinámico con el nombre especificado.

System_CAPS_pubmethodGetExportedTypes()

Obtiene los tipos definidos en este ensamblado.(Reemplaza a Assembly.GetExportedTypes()).

System_CAPS_pubmethodGetFile(String)

Obtiene un objeto FileStream para el archivo especificado en la tabla de archivos del manifiesto de este ensamblado.(Reemplaza a Assembly.GetFile(String)).

System_CAPS_pubmethodGetFiles()

Obtiene los archivos en la tabla de archivos del manifiesto del ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodGetFiles(Boolean)

Obtiene los archivos en la tabla de archivos del manifiesto del ensamblado, especificando si deben incluirse módulos de recursos.(Reemplaza a Assembly.GetFiles(Boolean)).

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Reemplaza a Assembly.GetHashCode()).

System_CAPS_pubmethodGetLoadedModules()

Obtiene todos los módulos cargados que forman parte de este ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodGetLoadedModules(Boolean)

Devuelve todos los módulos cargados que forman parte de este ensamblado e incluye opcionalmente módulos de recursos.(Reemplaza a Assembly.GetLoadedModules(Boolean)).

System_CAPS_pubmethodGetManifestResourceInfo(String)

Devuelve información sobre cómo el recurso dado ha persistido.(Reemplaza a Assembly.GetManifestResourceInfo(String)).

System_CAPS_pubmethodGetManifestResourceNames()

Carga el recurso del manifiesto especificado a partir de este ensamblado.(Reemplaza a Assembly.GetManifestResourceNames()).

System_CAPS_pubmethodGetManifestResourceStream(String)

Carga el recurso del manifiesto especificado a partir de este ensamblado.(Reemplaza a Assembly.GetManifestResourceStream(String)).

System_CAPS_pubmethodGetManifestResourceStream(Type, String)

Carga el recurso del manifiesto especificado según el espacio de nombres del tipo especificado a partir de este ensamblado.(Reemplaza a Assembly.GetManifestResourceStream(Type, String)).

System_CAPS_pubmethodGetModule(String)

Obtiene el módulo especificado en este ensamblado.(Reemplaza a Assembly.GetModule(String)).

System_CAPS_pubmethodGetModules()

Obtiene todos los módulos que forman parte de este ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodGetModules(Boolean)

Obtiene todos los módulos que forman parte de este ensamblado e incluye opcionalmente módulos de recursos.(Reemplaza a Assembly.GetModules(Boolean)).

System_CAPS_pubmethodGetName()

Obtiene un objeto AssemblyName para este ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodGetName(Boolean)

Obtiene el AssemblyName que se especificó cuando se creó el ensamblado dinámico actual y establece el código base según lo especificado.(Reemplaza a Assembly.GetName(Boolean)).

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Obtiene información de serialización con todos los datos necesarios para crear una nueva instancia de este ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodGetReferencedAssemblies()

Obtiene una lista incompleta de objetos AssemblyName para los ensamblados a los que hace referencia este AssemblyBuilder.(Reemplaza a Assembly.GetReferencedAssemblies()).

System_CAPS_pubmethodGetSatelliteAssembly(CultureInfo)

Obtiene el ensamblado satélite para la referencia cultural especificada.(Reemplaza a Assembly.GetSatelliteAssembly(CultureInfo)).

System_CAPS_pubmethodGetSatelliteAssembly(CultureInfo, Version)

Obtiene la versión especificada del ensamblado satélite para la referencia cultural especificada.(Reemplaza a Assembly.GetSatelliteAssembly(CultureInfo, Version)).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object.)

System_CAPS_pubmethodGetType(String)

Obtiene el objeto Type con el nombre especificado en la instancia de ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodGetType(String, Boolean)

Obtiene el objeto Type con el nombre especificado en la instancia de ensamblado y, de manera opcional, produce una excepción si no se encuentra el tipo.(Heredado de Assembly.)

System_CAPS_pubmethodGetType(String, Boolean, Boolean)

Obtiene el tipo especificado a partir de los tipos que se definieron y se crearon en el AssemblyBuilder actual.(Reemplaza a Assembly.GetType(String, Boolean, Boolean)).

System_CAPS_pubmethodGetTypes()

Obtiene los tipos definidos en este ensamblado.(Heredado de Assembly.)

System_CAPS_pubmethodIsDefined(Type, Boolean)

Devuelve un valor que indica si se aplica a este miembro una o más instancias del tipo de atributo especificado.(Reemplaza a Assembly.IsDefined(Type, Boolean)).

System_CAPS_pubmethodLoadModule(String, Byte[])

Carga el módulo, que es interno para este ensamblado, con una imagen que toma como base el formato Common Object File Format (COFF) y que contiene un módulo emitido o un archivo de recursos.(Heredado de Assembly.)

System_CAPS_pubmethodLoadModule(String, Byte[], Byte[])

Carga el módulo, que es interno para este ensamblado, con una imagen que toma como base el formato Common Object File Format (COFF) y que contiene un módulo emitido o un archivo de recursos. También se cargan los bytes sin formato que representan a los símbolos del módulo.(Heredado de Assembly.)

System_CAPS_pubmethodSave(String)

Guarda este ensamblado dinámico en el disco.

System_CAPS_pubmethodSave(String, PortableExecutableKinds, ImageFileMachine)

Guarda este ensamblado dinámico en el disco, especificando la naturaleza del código en los ejecutables del ensamblado y en la plataforma de destino.

System_CAPS_pubmethodSetCustomAttribute(ConstructorInfo, Byte[])

Establezca un atributo personalizado en este ensamblado mediante un blob de atributo personalizado especificado.

System_CAPS_pubmethodSetCustomAttribute(CustomAttributeBuilder)

Establezca un atributo personalizado en este ensamblado mediante un generador de atributos personalizado.

System_CAPS_pubmethodSetEntryPoint(MethodInfo)

Establece el punto de entrada para este ensamblado dinámico, suponiendo que se está generando una aplicación de consola.

System_CAPS_pubmethodSetEntryPoint(MethodInfo, PEFileKinds)

Establece el punto de entrada para este ensamblado y define el tipo de archivo ejecutable portable (archivo PE) que se está desarrollando.

System_CAPS_pubmethodToString()

Devuelve el nombre completo del ensamblado, también conocido como nombre para mostrar.(Heredado de Assembly.)

NombreDescripción
System_CAPS_pubeventModuleResolve

Se produce cuando el cargador de clases Common Language Runtime no puede resolver una referencia a un módulo interno de un ensamblado por medios normales.(Heredado de Assembly.)

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethod_Assembly.GetType()

Devuelve el tipo de la instancia actual.(Heredado de Assembly.)

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

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.

System_CAPS_pubinterfaceSystem_CAPS_privmethod_AssemblyBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera la información de tipo de un objeto, que se puede usar después para obtener la información de tipo de una interfaz.

System_CAPS_pubinterfaceSystem_CAPS_privmethod_AssemblyBuilder.GetTypeInfoCount(UInt32)

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

System_CAPS_pubinterfaceSystem_CAPS_privmethod_AssemblyBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.

NombreDescripción
System_CAPS_pubmethodGetCustomAttribute(Type)

Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un ensamblado especificado.(Defined by CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttribute<T>()

Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un ensamblado especificado.(Defined by CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttributes()

Sobrecargado. Recupera una colección de atributos personalizados que se aplican a un ensamblado especificado.(Defined by CustomAttributeExtensions.)

System_CAPS_pubmethodGetCustomAttributes(Type)

Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un ensamblado especificado.(Defined by CustomAttributeExtensions.)

System_CAPS_pubmethodIsDefined(Type)

Sobrecargado. Indica si se aplican atributos personalizados de un tipo especificado a un ensamblado especificado.(Defined by CustomAttributeExtensions.)

Un ensamblado dinámico es un ensamblado que se crea utilizando las API de emisión de reflexión. Los módulos dinámicos del ensamblado se guardan cuando se guarda el ensamblado dinámico usando el Save método. Para generar un archivo ejecutable, el SetEntryPoint método debe llamarse para identificar el método que es el punto de entrada para el ensamblado. Los ensamblados se guardan como archivos DLL de forma predeterminada, a menos que el SetEntryPoint método solicita la generación de una aplicación de consola o una aplicación basada en Windows.

Si un ensamblado dinámico contiene más de un módulo dinámico, el nombre del archivo de manifiesto del ensamblado debe coincidir con el nombre del módulo que se especifica como el primer argumento para el DefineDynamicModule (método).

Algunos métodos en la base de Assembly de clase, como GetModules y GetLoadedModules, no funcionará correctamente cuando se llama desde AssemblyBuilder objetos. Puede cargar el ensamblado dinámico definido y llamar a los métodos en el ensamblado cargado. Por ejemplo, para asegurarse de que los módulos de recursos se incluyen en la lista de módulos devuelta, llame a GetModules en la carga Assembly objeto.

La firma de un ensamblado dinámico usando KeyPair no es eficaz hasta que el ensamblado se guarda en el disco. Por lo tanto, los nombres seguros no funcionará con los ensamblados dinámicos transitorios.

Para obtener un AssemblyBuilder objeto, utilice el AppDomain.DefineDynamicAssembly método.

Los siguientes son algunos aspectos a tener en cuenta al utilizar el AssemblyBuilder clase para crear ensamblados dinámicos.

Reflection emit admite la creación de módulos dinámicos definidos en ensamblados dinámicos. Un módulo dinámico creado en un ensamblado dinámico puede ser transitorio o con persistencia.

Ensamblados pueden hacer referencia a tipos definidos en otro ensamblado. Un ensamblado dinámico transitorio puede hacer referencia sin problemas a los tipos definidos en otro ensamblado dinámico transitorio, un ensamblado dinámico con persistencia o en un ensamblado estático. Sin embargo, common language runtime no permite un módulo dinámico con persistencia hacer referencia a un tipo definido en un módulo dinámico transitorio. Esto es porque cuando se carga el módulo dinámico con persistencia después de haberse guardado en el disco, el tiempo de ejecución no puede resolver las referencias a tipos definidos en el módulo dinámico transitorio.

Algunos escenarios requieren un ensamblado dinámico se creen y se ejecutan en un dominio de aplicación remota. La emisión de reflexión no admite un ensamblado dinámico que se emitan directamente a un dominio de aplicación remota. La solución es emitir el ensamblado dinámico en el dominio de aplicación actual, guardar el ensamblado dinámico emitido en el disco y, a continuación, cargar el ensamblado dinámico en el dominio de aplicación remota.

Ensamblados dinámicos se pueden crear utilizando uno de los siguientes modos de acceso:

  • AssemblyBuilderAccess.Run

    El ensamblado dinámico representado por un AssemblyBuilder objeto es transitorio. El ensamblado dinámico sólo puede utilizarse para ejecutar el código emitido.

  • AssemblyBuilderAccess.Save

    El ensamblado dinámico representado por un AssemblyBuilder objeto puede persistir, pero no se puede ejecutar hasta que se ha cargado el archivo del archivo ejecutable portable (PE) guardado desde el disco.

  • AssemblyBuilderAccess.RunAndSave

    El ensamblado dinámico representado por un AssemblyBuilder objeto puede persistir, pero también se pueden ejecutar antes o después de que el ensamblado se guarda en el disco.

El modo de acceso debe especificarse proporcionando adecuado AssemblyBuilderAccess valor en la llamada a la AssemblyBuilder.DefineDynamicAssembly método cuando el ensamblado dinámico está definido y no se puede cambiar más adelante. El runtime usa el modo de acceso de un ensamblado dinámico para optimizar la representación interna del ensamblado.

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 de ejemplo contiene un solo 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 el usuario por el campo privado de valor y devuelve el resultado.

AssemblyBuilderAccess.RunAndSave se especifica cuando se crea el ensamblado. El código de ensamblado se usa inmediatamente y el ensamblado también se guarda en el disco para que se pueden examinar con Ildasm.exe (IL Disassembler) o usarlo 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
 */

ReflectionPermission

when invoked late-bound through mechanisms such as M:System.Type.InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[]). Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess.

.NET Framework
Disponible desde 1.1
Silverlight
Disponible desde 2.0

Los miembros estáticos públicos (Shared en Visual Basic) 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.

Volver al principio
Mostrar:
© 2016 Microsoft