Assembly Clase

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Source:

Assembly.cs

Representa un ensamblado, que es un bloque de creación reutilizable, versionable y autodescriptible de una aplicación de Common Language Runtime.

public ref class Assembly abstract : System::Reflection::ICustomAttributeProvider, System::Runtime::Serialization::ISerializable

public abstract class Assembly : System.Reflection.ICustomAttributeProvider, System.Runtime.Serialization.ISerializable

type Assembly = class
    interface ICustomAttributeProvider
    interface ISerializable

Public MustInherit Class Assembly
Implements ICustomAttributeProvider, ISerializable

Herencia

Object

Assembly

Derivado

System.Reflection.Emit.AssemblyBuilder

Implementaciones

ICustomAttributeProvider ISerializable

Ejemplos

En el ejemplo de código siguiente se muestra cómo obtener el ensamblado que se está ejecutando actualmente, crear una instancia de un tipo contenido en ese ensamblado e invocar uno de los métodos del tipo con enlace en tiempo de ejecución. Para ello, el ejemplo de código define una clase denominada Example, con un método denominado SampleMethod. El constructor de la clase acepta un entero, que se usa para calcular el valor devuelto del método .

El ejemplo de código también muestra el uso del método GetName para obtener un objeto AssemblyName que se puede usar para analizar el nombre completo del ensamblado. En el ejemplo se muestra el número de versión del ensamblado, la propiedad CodeBase y la propiedad EntryPoint.

using namespace System;
using namespace System::Reflection;
using namespace System::Security::Permissions;

[assembly:AssemblyVersionAttribute("1.0.2000.0")];

public ref class Example
{
private: 
    int factor;

public:
    Example(int f)
    {
        factor = f;
    }

    int SampleMethod(int x) 
    { 
        Console::WriteLine("\nExample->SampleMethod({0}) executes.", x);
        return x * factor;
    }
};

void main()
{
    Assembly^ assem = Example::typeid->Assembly;

    Console::WriteLine("Assembly Full Name:");
    Console::WriteLine(assem->FullName);

    // The AssemblyName type can be used to parse the full name.
    AssemblyName^ assemName = assem->GetName();
    Console::WriteLine("\nName: {0}", assemName->Name);
    Console::WriteLine("Version: {0}.{1}", 
        assemName->Version->Major, assemName->Version->Minor);

    Console::WriteLine("\nAssembly CodeBase:");
    Console::WriteLine(assem->CodeBase);

    // Create an object from the assembly, passing in the correct number and
    // type of arguments for the constructor.
    Object^ o = assem->CreateInstance("Example", false, 
        BindingFlags::ExactBinding, 
        nullptr, gcnew array<Object^> { 2 }, nullptr, nullptr);

    // Make a late-bound call to an instance method of the object.    
    MethodInfo^ m = assem->GetType("Example")->GetMethod("SampleMethod");
    Object^ ret = m->Invoke(o, gcnew array<Object^> { 42 });
    Console::WriteLine("SampleMethod returned {0}.", ret);

    Console::WriteLine("\nAssembly entry point:");
    Console::WriteLine(assem->EntryPoint);
}

/* This code example produces output similar to the following:

Assembly Full Name:
source, Version=1.0.2000.0, Culture=neutral, PublicKeyToken=null

Name: source
Version: 1.0

Assembly CodeBase:
file:///C:/sdtree/AssemblyClass/cpp/source.exe

Example->SampleMethod(42) executes.
SampleMethod returned 84.

Assembly entry point:
UInt32 _mainCRTStartup()
 */

using System;
using System.Reflection;
using System.Security.Permissions;

[assembly:AssemblyVersionAttribute("1.0.2000.0")]

public class Example
{
    private int factor;
    public Example(int f)
    {
        factor = f;
    }

    public int SampleMethod(int x)
    {
        Console.WriteLine("\nExample.SampleMethod({0}) executes.", x);
        return x * factor;
    }

    public static void Main()
    {
        Assembly assem = typeof(Example).Assembly;

        Console.WriteLine("Assembly Full Name:");
        Console.WriteLine(assem.FullName);

        // The AssemblyName type can be used to parse the full name.
        AssemblyName assemName = assem.GetName();
        Console.WriteLine("\nName: {0}", assemName.Name);
        Console.WriteLine("Version: {0}.{1}",
            assemName.Version.Major, assemName.Version.Minor);

        Console.WriteLine("\nAssembly CodeBase:");
        Console.WriteLine(assem.CodeBase);

        // Create an object from the assembly, passing in the correct number
        // and type of arguments for the constructor.
        Object o = assem.CreateInstance("Example", false,
            BindingFlags.ExactBinding,
            null, new Object[] { 2 }, null, null);

        // Make a late-bound call to an instance method of the object.
        MethodInfo m = assem.GetType("Example").GetMethod("SampleMethod");
        Object ret = m.Invoke(o, new Object[] { 42 });
        Console.WriteLine("SampleMethod returned {0}.", ret);

        Console.WriteLine("\nAssembly entry point:");
        Console.WriteLine(assem.EntryPoint);
    }
}

/* This code example produces output similar to the following:

Assembly Full Name:
source, Version=1.0.2000.0, Culture=neutral, PublicKeyToken=null

Name: source
Version: 1.0

Assembly CodeBase:
file:///C:/sdtree/AssemblyClass/cs/source.exe

Example.SampleMethod(42) executes.
SampleMethod returned 84.

Assembly entry point:
Void Main()
 */

Imports System.Reflection
Imports System.Security.Permissions

<assembly: AssemblyVersionAttribute("1.0.2000.0")>

Public Class Example
    Private factor As Integer
    
    Public Sub New(ByVal f As Integer) 
        factor = f
    End Sub 
    
    Public Function SampleMethod(ByVal x As Integer) As Integer 
        Console.WriteLine(vbCrLf & "Example.SampleMethod({0}) executes.", x)
        Return x * factor
    End Function 
    
    Public Shared Sub Main() 
        Dim assem As Assembly = GetType(Example).Assembly
        
        Console.WriteLine("Assembly Full Name:")
        Console.WriteLine(assem.FullName)
        
        ' The AssemblyName type can be used to parse the full name.
        Dim assemName As AssemblyName = assem.GetName()
        Console.WriteLine(vbLf + "Name: {0}", assemName.Name)
        Console.WriteLine("Version: {0}.{1}", assemName.Version.Major, _
            assemName.Version.Minor)
        
        Console.WriteLine(vbLf + "Assembly CodeBase:")
        Console.WriteLine(assem.CodeBase)
        
        ' Create an object from the assembly, passing in the correct number
        ' and type of arguments for the constructor.
        Dim o As Object = assem.CreateInstance("Example", False, _
            BindingFlags.ExactBinding, Nothing, _
            New Object() { 2 }, Nothing, Nothing)
        
        ' Make a late-bound call to an instance method of the object.    
        Dim m As MethodInfo = assem.GetType("Example").GetMethod("SampleMethod")
        Dim ret As Object = m.Invoke(o, New Object() { 42 })
        Console.WriteLine("SampleMethod returned {0}.", ret)
        
        Console.WriteLine(vbCrLf & "Assembly entry point:")
        Console.WriteLine(assem.EntryPoint)
    
    End Sub 
End Class 

' This code example produces output similar to the following:
'
'Assembly Full Name:
'source, Version=1.0.2000.0, Culture=neutral, PublicKeyToken=null
'
'Name: source
'Version: 1.0
'
'Assembly CodeBase:
'file:///C:/sdtree/AssemblyClass/vb/source.exe
'
'Example.SampleMethod(42) executes.
'SampleMethod returned 84.
'
'Assembly entry point:
'Void Main()
'

Comentarios

Use la clase Assembly para cargar ensamblados, explorar los metadatos y las partes constituyentes de los ensamblados, detectar los tipos contenidos en ensamblados y crear instancias de esos tipos.

Para obtener una matriz de Assembly objetos que representan los ensamblados cargados actualmente en un dominio de aplicación (por ejemplo, el dominio de aplicación predeterminado de un proyecto simple), use el método AppDomain.GetAssemblies.

Para cargar ensamblados dinámicamente, la clase Assembly proporciona los siguientes métodos estáticos (Shared métodos en Visual Basic). Los ensamblados se cargan en el dominio de aplicación donde se produce la operación de carga.

• La manera recomendada de cargar ensamblados es usar el método Load, que identifica el ensamblado que se va a cargar por su nombre para mostrar (por ejemplo, "System.Windows.Forms, Version=2.0.0.0,0, Culture=neutral, PublicKeyToken=b77a5c561934e089"). La búsqueda del ensamblado sigue las reglas descritas en How the Runtime Locates Assemblies.

• Los métodos ReflectionOnlyLoad y ReflectionOnlyLoadFrom permiten cargar un ensamblado para la reflexión, pero no para su ejecución. Por ejemplo, un ensamblado destinado a una plataforma de 64 bits se puede examinar mediante código que se ejecuta en una plataforma de 32 bits.

• Los métodos LoadFile y LoadFrom se proporcionan para escenarios poco frecuentes en los que un ensamblado debe identificarse por ruta de acceso.

Para obtener un objeto Assembly para el ensamblado que se está ejecutando actualmente, use el método GetExecutingAssembly.

Muchos miembros de la clase Assembly proporcionan información sobre un ensamblado. Por ejemplo:

• El método GetName devuelve un objeto AssemblyName que proporciona acceso a las partes del nombre para mostrar del ensamblado.

• El método GetCustomAttributes enumera los atributos aplicados al ensamblado.

• El método GetFiles proporciona acceso a los archivos del manifiesto del ensamblado.

• El método GetManifestResourceNames proporciona los nombres de los recursos en el manifiesto del ensamblado.

El método GetTypes enumera todos los tipos del ensamblado. El método GetExportedTypes enumera los tipos que son visibles para los autores de llamadas fuera del ensamblado. El método GetType se puede usar para buscar un tipo determinado en el ensamblado. El método CreateInstance se puede usar para buscar y crear instancias de tipos en el ensamblado.

Para obtener más información sobre los ensamblados, vea la sección "Dominios de aplicación y ensamblados" del tema Dominios de aplicación.

Constructores

Assembly()

Inicializa una nueva instancia de la clase Assembly.

Propiedades

CodeBase	Obsoletos. Obtiene la ubicación del ensamblado tal como se especificó originalmente, por ejemplo, en un objeto AssemblyName.
CustomAttributes	Obtiene una colección que contiene los atributos personalizados de este ensamblado.
DefinedTypes	Obtiene una colección de los tipos definidos en este ensamblado.
EntryPoint	Obtiene el punto de entrada de este ensamblado.
EscapedCodeBase	Obsoletos. Obtiene el URI, incluidos los caracteres de escape, que representa el código base.
ExportedTypes	Obtiene una colección de los tipos públicos definidos en este ensamblado que están visibles fuera del ensamblado.
FullName	Obtiene el nombre para mostrar del ensamblado.
GlobalAssemblyCache	Obsoletos. Obtiene un valor que indica si el ensamblado se cargó desde la caché global de ensamblados (solo .NET Framework).
HostContext	Obtiene el contexto de host con el que se cargó el ensamblado.
ImageRuntimeVersion	Obtiene una cadena que representa la versión de Common Language Runtime (CLR) guardada en el archivo que contiene el manifiesto.
IsCollectible	Obtiene un valor que indica si este ensamblado se mantiene en un AssemblyLoadContextrecopilable.
IsDynamic	Obtiene un valor que indica si el ensamblado actual se generó dinámicamente en el proceso actual mediante la emisión de reflexión.
IsFullyTrusted	Obtiene un valor que indica si el ensamblado actual se carga con plena confianza.
Location	Obtiene la ruta de acceso completa o la ubicación UNC del archivo cargado que contiene el manifiesto.
ManifestModule	Obtiene el módulo que contiene el manifiesto del ensamblado actual.
Modules	Obtiene una colección que contiene los módulos de este ensamblado.
ReflectionOnly	Obtiene un valor de Boolean que indica si este ensamblado se cargó en el contexto de solo reflexión.
SecurityRuleSet	Obtiene un valor que indica qué conjunto de reglas de seguridad exige Common Language Runtime (CLR) para este ensamblado.

Métodos

CreateInstance(String)	Busca el tipo especificado de este ensamblado y crea una instancia de él mediante el activador del sistema, mediante la búsqueda con distinción entre mayúsculas y minúsculas.
CreateInstance(String, Boolean)	Busca el tipo especificado de este ensamblado y crea una instancia de él mediante el activador del sistema, con búsqueda opcional con distinción entre mayúsculas y minúsculas.
CreateInstance(String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])	Busca el tipo especificado de este ensamblado y crea una instancia de él mediante el activador del sistema, con una búsqueda opcional que distingue mayúsculas de minúsculas y tiene la referencia cultural, los argumentos y los atributos de enlace y activación especificados.
CreateQualifiedName(String, String)	Crea el nombre de un tipo calificado por el nombre para mostrar de su ensamblado.
Equals(Object)	Determina si este ensamblado y el objeto especificado son iguales.
GetAssembly(Type)	Obtiene el ensamblado cargado actualmente en el que se define el tipo especificado.
GetCallingAssembly()	Devuelve el Assembly del método que invocó el método que se está ejecutando actualmente.
GetCustomAttributes(Boolean)	Obtiene todos los atributos personalizados de este ensamblado.
GetCustomAttributes(Type, Boolean)	Obtiene los atributos personalizados para este ensamblado, tal como se especifica por tipo.
GetCustomAttributesData()	Devuelve información sobre los atributos que se han aplicado al Assemblyactual, expresados como objetos CustomAttributeData.
GetEntryAssembly()	Obtiene el ensamblado de entrada para la aplicación en ejecución.
GetExecutingAssembly()	Obtiene el ensamblado que contiene el código que se está ejecutando actualmente.
GetExportedTypes()	Obtiene los tipos públicos definidos en este ensamblado que están visibles fuera del ensamblado.
GetFile(String)	Obtiene un FileStream para el archivo especificado en la tabla de archivos del manifiesto de este ensamblado.
GetFiles()	Obtiene los archivos de la tabla de archivos de un manifiesto de ensamblado.
GetFiles(Boolean)	Obtiene los archivos de la tabla de archivos de un manifiesto de ensamblado, especificando si se van a incluir módulos de recursos.
GetForwardedTypes()	Representa un ensamblado, que es un bloque de creación reutilizable, versionable y autodescriptible de una aplicación de Common Language Runtime.
GetHashCode()	Devuelve el código hash de esta instancia.
GetLoadedModules()	Obtiene todos los módulos cargados que forman parte de este ensamblado.
GetLoadedModules(Boolean)	Obtiene todos los módulos cargados que forman parte de este ensamblado, especificando si se deben incluir módulos de recursos.
GetManifestResourceInfo(String)	Devuelve información sobre cómo se ha conservado el recurso especificado.
GetManifestResourceNames()	Devuelve los nombres de todos los recursos de este ensamblado.
GetManifestResourceStream(String)	Carga el recurso de manifiesto especificado de este ensamblado.
GetManifestResourceStream(Type, String)	Carga el recurso de manifiesto especificado, con ámbito por el espacio de nombres del tipo especificado, desde este ensamblado.
GetModule(String)	Obtiene el módulo especificado en este ensamblado.
GetModules()	Obtiene todos los módulos que forman parte de este ensamblado.
GetModules(Boolean)	Obtiene todos los módulos que forman parte de este ensamblado, especificando si se van a incluir módulos de recursos.
GetName()	Obtiene un AssemblyName para este ensamblado.
GetName(Boolean)	Obtiene un AssemblyName para este ensamblado, estableciendo el código base como se especifica en copiedName.
GetObjectData(SerializationInfo, StreamingContext)	Obsoletos. Obtiene información de serialización con todos los datos necesarios para volver a fundamentar este ensamblado.
GetReferencedAssemblies()	Obtiene los objetos AssemblyName para todos los ensamblados a los que hace referencia este ensamblado.
GetSatelliteAssembly(CultureInfo)	Obtiene el ensamblado satélite de la referencia cultural especificada.
GetSatelliteAssembly(CultureInfo, Version)	Obtiene la versión especificada del ensamblado satélite para la referencia cultural especificada.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetType(String)	Obtiene el objeto Type con el nombre especificado en la instancia de ensamblado.
GetType(String, Boolean)	Obtiene el objeto Type con el nombre especificado en la instancia de ensamblado y, opcionalmente, produce una excepción si no se encuentra el tipo.
GetType(String, Boolean, Boolean)	Obtiene el objeto Type con el nombre especificado en la instancia de ensamblado, con las opciones de omitir el caso y de producir una excepción si no se encuentra el tipo.
GetTypes()	Obtiene todos los tipos definidos en este ensamblado.
IsDefined(Type, Boolean)	Indica si se ha aplicado o no un atributo especificado al ensamblado.
Load(AssemblyName)	Carga un ensamblado dado su AssemblyName.
Load(Byte[])	Carga el ensamblado con una imagen basada en formato de archivo de objeto común (COFF) que contiene un ensamblado emitido.
Load(Byte[], Byte[])	Carga el ensamblado con una imagen basada en formato de archivo de objeto común (COFF) que contiene un ensamblado emitido, que opcionalmente incluye símbolos para el ensamblado.
Load(String)	Carga un ensamblado con el nombre especificado.
LoadFile(String)	Carga el contenido de un archivo de ensamblado en la ruta de acceso especificada.
LoadFrom(String)	Carga un ensamblado según su nombre de archivo o ruta de acceso.
LoadFrom(String, Byte[], AssemblyHashAlgorithm)	Carga un ensamblado según su nombre de archivo o ruta de acceso, valor hash y algoritmo hash.
LoadModule(String, Byte[])	Carga el módulo, interno en este ensamblado, con una imagen basada en formato de archivo de objeto común (COFF) que contiene un módulo emitido o un archivo de recursos.
LoadModule(String, Byte[], Byte[])	Carga el módulo, interno en este ensamblado, con una imagen basada en formato de archivo de objeto común (COFF) que contiene un módulo emitido o un archivo de recursos. Los bytes sin procesar que representan los símbolos del módulo también se cargan.
LoadWithPartialName(String)	Obsoletos. Carga un ensamblado desde el directorio de la aplicación o desde la caché global de ensamblados con un nombre parcial.
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
ReflectionOnlyLoad(Byte[])	Obsoletos. Carga el ensamblado desde una imagen basada en formato de archivo de objeto común (COFF) que contiene un ensamblado emitido. El ensamblado se carga en el contexto de solo reflexión del dominio de aplicación del autor de la llamada.
ReflectionOnlyLoad(String)	Obsoletos. Carga un ensamblado en el contexto de solo reflexión, dado su nombre para mostrar.
ReflectionOnlyLoadFrom(String)	Obsoletos. Carga un ensamblado en el contexto de solo reflexión, dada su ruta de acceso.
ToString()	Devuelve el nombre completo del ensamblado, también conocido como nombre para mostrar.
UnsafeLoadFrom(String)	Carga un ensamblado en el contexto de carga desde y pasa algunas comprobaciones de seguridad.

Operadores

Equality(Assembly, Assembly)	Indica si dos objetos Assembly son iguales.
Inequality(Assembly, Assembly)	Indica si dos objetos Assembly no son iguales.

Eventos

ModuleResolve

Se produce cuando el cargador de clases de Common Language Runtime no puede resolver una referencia a un módulo interno de un ensamblado a través de medios normales.

Métodos de extensión

GetExportedTypes(Assembly)	Representa un ensamblado, que es un bloque de creación reutilizable, versionable y autodescriptible de una aplicación de Common Language Runtime.
GetModules(Assembly)	Representa un ensamblado, que es un bloque de creación reutilizable, versionable y autodescriptible de una aplicación de Common Language Runtime.
GetTypes(Assembly)	Representa un ensamblado, que es un bloque de creación reutilizable, versionable y autodescriptible de una aplicación de Common Language Runtime.
GetCustomAttribute(Assembly, Type)	Recupera un atributo personalizado de un tipo especificado que se aplica a un ensamblado especificado.
GetCustomAttribute<T>(Assembly)	Recupera un atributo personalizado de un tipo especificado que se aplica a un ensamblado especificado.
GetCustomAttributes(Assembly)	Recupera una colección de atributos personalizados que se aplican a un ensamblado especificado.
GetCustomAttributes(Assembly, Type)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un ensamblado especificado.
GetCustomAttributes<T>(Assembly)	Recupera una colección de atributos personalizados de un tipo especificado que se aplica a un ensamblado especificado.
IsDefined(Assembly, Type)	Indica si los atributos personalizados de un tipo especificado se aplican a un ensamblado especificado.
TryGetRawMetadata(Assembly, Byte*, Int32)	Recupera la sección de metadatos del ensamblado, para su uso con MetadataReader.

Seguridad para subprocesos

Este tipo es seguro para subprocesos.

Consulte también

• AppDomain
• AssemblyName
• dominios de aplicación de