Cosa sono gli assembly .NET?

Cosa sono gli assembly .NET? Ho sfogliato la rete e non riesco a capire la definizione.

In termini più semplici: un pezzo di codice (precompilato) che può essere eseguito dall'ambiente di runtime .NET. Un programma .NET è costituito da uno o più assembly.

Assembly è la più piccola unità di distribuzione di un'applicazione .net. Può essere una dll o una exe .
Esistono principalmente due tipi:

1. Assemblea privata: la dll o exe che è di proprietà esclusiva di una sola applicazione. In genere è memorizzato nella cartella principale dell'applicazione

2. Assembly pubblico / condiviso: è una dll che può essere utilizzata da più applicazioni contemporaneamente. Un assembly condiviso viene archiviato in GAC, ovvero Global Assembly Cache .

Sembra difficile? Naa ....
GAC è semplicemente la cartella C: \ Windows \ Assembly in cui è possibile trovare gli assembly / dll pubblici di tutti i software installati nel PC.

Esiste anche un terzo e meno noto tipo di assembly: Satellite Assembly .
Un assieme satellite contiene solo oggetti statici come immagini e altri file non eseguibili richiesti dall'applicazione.

Spero che questo aiuti i lettori!

assemblee

Quando si compila un'applicazione, il codice MSIL creato viene archiviato in un assembly. Gli assembly includono sia i file delle applicazioni eseguibili che è possibile eseguire direttamente da Windows senza la necessità di altri programmi (questi hanno un'estensione di file .exe), sia le librerie (che hanno un'estensione .dll) per l'uso da altre applicazioni.

Oltre a contenere MSIL, gli assembly includono anche meta informazioni (ovvero informazioni sulle informazioni contenute nell'assembly, note anche come metadati) e risorse opzionali (dati aggiuntivi utilizzati da MSIL, come file audio e immagini). Le meta informazioni consentono agli assembly di essere completamente auto-descrittivi. Non sono necessarie altre informazioni per utilizzare un assembly, il che significa che si evitano situazioni come la mancata aggiunta dei dati richiesti al registro di sistema e così via, il che spesso rappresentava un problema durante lo sviluppo con altre piattaforme.

Ciò significa che la distribuzione di applicazioni è spesso semplice come copiare i file in una directory su un computer remoto. Poiché non sono necessarie ulteriori informazioni sui sistemi di destinazione, è possibile semplicemente eseguire un file eseguibile da questa directory e (supponendo che sia installato .NET CLR) si è pronti per partire.

Naturalmente, non vorrai necessariamente includere tutto ciò che è necessario per eseguire un'applicazione in un unico posto. È possibile scrivere del codice che esegue attività richieste da più applicazioni. In situazioni del genere, è spesso utile posizionare il codice riutilizzabile in un luogo accessibile a tutte le applicazioni. In .NET Framework, si tratta della Global Assembly Cache (GAC). Inserire il codice nel GAC è semplice: basta posizionare l'assembly contenente il codice nella directory che contiene questa cache.

Un assembly è il file DLL effettivo sul disco rigido in cui sono memorizzate le classi in .NET Framework. Ad esempio, tutte le classi contenute in ASP.NET Framework si trovano in un assembly denominato System.Web.dll.

Più precisamente, un assembly è l'unità principale di distribuzione, sicurezza e controllo della versione in .NET Framework. Poiché un assembly può estendersi su più file, un assembly viene spesso indicato come dll "logica".

Nota

.NET Framework (versione 2.0) include 51 assembly.

Esistono due tipi di assembly: privato e condiviso. Un assembly privato può essere utilizzato da un'unica applicazione. Un assembly condiviso, d'altra parte, può essere utilizzato da tutte le applicazioni situate sullo stesso server.

Gli assembly condivisi si trovano nella Global Assembly Cache (GAC). Ad esempio, l'assembly System.Web.dll e tutti gli altri assembly inclusi in .NET Framework si trovano nella Global Assembly Cache.

Nota

La Global Assembly Cache si trova fisicamente nella cartella \ WINDOWS \ Assembly del computer. Esiste una copia separata di ogni assembly nella cartella \ WINDOWS \ Microsoft.NET \ Framework \ v2.0.50727. Il primo set di assiemi viene utilizzato in fase di esecuzione e il secondo set viene utilizzato in fase di compilazione.

Prima di poter utilizzare una classe contenuta in un assembly nell'applicazione, è necessario aggiungere un riferimento all'assembly. Per impostazione predefinita, un'applicazione ASP.NET fa riferimento agli assembly più comuni contenuti nella Global Assembly Cache:

mscorlib.dll

System.dll

System.Configuration.dll

System.Web.dll

System.Data.dll

System.Web.Services.dll

System.Xml.dll

System.Drawing.dll

System.EnterpriseServices.dll

System.Web.Mobile.dll

Per utilizzare una classe particolare in .NET Framework, è necessario eseguire due operazioni. Innanzitutto, l'applicazione deve fare riferimento all'assembly che contiene la classe. In secondo luogo, l'applicazione deve importare lo spazio dei nomi associato alla classe.

Nella maggior parte dei casi, non dovrai preoccuparti di fare riferimento all'assembly necessario perché gli assemblaggi più comuni vengono referenziati automaticamente. Tuttavia, se è necessario utilizzare un assembly specializzato, è necessario aggiungere esplicitamente un riferimento all'assembly. Ad esempio, se è necessario interagire con Active Directory utilizzando le classi nello spazio dei nomi System.DirectoryServices, sarà necessario aggiungere un riferimento all'assembly System.DirectoryServices.dll all'applicazione.

Ogni voce di classe nella documentazione di .NET Framework SDK elenca l'assembly e lo spazio dei nomi associati alla classe. Ad esempio, se si cerca la classe MessageQueue nella documentazione, si scoprirà che questa classe si trova nello spazio dei nomi System.Messaging situato nell'assembly System.Messaging.dll.

Se si utilizza Visual Web Developer, è possibile aggiungere esplicitamente un riferimento a un assembly selezionando l'opzione di menu Sito Web, Aggiungi riferimento e selezionando il nome dell'assembly a cui è necessario fare riferimento. Ad esempio, l'aggiunta di un riferimento all'assembly System.Messaging.dll comporta l'aggiunta del file di configurazione Web nel Listato 1.4 all'applicazione.

Per esempio. web.Config

enter code here

Se si preferisce non utilizzare Visual Web Developer, è possibile aggiungere manualmente il riferimento all'assembly System.Messaging.dll creando manualmente il file nell'esempio sopra

Wikipedia ha da dire:

Nel framework Microsoft .NET, un assembly è una libreria di codici parzialmente compilata per l'utilizzo in deployment, versioning e sicurezza. Esistono due tipi: assembly di processo (EXE) e assembly di libreria (DLL). Un assembly di processo rappresenta un processo che utilizzerà le classi definite negli assembly di libreria. Gli assembly .NET contengono codice in CIL, che di solito viene generato da un linguaggio CLI e quindi compilato in linguaggio macchina in fase di esecuzione dal compilatore just-in-time CLR. Un assembly può essere costituito da uno o più file. I file di codice sono chiamati moduli. Un assembly può contenere più di un modulo di codice e poiché è possibile utilizzare lingue diverse per creare moduli di codice, è tecnicamente possibile utilizzare diverse lingue per creare un assembly.

Se davvero hai navigato, sarebbe di aiuto se chiarissi ciò che non capisci

Vedi questo :

Nel framework Microsoft .NET, un assembly è una libreria di codici parzialmente compilata per l'utilizzo in deployment, versioning e sicurezza

raccolta fisica di classe, interfaccia, enum ecc. che si trova nel codice IL. Che può essere un file .EXE o .DLL .EXE è un file eseguibile e .DLL può essere utilizzato in modo dinamico in qualsiasi linguaggio .net supportato.

Un assembly è un'unità di runtime composta da tipi e altre risorse. Tutti i tipi in un assieme hanno lo stesso numero di versione.

Spesso, un assembly ha un solo spazio dei nomi ed è utilizzato da un programma. Ma può estendersi su più spazi dei nomi. Inoltre, uno spazio dei nomi può essere distribuito su più assembly. In progetti di grandi dimensioni, un assembly può essere costituito da più file tenuti insieme da un manifest (ovvero un sommario).

In C #, un assembly è la distribuzione più piccola di un'applicazione .Net. Può essere una dll o una exe. Ha due tipi: 1. Assembly privato 2. Assembly pubblico / condiviso

Oltre alla risposta accettata, voglio darti un esempio!

Ad esempio, usiamo tutti

System.Console.WriteLine()

Ma dov'è il codice per System.Console.WriteLine !?
qual è il codice che mette effettivamente il testo sulla console?

Se guardi la prima pagina della documentazione per la classe Console , vedrai in alto quanto segue: Assembly: mscorlib (in mscorlib.dll) Indica che il codice per la classe Console si trova in un assem-bly chiamato mscorlib. Un assembly può essere composto da più file, ma in questo caso è solo un file, ovvero la libreria a collegamento dinamico mscorlib.dll.

Il file mscorlib.dll è molto importante in .NET, è la DLL principale per le librerie di classi in .NET e contiene tutte le classi e le strutture di base di .NET.

se conosci C o C ++, in genere hai bisogno di una direttiva #include nella parte superiore che faccia riferimento a un file di intestazione. Il file include fornisce prototipi di funzioni al compilatore. al contrario Il compilatore C # non ha bisogno di file header. Durante la compilazione, il compilatore C # accede direttamente al file mscorlib.dll e ottiene informazioni dai metadati in quel file riguardanti tutte le classi e altri tipi ivi definiti.

Il compilatore C # è in grado di stabilire che mscorlib.dll contiene effettivamente una classe denominata Console in uno spazio dei nomi denominato Sistema con un metodo denominato WriteLine che accetta un singolo argomento di tipo stringa.

Il compilatore C # può determinare che la chiamata WriteLine è valida e il compilatore stabilisce un riferimento all'assembly mscorlib nell'eseguibile.

per impostazione predefinita Il compilatore C # accederà a mscorlib.dll, ma per altre DLL, sarà necessario indicare al compilatore l'assembly in cui si trovano le classi. Questi sono noti come riferimenti.

Spero che sia chiaro ora!

Da DotNetBookZero Charles pitzold

MSDN ha una buona spiegazione :

Gli assembly sono i mattoni delle applicazioni .NET Framework; formano l'unità fondamentale di distribuzione, controllo della versione, riutilizzo, ambito di attivazione e autorizzazioni di sicurezza. Un assieme è una raccolta di tipi e risorse creati per funzionare insieme e formare un'unità logica di funzionalità. Un assembly fornisce al linguaggio comune runtime le informazioni necessarie per conoscere le implementazioni dei tipi. Per il runtime, un tipo non esiste al di fuori del contesto di un assembly.

Un assembly è una raccolta di tipi e risorse che costituisce un'unità logica di funzionalità. Tutti i tipi in .NET Framework devono esistere negli assembly; Common Language Runtime non supporta tipi al di fuori degli assembly. Ogni volta che si crea un'applicazione Microsoft Windows®, un servizio Windows, una libreria di classi o un'altra applicazione con Visual Basic .NET, si crea un singolo assembly. Ogni assembly viene archiviato come file .exe o .dll.

Fonte: https://msdn.microsoft.com/en-us/library/ms973231.aspx#assenamesp_topic4

Per quelli con un background Java come me spero che il seguente diagramma chiarisca i concetti -

Gli assiemi sono proprio come file jar (contenenti più file .class). Il tuo codice può fare riferimento a un assembly esistente oppure il codice stesso può essere pubblicato come assembly per altro codice da utilizzare come riferimento e da utilizzare (puoi pensarlo come file jar in Java che puoi aggiungere nelle dipendenze del tuo progetto).

Alla fine della giornata un assembly è un codice compilato che può essere eseguito su qualsiasi sistema operativo con CLR installato. Ciò equivale a dire che il file .class o il jar in bundle possono essere eseguiti su qualsiasi macchina con JVM installato.

In .Net, un assembly può essere:

Una raccolta di vari gestibili parti contenenti Types (or Classes), Resources (Bitmaps/Images/Strings/Files), Namespaces, Config Filescompilato Privatelyo Publicly; distribuito in una cartella localo Shared (GAC); discover-ableda altri programs/assembliese; può essere modificato in versione.

Poiché assembly è la più piccola unità di controllo delle versioni, distribuzione e riusabilità del codice in Microsoft.Net.

Contiene:

- Assembly Identity
- Manifest
- Metadata
- MSIL Code
- Security Information
- Assembly Header

L'assemblaggio è la parte fondamentale della programmazione con .NET Framework. Contiene il codice che CLR esegue il codice MSIL (Microsoft Intermediate Language) in un file eseguibile portatile non verrà eseguito se non ha un manifest dell'assembly associato.

Le applicazioni .NET sono costruite mettendo insieme un numero qualsiasi di assiemi. In poche parole, un assembly non è altro che un binario con versione auto-descrittiva (DLL o EXE) contenente una raccolta di tipi (classi, interfacce, strutture, ecc.) E risorse opzionali (immagini, tabelle di stringhe e quant'altro). Una cosa di cui essere dolorosamente consapevoli in questo momento, è che l'organizzazione interna di un assembly .NET non è come l'organizzazione interna di un classico server COM (indipendentemente dalle estensioni di file condivise).

In .NET, quando compiliamo il nostro codice sorgente, l'assembly viene generato in Visual Studio. L'Assemblea è composta da due parti Manifest e IL (Intermediate Language). Manifest contiene metadati dell'assembly: requisiti di versione dell'assembly, identità di sicurezza, nomi e hash di tutti i file che compongono l'assembly. IL contiene informazioni su classi, costruttori, metodo principale ecc.

Ho trovato questo link molto utile. Ti dà anche un'idea di come IL abbia un ruolo in .NET.

http://www.codeguru.com/columns/csharp_learning/article.php/c5845/C-FAQ-15--What-is-an-Assembly.htm

Le soluzioni di Visual Studio sono costituite da uno o più progetti. Ad esempio: i progetti console possono produrre un assieme . Un assembly è logicamente un pezzo di codice che può essere spedito ai clienti e fisicamente un .EXE (programma eseguibile) o .DLL (sono riutilizzabili da altri programmi).

Gli assembly contengono informazioni su contenuto, controllo delle versioni e dipendenze, le applicazioni che li utilizzano non devono fare affidamento su fonti esterne, come il registro sui sistemi Windows, per funzionare correttamente. Gli assembly riducono i conflitti .dll e rendono le applicazioni più affidabili e facili da distribuire.

È una raccolta di tipi e risorse che sono costruite per lavorare insieme e formare un'unità logica di funzionalità. Gli assiemi assumono la forma di file eseguibili (.exe) o di librerie a collegamento dinamico (.dll) e sono i mattoni delle applicazioni .NET. Forniscono al Common Language Runtime le informazioni necessarie per conoscere le implementazioni dei tipi.

Ogni assembly ha un file manifest dell'assembly. Simile a un sommario contenuto nel manifest dell'assembly:

• L'identità dell'assembly (il suo nome e versione).
• Una tabella di file che descrive tutti gli altri file che compongono l'assembly, ad esempio altri assembly creati su cui si basa il file .exe o .dll, i file bitmap o i file Leggimi.
• Un elenco di riferimenti di assembly, che è un elenco di tutte le dipendenze esterne, come .dlls o altri file. I riferimenti di assemblaggio contengono riferimenti a oggetti globali e privati. In .NET Framework, gli oggetti globali risiedono nella Global Assembly Cache (GAC). System.IO.dll è un esempio di un assembly nel GAC. Gli oggetti privati ​​devono trovarsi a un livello di directory pari o inferiore alla directory in cui è installata l'app.

Per utilizzare un assembly in un'applicazione, è necessario aggiungere un riferimento ad esso. Dopo aver fatto riferimento a un assembly, tutti i tipi, le proprietà, i metodi e gli altri membri accessibili dei relativi spazi dei nomi sono disponibili per l'applicazione come se il loro codice fosse parte del file di origine.

Quindi sappiamo tutti che il nostro codice sorgente è convertito in Microsoft Intermediate Language (MSIL). In fase di esecuzione, CLR (Common Languge Runtime) converte il codice MSIL in codice nativo con il compilatore JIT. Prima di convertire il codice MSIL è necessario superare un processo di verifica che esamina MSIL + MetaData (nome degli assiemi, versione, riferimenti): per scoprire se il codice può essere determinato come sicuro. se supera la verifica, MSIL viene convertito in codice nativo. Tutti i metodi chiamati vengono convertiti in linguaggio macchina e salvati nella cache per l'utilizzo successivo.