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

Clase AssemblyBuilder

 

Publicado: octubre de 2016

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).(Invalida 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.(Invalida 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.(Invalida 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.(Invalida Assembly.FullName).

System_CAPS_pubpropertyGlobalAssemblyCache

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

System_CAPS_pubpropertyHostContext

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

System_CAPS_pubpropertyImageRuntimeVersion

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

System_CAPS_pubpropertyIsDynamic

Obtiene un valor que indica que el ensamblado actual es un ensamblado dinámico.(Invalida 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.(Invalida Assembly.Location).

System_CAPS_pubpropertyManifestModule

Obtiene el módulo del AssemblyBuilder actual que contiene el manifiesto del ensamblado.(Invalida 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.(Invalida Assembly.PermissionSet).

System_CAPS_pubpropertyReflectionOnly

Obtiene un valor que indica si el ensamblado dinámico está en el contexto de solo reflexión.(Invalida 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.(Invalida 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.(Invalida Assembly.Equals(Object)).

System_CAPS_pubmethodGetCustomAttributes(Boolean)

Devuelve todos los atributos personalizados que se aplicaron al AssemblyBuilder actual.(Invalida 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.(Invalida Assembly.GetCustomAttributes(Type, Boolean)).

System_CAPS_pubmethodGetCustomAttributesData()

Devuelve objetos CustomAttributeData que contienen información sobre los atributos que se aplicaron al AssemblyBuilder actual.(Invalida 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.(Invalida Assembly.GetExportedTypes()).

System_CAPS_pubmethodGetFile(String)

Obtiene un objeto FileStream para el archivo especificado en la tabla de archivos del manifiesto de este ensamblado.(Invalida 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.(Invalida Assembly.GetFiles(Boolean)).

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Invalida 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.(Invalida Assembly.GetLoadedModules(Boolean)).

System_CAPS_pubmethodGetManifestResourceInfo(String)

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

System_CAPS_pubmethodGetManifestResourceNames()

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

System_CAPS_pubmethodGetManifestResourceStream(String)

Carga el recurso del manifiesto especificado a partir de este ensamblado.(Invalida 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.(Invalida Assembly.GetManifestResourceStream(Type, String)).

System_CAPS_pubmethodGetModule(String)

Obtiene el módulo especificado en este ensamblado.(Invalida 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.(Invalida 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.(Invalida 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.(Invalida Assembly.GetReferencedAssemblies()).

System_CAPS_pubmethodGetSatelliteAssembly(CultureInfo)

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

System_CAPS_pubmethodGetSatelliteAssembly(CultureInfo, Version)

Obtiene la versión especificada del ensamblado satélite para la referencia cultural especificada.(Invalida 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.(Invalida 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.(Invalida 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.(Definido por CustomAttributeExtensions).

System_CAPS_pubmethodGetCustomAttribute<T>()

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

System_CAPS_pubmethodGetCustomAttributes()

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

System_CAPS_pubmethodGetCustomAttributes(Type)

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

System_CAPS_pubmethodIsDefined(Type)

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

A dynamic assembly is an assembly that is created using the Reflection Emit APIs. The dynamic modules in the assembly are saved when the dynamic assembly is saved using the M:System.Reflection.Emit.AssemblyBuilder.Save(System.String) method. To generate an executable, the M:System.Reflection.Emit.AssemblyBuilder.SetEntryPoint(System.Reflection.MethodInfo) method must be called to identify the method that is the entry point to the assembly. Assemblies are saved as DLLs by default, unless the M:System.Reflection.Emit.AssemblyBuilder.SetEntryPoint(System.Reflection.MethodInfo) method requests the generation of a console application or a Windows-based application.

If a dynamic assembly contains more than one dynamic module, the assembly's manifest file name should match the module's name that is specified as the first argument to the M:System.Reflection.Emit.AssemblyBuilder.DefineDynamicModule(System.String) method.

Some methods on the base T:System.Reflection.Assembly class, such as GetModules and GetLoadedModules, will not work correctly when called from T:System.Reflection.Emit.AssemblyBuilder objects. You can load the defined dynamic assembly and call the methods on the loaded assembly. For example, to ensure that resource modules are included in the returned module list, call GetModules on the loaded T:System.Reflection.Assembly object.

The signing of a dynamic assembly using P:System.Reflection.AssemblyName.KeyPair is not effective until the assembly is saved to disk. So, strong names will not work with transient dynamic assemblies.

To get an T:System.Reflection.Emit.AssemblyBuilder object, use the Overload:System.AppDomain.DefineDynamicAssembly method.

The following are some things to consider when using the T:System.Reflection.Emit.AssemblyBuilder class to create dynamic assemblies.

Reflection emit supports the creation of dynamic modules defined in dynamic assemblies. A dynamic module created in a dynamic assembly can be transient or persistable.

Assemblies can reference types defined in another assembly. A transient dynamic assembly can safely reference types defined in another transient dynamic assembly, a persistable dynamic assembly, or a static assembly. However, the common language runtime does not allow a persistable dynamic module to reference a type defined in a transient dynamic module. This is because when the persisted dynamic module is loaded after being saved to disk, the runtime cannot resolve the references to types defined in the transient dynamic module.

Some scenarios require a dynamic assembly to be created and executed in a remote application domain. Reflection emit does not allow a dynamic assembly to be emitted directly to a remote application domain. The solution is to emit the dynamic assembly in the current application domain, save the emitted dynamic assembly to disk, and then load the dynamic assembly into the remote application domain.

Dynamic assemblies can be created using one of the following access modes:

  • AssemblyBuilderAccess.Run

    The dynamic assembly represented by an T:System.Reflection.Emit.AssemblyBuilder object is transient. The dynamic assembly can only be used to execute the emitted code.

  • AssemblyBuilderAccess.Save

    The dynamic assembly represented by an T:System.Reflection.Emit.AssemblyBuilder object is persistable but cannot be executed until the saved portable executable (PE) file has been loaded from disk.

  • AssemblyBuilderAccess.RunAndSave

    The dynamic assembly represented by an T:System.Reflection.Emit.AssemblyBuilder object is persistable, but can also be executed before and/or after the assembly is saved to disk.

The access mode must be specified by providing the appropriate T:System.Reflection.Emit.AssemblyBuilderAccess value in the call to the M:System.Reflection.Emit.AssemblyBuilder.DefineDynamicAssembly(System.Reflection.AssemblyName,System.Reflection.Emit.AssemblyBuilderAccess,System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder}) method when the dynamic assembly is defined and cannot be changed later. The runtime uses the access mode of a dynamic assembly to optimize the assembly's internal representation.

The following code example shows how to define a dynamic assembly with one module. The module in the example assembly contains one type, MyDynamicType, which 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.

AssemblyBuilderAccess.RunAndSave is specified when the assembly is created. The assembly code is used immediately, and the assembly is also saved to disk so that it can be examined with Ildasm.exe (IL Disassembler) or used in another program.

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

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: