.NET Module vs Assembly

Question

He estado tratando de entender la respuesta "correcta" a esto? hay un par de temas en stackoverflow que lo cubren, pero que entran en conflicto con la documentación de msdn.

por ejemplo, tenga en cuenta el diagrama de la segunda respuesta a su pregunta: What is a Managed Module (compared to an Assembly)?

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

el diagrama de MSDN implica que un conjunto de una sola archivo no forma parte de una módulo, sino más bien de un manifiesto, código il, tipo de metadatos, etc. Esto es diferente a muchos otros artículos que he leído que indica que un único archivo de ensamblaje tiene un módulo.

¿Cuál es la respuesta? Si la respuesta es 'both', entonces ¿el módulo es un archivo phyical separado que está vinculado a través del manifiesto de ensamblaje?

Answer 1

Cada conjunto tiene al menos un módulo. Es un detalle de implementación que es altamente invisible. Pero puedes verlo cuando usas Reflection.Emit. Desde el código de ejemplo para el AssemblyBuilder class:

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

Nota el uso de la clase ModuleBuilder, los tipos se añaden 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 construcción usted mismo para usar al.exe, the assembly linker. No hay buenas razones para hacer esto que puedo pensar, todos los compiladores .NET ya saben cómo generar un ensamblaje de módulo individual directamente. Al.exe es una herramienta de arranque típica, posiblemente utilizada para construir mscorlib.dll.

Answer 2

Un módulo es una recopilación lógica de código dentro de un Ensamblaje. Puede tener múltiples módulos dentro de un Ensamblaje, y cada módulo puede escribirse en diferentes lenguajes .NET (VS, hasta donde yo sé, no admite la creación de ensambles de múltiples módulos).

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

Desde: What is a module in .NET?

Realmente Desde: búsqueda Bing "módulo de .NET vs asamblea"

Answer 3

En .NET la diferencia entre un montaje y el módulo es que un módulo no contiene el manifiesto.

//Copied from CLR via C# 

Lo que se manifiesta?

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

El CLR funciona en conjuntos; es decir, el CLR siempre carga primero el archivo que contiene las tablas de metadatos de manifiesto y luego utiliza el manifiesto para obtener los nombres de los otros archivos/módulos que están en el ensamblado.

Cómo combinar módulos para formar un conjunto?

Usando compilador de C#

Para entender cómo construir un/multimódulo ensamblaje en varios archivos, vamos a suponer que tenemos dos archivos de código fuente:

■■ RUT.cs, que contiene raramente utilizado tipos

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

Vamos a compilar los tipos rara vez se utilizan int o su propio módulo para que los usuarios del ensamblaje no necesiten para implementar este módulo si nunca acceden a los tipos poco utilizados.

csc /t:module RUT.cs 

Esta línea hace que el compilador C# cree un archivo RUT.netmodule. Este archivo es un archivo DLL PE estándar, pero, por sí mismo, el CLR no puede cargarlo. A continuación, compilemos los tipos más utilizados en su propio módulo. Haremos de este módulo el guardián del manifiesto de la asamblea porque los tipos se utilizan con tanta frecuencia. De hecho, debido a que este módulo ahora representará todo el conjunto, 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# para compilar 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 modificador .netmodule /addmodule:RUT le dice al compilador que RUT.netmodule es un archivo que se debe considerar parte del ensamblado. Específicamente, el modificador /addmodule indica al compilador que agregue el archivo a la tabla de metadatos del manifiesto FileDef y que agregue los tipos exportados de RUT.netmodule a la tabla de metadatos del manifiesto ExportedTypesDef.

Después de que el compilador haya 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

Asamblea La utilidad al.exe puede producir una un archivo PE DLL que contiene sólo un manifiesto de la descripción de las tipos en otros módulos EXE o. Para comprender cómo funciona AL.exe, cambiemos 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.

Yo sugeriría a leer CAPÍTULO 2: construcción, embalaje, la implementación y la administración de aplicaciones y tipos deCLR a través de C# de Jeffrey Richter a entender el concepto en detalle.