.NET Module vs Assembly

Question

Ho cercato di comprendere la risposta "giusta" a questo? ci sono un paio di argomenti su StackOverflow che copre questo, ma questo è in qualche modo in conflitto con la documentazione di msdn.

per esempio, notare il diagramma nel 2 ° risposta alla sua domanda: What is a Managed Module (compared to an Assembly)?

Ora guardate il diagramma MSDN: http://msdn.microsoft.com/en-us/library/zst29sk2(VS.100).aspx

diagramma msdn implica che un gruppo di file singolo non comprende di un modulo, ma piuttosto di un manifest, il codice, digita i metadati, ecc. Questo è diverso da molti altri articoli che ho letto in cui si afferma che un singolo gruppo di file ha un modulo.

Qual è la risposta? Se la risposta è "entrambi", il modulo è un file phyical separato collegato tramite il manifest assembly?

Answer 1

Ogni assemblea ha almeno un modulo. È un dettaglio di implementazione altamente invisibile. Ma puoi vederlo quando usi Reflection.Emit. Dal codice di esempio per la 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 l'utilizzo della classe ModuleBuilder, tipi vengono aggiunti ad un modulo. Che un assembly possa contenere più moduli è piuttosto irrilevante, l'ambiente di sviluppo non lo supporta. Non solo l'IDE, MSBuild non supporta neanche. Dovresti scrivere uno script di compilazione per utilizzare al.exe, the assembly linker. Non ci sono buoni motivi per fare ciò che posso pensare, tutti i compilatori .NET sanno già come generare direttamente un singolo modulo. Al.exe è un tipico strumento di bootstrap, probabilmente usato per creare mscorlib.dll.

Answer 2

Un modulo è una raccolta logica di codice all'interno di un assieme. È possibile avere più moduli all'interno di un assieme e ogni modulo può essere scritto in diversi linguaggi .NET (VS, per quanto ne so, non supporta la creazione di assiemi multi-modulo).

Gli assembly contengono moduli. I moduli contengono classi. Le classi contengono funzioni.

Da: What is a module in .NET?

Davvero Da: Bing search "modulo .NET vs montaggio"

Answer 3

NET la differenza tra un assieme e modulo è che un modulo non contiene il manifesta.

//Copied from CLR via C# 

ciò che è palese?

Il file manifest è un'altra serie di tabelle di metadati che contengono essenzialmente i nomi dei file che fanno parte dell'assieme. Inoltre, descrivono la versione dell'assembly, la lingua, l'editore, i tipi esportati pubblicamente e tutti i file compresi nell'assieme da .

Il CLR funziona su assiemi; vale a dire, il CLR carica sempre il file che contiene le tabelle dei metadati manifest e quindi utilizza il manifest per ottenere i nomi degli altri file/moduli presenti nell'assembly.

Come combinare i moduli per formare un assieme?

con C# compilatore

per capire come costruire un fascicolo/multimodulo assemblaggio, supponiamo di avere due file di codice sorgente:

■■ RUT.cs, che contiene raramente utilizzato tipi

■■ FUT.cs, che contiene i tipi di uso frequente

Diamo compilare i tipi usati raramente int o il proprio modulo in modo che gli utenti dell'assembly non abbiano bisogno di per distribuire questo modulo se non accedono mai ai tipi usati raramente.

csc /t:module RUT.cs 

Questa linea fa sì che il compilatore C# per creare un file RUT.netmodule. Questo file è un file PE DLL standard, ma, di per sé, il CLR non può caricarlo. Quindi compiliamo i tipi usati di frequente nel loro modulo. Creeremo questo modulo il custode del manifest dell'assembly perché i tipi sono usati così spesso. Infatti, poiché questo modulo rappresenterà l'intero assembly, cambierò il nome del file di output in MultiFileLibrary.dll anziché chiamarlo FUT.dll.

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

Questa linea dice al compilatore C# per compilare il file FUT.cs per produrre il file MultiFileLibrary.dll. Perché /t: la libreria è specificata, un file PE DLL contenente le tabelle dei metadati manifest viene emesso nel file MultiFileLibrary.dll. L'interruttore .netmodule /addmodule:RUT dice al compilatore che Rut.netmodule è un file che dovrebbe essere considerato parte dell'assieme. Nello specifico, l'interruttore /addmodule comunica al compilatore di aggiungere il file alla tabella dei metadati manifest di FileDef e di aggiungere i tipi esportati di RUT.netmodule a nella tabella dei metadati manifest di ExportedTypesDef.

Dopo che il compilatore ha completato tutta la sua elaborazione, vengono creati i due file mostrati nella Figura 2-1. Il modulo a destra contiene il manifest.

Utilizzando l'Assembly Linker

L'utilità Al.exe in grado di produrre un file PE DLL che contiene solo un manifesto che descrive i tipi in altri moduli EXE o. Per capire come funziona AL.exe, cambiamo il modo in cui l'assembly MultiFileLibrary.dll viene creato.

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

La Figura 2-3 mostra i file risultanti dall'esecuzione di queste istruzioni.

vorrei suggerire di leggere CAPITOLO 2: costruzione, imballaggio, la distribuzione e applicazioni Amministrazione e tipi da CLR via C# di Jeffrey Richter per capire il concetto in dettaglio.