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

AssemblyBuilder (Clase)

Define y representa un ensamblado dinámico.

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

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

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

El tipo AssemblyBuilder expone los siguientes miembros.

  NombreDescripción
Propiedad públicaCodeBaseObtiene la ubicación del ensamblado tal y como se especificó originalmente (por ejemplo, en un objeto AssemblyName). (Invalida a Assembly.CodeBase).
Propiedad públicaCustomAttributesObtiene una colección que contiene los atributos personalizados de este ensamblado. (Se hereda de Assembly).
Propiedad públicaDefinedTypesObtiene una colección de los tipos definidos en este ensamblado. (Se hereda de Assembly).
Propiedad públicaEntryPointDevuelve el punto de entrada de este ensamblado. (Invalida a Assembly.EntryPoint).
Propiedad públicaEscapedCodeBaseObtiene el identificador URI, incluidos los caracteres de escape, que representa el código base. (Se hereda de Assembly).
Propiedad públicaEvidenceObtiene la evidencia para este ensamblado. (Invalida a Assembly.Evidence).
Propiedad públicaExportedTypesObtiene una colección de los tipos públicos definidos en este ensamblado que se pueden ver desde fuera del ensamblado. (Se hereda de Assembly).
Propiedad públicaFullNameObtiene el nombre para mostrar del ensamblado dinámico actual. (Invalida a Assembly.FullName).
Propiedad públicaGlobalAssemblyCacheObtiene un valor que indica si el ensamblado se ha cargado desde la memoria caché global de ensamblados. (Invalida a Assembly.GlobalAssemblyCache).
Propiedad públicaHostContextObtiene el contexto del host donde se va a crear el ensamblado dinámico. (Invalida a Assembly.HostContext).
Propiedad públicaImageRuntimeVersionObtiene la versión de Common Language Runtime que se guardará en el archivo que contiene el manifiesto. (Invalida a Assembly.ImageRuntimeVersion).
Propiedad públicaIsDynamicObtiene un valor que indica que el ensamblado actual es un ensamblado dinámico. (Invalida a Assembly.IsDynamic).
Propiedad públicaIsFullyTrustedObtiene un valor que indica si el ensamblado actual se carga con plena confianza. (Se hereda de Assembly).
Propiedad públicaLocationObtiene la ubicación, en formato de código base, del archivo cargado que contiene el manifiesto si no se ha realizado copia de seguridad. (Invalida a Assembly.Location).
Propiedad públicaManifestModuleObtiene el módulo de la clase AssemblyBuilder actual que contiene el manifiesto del ensamblado. (Invalida a Assembly.ManifestModule).
Propiedad públicaModulesObtiene una colección que contiene los módulos de este ensamblado. (Se hereda de Assembly).
Propiedad públicaPermissionSetObtiene el conjunto de permisos del ensamblado dinámico actual. (Invalida a Assembly.PermissionSet).
Propiedad públicaReflectionOnlyObtiene un valor que indica si el ensamblado dinámico está en el contexto de sólo reflexión. (Invalida a Assembly.ReflectionOnly).
Propiedad públicaSecurityRuleSetObtiene un valor que indica el conjunto de reglas de seguridad que Common Language Runtime (CLR) aplica para este ensamblado. (Invalida a Assembly.SecurityRuleSet).
Arriba

  NombreDescripción
Método públicoAddResourceFile(String, String)Agrega un archivo de recursos existente a este ensamblado.
Método públicoAddResourceFile(String, String, ResourceAttributes)Agrega un archivo de recursos existente a este ensamblado.
Método públicoCreateInstance(String)Ubica el tipo especificado en este ensamblado y crea una instancia del mismo mediante el activador del sistema, realizando una búsqueda en la que se distingue entre mayúsculas y minúsculas. (Se hereda de Assembly).
Método públicoCreateInstance(String, Boolean)Ubica el tipo especificado de este ensamblado y crea una instancia del mismo mediante el activador del sistema, con búsqueda de mayúsculas y minúsculas opcional. (Se hereda de Assembly).
Método públicoCreateInstance(String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])Ubica el tipo especificado en este ensamblado y crea una instancia del mismo 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. (Se hereda de Assembly).
Método públicoMiembro estáticoDefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess)Define un ensamblado dinámico que tiene los derechos de acceso y nombre especificados.
Método públicoMiembro estáticoDefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)Define un nuevo ensamblado que tiene el nombre, los derechos de acceso y los atributos especificados.
Método públicoDefineDynamicModule(String)Define un módulo dinámico transitorio con nombre en este ensamblado.
Método públicoDefineDynamicModule(String, Boolean)Define un módulo dinámico transitorio con nombre en este ensamblado y especifica si debe emitirse información de símbolos.
Método públicoDefineDynamicModule(String, String)Define un módulo dinámico con persistencia con el nombre especificado que se guardará en el archivo indicado. No se emite información de símbolos.
Método públicoDefineDynamicModule(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 va a guardar el módulo y si se debe emitir información de símbolos mediante el sistema de escritura de símbolos predeterminado.
Método públicoDefineResource(String, String, String)Define un recurso administrado independiente para este ensamblado con el atributo de recurso público predeterminado.
Método públicoDefineResource(String, String, String, ResourceAttributes)Define un recurso administrado independiente para este ensamblado. Se pueden especificar atributos para el recurso administrado.
Método públicoDefineUnmanagedResource(Byte[])Define un recurso no administrado para este ensamblado como un objeto binario opaco de bytes.
Método públicoDefineUnmanagedResource(String)Define un archivo de recursos no administrados para este ensamblado a partir del nombre del archivo de recursos.
Método públicoDefineVersionInfoResource()Define un recurso de información de versión no administrado con la información especificada en el objeto AssemblyName del ensamblado y los atributos personalizados del mismo.
Método públicoDefineVersionInfoResource(String, String, String, String, String)Define un recurso de información de versión no administrado para este ensamblado con las especificaciones dadas.
Método públicoEqualsDevuelve un valor que indica si esta instancia es igual que el objeto especificado. (Invalida a Assembly.Equals(Object)).
Método públicoGetCustomAttributes(Boolean)Devuelve todos los atributos personalizados que se han aplicado a la clase AssemblyBuilderactual. (Invalida a Assembly.GetCustomAttributes(Boolean)).
Método públicoGetCustomAttributes(Type, Boolean)Devuelve todos los atributos personalizados que se han aplicado a la clase AssemblyBuilder actual y que derivan de un tipo de atributo especificado. (Invalida a Assembly.GetCustomAttributes(Type, Boolean)).
Método públicoGetCustomAttributesDataDevuelve objetos CustomAttributeData que contienen información sobre los atributos que se han aplicado a la clase AssemblyBuilder actual. (Invalida a Assembly.GetCustomAttributesData()).
Método públicoGetDynamicModuleDevuelve el módulo dinámico con el nombre especificado.
Método públicoGetExportedTypesObtiene los tipos exportados definidos en este ensamblado. (Invalida a Assembly.GetExportedTypes()).
Método públicoGetFileObtiene un FileStream para el archivo especificado en la tabla de archivos del manifiesto de este ensamblado. (Invalida a Assembly.GetFile(String)).
Método públicoGetFiles()Obtiene los archivos en la tabla de archivos del manifiesto del ensamblado. (Se hereda de Assembly).
Método públicoGetFiles(Boolean)Obtiene los archivos en la tabla de archivos del manifiesto del ensamblado, especificando si deben incluirse módulos de recursos. (Invalida a Assembly.GetFiles(Boolean)).
Método públicoGetHashCodeDevuelve el código hash de esta instancia. (Invalida a Assembly.GetHashCode()).
Método públicoGetLoadedModules()Obtiene todos los módulos cargados que forman parte de este ensamblado. (Se hereda de Assembly).
Método públicoGetLoadedModules(Boolean)Devuelve todos los módulos cargados que forman parte de este ensamblado y, opcionalmente, incluye módulos de recursos. (Invalida a Assembly.GetLoadedModules(Boolean)).
Método públicoGetManifestResourceInfoDevuelve información sobre cómo el recurso dado ha persistido. (Invalida a Assembly.GetManifestResourceInfo(String)).
Método públicoGetManifestResourceNamesCarga el recurso del manifiesto especificado a partir de este ensamblado. (Invalida a Assembly.GetManifestResourceNames()).
Método públicoGetManifestResourceStream(String)Carga el recurso del manifiesto especificado a partir de este ensamblado. (Invalida a Assembly.GetManifestResourceStream(String)).
Método públicoGetManifestResourceStream(Type, String)Carga el recurso del manifiesto especificado según el espacio de nombres del tipo especificado a partir de este ensamblado. (Invalida a Assembly.GetManifestResourceStream(Type, String)).
Método públicoGetModuleObtiene el módulo especificado en este ensamblado. (Invalida a Assembly.GetModule(String)).
Método públicoGetModules()Obtiene todos los módulos que forman parte de este ensamblado. (Se hereda de Assembly).
Método públicoGetModules(Boolean)Obtiene todos los módulos que forman parte de este ensamblado y, opcionalmente, incluye módulos de recursos. (Invalida a Assembly.GetModules(Boolean)).
Método públicoGetName()Obtiene un objeto AssemblyName para este ensamblado. (Se hereda de Assembly).
Método públicoGetName(Boolean)Obtiene el objeto AssemblyName que se especificó cuando se creó el ensamblado dinámico actual, y establece el código base tal y como se especifica. (Invalida a Assembly.GetName(Boolean)).
Método públicoGetObjectDataObtiene información de serialización con todos los datos necesarios para crear una nueva instancia de este ensamblado. (Se hereda de Assembly).
Método públicoGetReferencedAssembliesObtiene una lista incompleta de objetos AssemblyName para los ensamblados a los que hace referencia esta clase AssemblyBuilder. (Invalida a Assembly.GetReferencedAssemblies()).
Método públicoGetSatelliteAssembly(CultureInfo)Obtiene el ensamblado satélite para la referencia cultural especificada. (Invalida a Assembly.GetSatelliteAssembly(CultureInfo)).
Método públicoGetSatelliteAssembly(CultureInfo, Version)Obtiene la versión especificada del ensamblado satélite para la referencia cultural especificada. (Invalida a Assembly.GetSatelliteAssembly(CultureInfo, Version)).
Método públicoGetType() Obtiene el Typede la instancia actual. (Se hereda de Object).
Método públicoGetType(String)Obtiene el objeto Type con el nombre especificado en la instancia del ensamblado. (Se hereda de Assembly).
Método públicoGetType(String, Boolean)Obtiene el objeto Type con el nombre especificado en la instancia del ensamblado y, opcionalmente, produce una excepción si no se encuentra el tipo. (Se hereda de Assembly).
Método públicoGetType(String, Boolean, Boolean)Obtiene el tipo especificado de los tipos que se han definido y creado en la clase AssemblyBuilderactual. (Invalida a Assembly.GetType(String, Boolean, Boolean)).
Método públicoGetTypesObtiene los tipos definidos en este ensamblado. (Se hereda de Assembly).
Método públicoIsDefinedDevuelve un valor que indica si se aplican una o más instancias del tipo de atributo especificado a este miembro. (Invalida a Assembly.IsDefined(Type, Boolean)).
Método públicoLoadModule(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. (Se hereda de Assembly).
Método públicoLoadModule(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. (Se hereda de Assembly).
Método públicoSave(String)Guarda en disco este ensamblado dinámico.
Método públicoSave(String, PortableExecutableKinds, ImageFileMachine)Guarda este ensamblado dinámico en disco, especificando la naturaleza del código en los ejecutables del ensamblado y la plataforma de destino.
Método públicoSetCustomAttribute(CustomAttributeBuilder)Establezca un atributo personalizado en este ensamblado mediante un generador de atributos personalizados.
Método públicoSetCustomAttribute(ConstructorInfo, Byte[])Establezca un atributo personalizado en este ensamblado mediante el objeto binario especificado de atributo personalizado.
Método públicoSetEntryPoint(MethodInfo)Establece el punto de entrada de este ensamblado dinámico, suponiendo que se está generando una aplicación de consola.
Método públicoSetEntryPoint(MethodInfo, PEFileKinds)Establece el punto de entrada para este ensamblado y define el tipo de archivo ejecutable portable (PE) que se está generando.
Método públicoToStringDevuelve el nombre completo del ensamblado, también conocido como nombre para mostrar. (Se hereda de Assembly).
Arriba

  NombreDescripción
Evento públicoModuleResolveSe 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. (Se hereda de Assembly).
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 ensamblado concreto. (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 ensamblado concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes()Sobrecargado. Recupera una colección de atributos personalizados que se aplican a un ensamblado 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 ensamblado 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 ensamblado concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoIsDefinedIndica si se deben aplicar atributos personalizados de un tipo especificado a un ensamblado especificado. (Definido por CustomAttributeExtensions).
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privado_Assembly.GetTypeDevuelve el tipo de la instancia actual. (Se hereda de Assembly).
Implementación explícita de interfacesMétodo privado_AssemblyBuilder.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.
Implementación explícita de interfacesMétodo privado_AssemblyBuilder.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_AssemblyBuilder.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_AssemblyBuilder.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto.
Arriba

Un ensamblado dinámico es aquél que se crea utilizando las API de Reflection Emit. Los módulos dinámicos del ensamblado se guardan cuando se guarda el ensamblado dinámico mediante el método Save. Para generar un ejecutable, debe llamarse al método SetEntryPoint para identificar el método que es el punto de entrada al ensamblado. De manera predeterminada, los ensamblados se guardan como DLL, a menos que SetEntryPoint solicite la generación de una aplicación de consola o una aplicación para Windows.

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

Algunos métodos de la clase base Assembly, como GetModules y GetLoadedModules, no funcionarán correctamente si se denominan objetos AssemblyBuilder. Se puede cargar el ensamblado dinámico definido y llamar a los métodos en el ensamblado cargado. Por ejemplo, para garantizar que los módulos de recursos se incluyen en la lista de módulos devuelta, llame a GetModules en el objeto Assembly cargado.

La firma de un ensamblado dinámico mediante KeyPair no tiene efecto hasta que el ensamblado se guarda en disco. Por tanto, los nombres seguros no funcionan con ensamblados dinámicos transitorios.

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

NotaNota

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

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

AssemblyBuilderAccess.RunAndSave se especifica 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
 */


.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