c# - name - Módulo.NET vs Asamblea

xml doc

Question

¿He estado tratando de envolver mi cabeza alrededor de la respuesta ''correcta'' a esto? Hay un par de temas en stackoverflow que cubren esto, pero que entran en conflicto con la documentación de msdn.

por ejemplo, observe el diagrama en la segunda respuesta a su pregunta: ¿Qué es un módulo administrado (comparado con un ensamblaje)?

Ahora mire el diagrama msdn: http://msdn.microsoft.com/en-us/library/zst29sk2(VS.100).aspx

el diagrama msdn implica que un conjunto de un solo archivo no forma parte de un módulo, sino más bien de un manifiesto, un código il, tipos de metadatos, etc. un modulo

¿Cual es la respuesta? Si la respuesta es ''ambos'', ¿es el módulo un archivo físico separado que se vincula a través del manifiesto del ensamblaje?

Answer 1

En .net, la diferencia entre un ensamblaje y un módulo es que un módulo no contiene el manifiesto .

//Copied from CLR via C#

¿Qué es manifiesto?

El manifiesto es otro conjunto de tablas de metadatos que básicamente contienen los nombres de los archivos que forman parte del ensamblaje. También describen la versión del ensamblaje, la cultura, el editor, los tipos exportados públicamente y todos los archivos que conforman el ensamblaje.

El CLR opera en montajes; es decir, el CLR siempre carga primero el archivo que contiene las tablas de metadatos del manifiesto y luego usa el manifiesto para obtener los nombres de los otros archivos / módulos que están en el ensamblaje.

¿Cómo combinar módulos para formar un ensamblaje?

Usando el compilador de C #

Para comprender cómo construir un ensamblaje de varios archivos / multimódulos, supongamos que tenemos dos archivos de código fuente:

■■ RUT.cs, que contiene tipos raramente utilizados

■■ FUT.cs, que contiene tipos de uso frecuente

Compilemos los tipos raramente utilizados en su propio módulo para que los usuarios del ensamblaje no necesiten implementar este módulo si nunca acceden a los tipos raramente utilizados.

csc /t:module RUT.cs

Esta línea hace que el compilador de C # cree un archivo de módulo RUT.net. Este archivo es un archivo DLL estándar de PE, pero, por sí solo, el CLR no puede cargarlo. A continuación, vamos a compilar los tipos de uso frecuente en su propio módulo. Haremos de este módulo el guardián del manifiesto del ensamblaje porque los tipos se utilizan con mucha frecuencia. De hecho, como este módulo ahora representará todo el ensamblaje, cambiaré el nombre del archivo de salida a MultiFileLibrary.dll en lugar de llamarlo FUT.dll.

csc /out:MultiFileLibrary.dll /t:library /addmodule:RUT.netmodule FUT.cs

Esta línea le dice al compilador de C # que compile el archivo FUT.cs para producir el archivo MultiFileLibrary.dll. Como se especifica / t: library, se emite un archivo DLL PE que contiene las tablas de metadatos de manifiesto en el archivo MultiFileLibrary.dll. El /addmodule:RUT .netmodule le dice al compilador que RUT.netmodule es un archivo que debe considerarse parte del ensamblaje. Específicamente, el /addmodule le dice al compilador que agregue el archivo a la tabla de metadatos de manifiesto FileDef y que agregue los tipos exportados públicamente por RUT.net a la tabla de metadatos de manifiesto ExportedTypesDef.

Una vez que el compilador ha terminado todo su procesamiento, se crean los dos archivos que se muestran en la Figura 2-1. El módulo de la derecha contiene el manifiesto.

Usando el enlazador de ensamblaje

La utilidad AL.exe puede producir un archivo EXE o DLL PE que contiene solo un manifiesto que describe los tipos en otros módulos. Para comprender cómo funciona AL.exe, vamos a cambiar la forma en que se construye el ensamblado MultiFileLibrary.dll.

csc /t:module RUT.cs
csc /t:module FUT.cs
al /out: MultiFileLibrary.dll /t:library FUT.netmodule RUT.netmodule

La Figura 2-3 muestra los archivos que resultan de la ejecución de estas declaraciones.

Le sugiero que lea el CAPÍTULO 2: Creación, empaquetado, implementación y administración de aplicaciones y tipos de CLR a través de C # por Jeffrey Richter para comprender el concepto en detalle.

Answer 2

Un módulo es una colección lógica de código dentro de un ensamblaje. Puede tener varios módulos dentro de un ensamblaje, y cada módulo puede escribirse en diferentes lenguajes .NET (VS, que yo sepa, no admite la creación de ensamblajes de múltiples módulos).

Los conjuntos contienen módulos. Los módulos contienen clases. Las clases contienen funciones.

De: ¿Qué es un módulo en .NET?

Realmente desde: Bing search ".NET module vs assembly"

Answer 3

Cada montaje tiene al menos un módulo. Es un detalle de implementación que es altamente invisible. Pero puedes verlo cuando usas Reflection.Emit. Del código de ejemplo para la clase AssemblyBuilder :

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);

Tenga en cuenta el uso de la clase ModuleBuilder, los tipos se agregan a un módulo. Que un ensamblaje pueda contener múltiples módulos es bastante irrelevante, el entorno de compilación no lo admite. No solo el IDE, MSBuild tampoco lo admite. Tendría que escribir un script de compilación para usar al.exe, el vinculador de ensamblaje . No se me ocurren buenas razones para hacer esto, todos los compiladores .NET ya saben cómo generar un solo ensamblaje de módulo directamente. Al.exe es una herramienta de arranque típica, posiblemente utilizada para compilar mscorlib.dll.