O que são assemblies .NET?

O que são assemblies .NET? Naveguei pela rede e não consigo entender a definição.

Em termos mais simples: um pedaço de código (pré-compilado) que pode ser executado pelo ambiente de tempo de execução do .NET. Um programa .NET consiste em um ou mais assemblies.

Assembly é a menor unidade de implantação de um aplicativo .net. Pode ser uma DLL ou um exe .
Existem principalmente dois tipos:

1. Assembléia particular: a dll ou exe que é propriedade exclusiva de apenas um aplicativo. Geralmente é armazenado na pasta raiz do aplicativo

2. Conjunto público / compartilhado: é uma dll que pode ser usada por vários aplicativos ao mesmo tempo. Um assembly compartilhado é armazenado no GAC, ou seja, Global Assembly Cache .

Parece difícil? Naa .... O
GAC é simplesmente a pasta C: \ Windows \ Assembly, onde você pode encontrar as assembléias / dlls públicas de todos os softwares instalados no seu PC.

Há também um terceiro e menos conhecido tipo de montagem: Montagem de Satélite .
Um conjunto de satélites contém apenas objetos estáticos, como imagens e outros arquivos não executáveis, exigidos pelo aplicativo.

Espero que isso ajude os leitores!

Assembléias

Quando você compila um aplicativo, o código MSIL criado é armazenado em um assembly. Os assemblies incluem arquivos de aplicativos executáveis ​​que você pode executar diretamente do Windows sem a necessidade de outros programas (eles têm uma extensão de arquivo .exe) e bibliotecas (que possuem uma extensão .dll) para uso por outros aplicativos.

Além de conter o MSIL, os assemblies também incluem metainformações (ou seja, informações sobre as informações contidas no assembly, também conhecidas como metadados) e recursos opcionais (dados adicionais usados ​​pelo MSIL, como arquivos de som e imagens). A meta-informação permite que as montagens sejam totalmente auto-descritivas. Você não precisa de outras informações para usar um assembly, o que significa que evita situações como falha na adição de dados necessários ao registro do sistema e assim por diante, o que geralmente era um problema ao se desenvolver com outras plataformas.

Isso significa que a implantação de aplicativos geralmente é tão simples quanto copiar os arquivos em um diretório em um computador remoto. Como nenhuma informação adicional é necessária nos sistemas de destino, você pode simplesmente executar um arquivo executável nesse diretório e (supondo que o .NET CLR esteja instalado), você estará pronto.

Obviamente, você não necessariamente incluirá tudo o que é necessário para executar um aplicativo em um único local. Você pode escrever algum código que execute tarefas exigidas por vários aplicativos. Em situações como essa, geralmente é útil colocar o código reutilizável em um local acessível a todos os aplicativos. No .NET Framework, este é o Global Assembly Cache (GAC). A colocação do código no GAC é simples - basta colocar o assembly que contém o código no diretório que contém esse cache.

Um assembly é o arquivo .dll real no disco rígido em que as classes no .NET Framework estão armazenadas. Por exemplo, todas as classes contidas no ASP.NET Framework estão localizadas em um assembly chamado System.Web.dll.

Mais precisamente, um assembly é a principal unidade de implantação, segurança e controle de versão no .NET Framework. Como um assembly pode abranger vários arquivos, um assembly geralmente é chamado de dll "lógica".

Nota

O .NET Framework (versão 2.0) inclui 51 assemblies.

Existem dois tipos de montagens: privada e compartilhada. Um assembly privado pode ser usado por apenas um único aplicativo. Um assembly compartilhado, por outro lado, pode ser usado por todos os aplicativos localizados no mesmo servidor.

Assemblies compartilhados estão localizados no Global Assembly Cache (GAC). Por exemplo, o assembly System.Web.dll e todos os outros assemblies incluídos no .NET Framework estão localizados no cache global de assemblies.

Nota

O Global Assembly Cache está localizado fisicamente na pasta \ WINDOWS \ Assembly do seu computador. Há uma cópia separada de cada assembly na sua pasta \ WINDOWS \ Microsoft.NET \ Framework \ v2.0.50727. O primeiro conjunto de montagens é usado em tempo de execução e o segundo conjunto é usado em tempo de compilação.

Antes de poder usar uma classe contida em uma montagem em seu aplicativo, você deve adicionar uma referência à montagem. Por padrão, um aplicativo ASP.NET faz referência aos assemblies mais comuns contidos no 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

Para usar qualquer classe específica no .NET Framework, você deve fazer duas coisas. Primeiro, seu aplicativo deve fazer referência à montagem que contém a classe. Segundo, seu aplicativo deve importar o espaço para nome associado à classe.

Na maioria dos casos, você não se preocupará em fazer referência à montagem necessária porque as montagens mais comuns são referenciadas automaticamente. No entanto, se você precisar usar uma montagem especializada, precisará adicionar uma referência explicitamente à montagem. Por exemplo, se você precisar interagir com o Active Directory usando as classes no espaço para nome System.DirectoryServices, será necessário adicionar uma referência ao assembly System.DirectoryServices.dll ao seu aplicativo.

Cada entrada de classe na documentação do .NET Framework SDK lista o assembly e o espaço para nome associado à classe. Por exemplo, se você procurar a classe MessageQueue na documentação, descobrirá que essa classe está localizada no espaço para nome System.Messaging, localizado no assembly System.Messaging.dll.

Se você estiver usando o Visual Web Developer, poderá adicionar uma referência a um assembly explicitamente, selecionando a opção de menu Site, Adicionar referência e selecionando o nome do assembly ao qual você precisa fazer referência. Por exemplo, adicionar uma referência ao assembly System.Messaging.dll faz com que o arquivo de configuração da Web na Listagem 1.4 seja adicionado ao seu aplicativo.

Por exemplo. Web.Config

enter code here

Se você preferir não usar o Visual Web Developer, adicione a referência ao assembly System.Messaging.dll criando o arquivo no exemplo acima manualmente

A Wikipedia tem a dizer:

Na estrutura Microsoft .NET, um assembly é uma biblioteca de códigos parcialmente compilada para uso na implantação, controle de versão e segurança. Existem dois tipos: assemblies de processo (EXE) e assemblies de biblioteca (DLL). Um assembly de processo representa um processo que usará as classes definidas nos assemblies de biblioteca. Os assemblies .NET contêm código no CIL, que geralmente é gerado a partir de uma linguagem CLI e, em seguida, compilado na linguagem de máquina em tempo de execução pelo compilador CLR just-in-time. Uma montagem pode consistir em um ou mais arquivos. Arquivos de código são chamados de módulos. Um assembly pode conter mais de um módulo de código e, como é possível usar idiomas diferentes para criar módulos de código, é tecnicamente possível usar vários idiomas diferentes para criar um assembly.

Se você realmente navegou, ajudaria se você esclarecesse o que não entende

Veja isto :

Na estrutura Microsoft .NET, um assembly é uma biblioteca de códigos parcialmente compilada para uso em implantação, controle de versão e segurança

coleção física de classe, interface, enumeração etc., que está no código IL. Que pode ser arquivo .EXE ou .DLL .EXE é um arquivo executável e .DLL pode ser usado dinamicamente em qualquer idioma .net com suporte.

Uma montagem é uma unidade de tempo de execução que consiste em tipos e outros recursos. Todos os tipos em uma montagem têm o mesmo número de versão.

Freqüentemente, um assembly possui apenas um namespace e é usado por um programa. Mas pode se estender por vários namespaces. Além disso, um espaço para nome pode se espalhar por vários assemblies. Em projetos grandes, uma montagem pode consistir em vários arquivos mantidos juntos por um manifesto (por exemplo, um sumário).

Em C #, um assembly é a menor implantação de um aplicativo .Net. Pode ser uma dll ou um exe. Ele tem dois tipos: 1. Assembléia Privada 2. Assembléia Pública / Compartilhada

Além da resposta aceita, quero dar um exemplo!

Por exemplo, todos nós usamos

System.Console.WriteLine()

Mas Onde está o código para System.Console.WriteLine !?
qual é o código que realmente coloca o texto no console?

Se você olhar a primeira página da documentação da classe Console , verá na parte superior o seguinte: Assembly: mscorlib (em mscorlib.dll) Isso indica que o código da classe Console está localizado em uma montagem chamado mscorlib. Um assembly pode consistir em vários arquivos, mas, nesse caso, é apenas um arquivo, que é a biblioteca de vínculo dinâmico mscorlib.dll.

O arquivo mscorlib.dll é muito importante no .NET, é a principal DLL para bibliotecas de classes no .NET e contém todas as classes e estruturas básicas do .NET.

se você conhece C ou C ++, geralmente precisa de uma diretiva #include na parte superior que faça referência a um arquivo de cabeçalho. O arquivo de inclusão fornece protótipos de função para o compilador. por outro lado O compilador C # não precisa de arquivos de cabeçalho. Durante a compilação, o compilador C # acessa o arquivo mscorlib.dll diretamente e obtém informações dos metadados desse arquivo sobre todas as classes e outros tipos definidos nele.

O compilador C # é capaz de estabelecer que o mscorlib.dll de fato contém uma classe chamada Console em um espaço para nome chamado System com um método chamado WriteLine que aceita um único argumento do tipo string.

O compilador C # pode determinar que a chamada WriteLine é válida e o compilador estabelece uma referência ao assembly mscorlib no executável.

por padrão O compilador C # acessará o mscorlib.dll, mas para outras DLLs, você precisará informar ao compilador o assembly no qual as classes estão localizadas. Estes são conhecidos como referências.

Espero que esteja claro agora!

Charles Pitzold, do DotNetBookZero

O MSDN tem uma boa explicação :

Assemblies são os blocos de construção de aplicativos .NET Framework; eles formam a unidade fundamental de implantação, controle de versão, reutilização, escopo de ativação e permissões de segurança. Um assembly é uma coleção de tipos e recursos criados para trabalhar juntos e formar uma unidade lógica de funcionalidade. Um assembly fornece ao Common Language Runtime as informações necessárias para conhecer as implementações de tipo. Para o tempo de execução, um tipo não existe fora do contexto de um assembly.

Um assembly é uma coleção de tipos e recursos que formam uma unidade lógica de funcionalidade. Todos os tipos no .NET Framework devem existir em assemblies; o Common Language Runtime não suporta tipos fora dos assemblies. Cada vez que você cria um Aplicativo Microsoft Windows®, Serviço Windows, Biblioteca de Classes ou outro aplicativo com o Visual Basic .NET, está criando um único assembly. Cada assembly é armazenado como um arquivo .exe ou .dll.

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

Para aqueles com experiência em Java como eu, espero que o diagrama a seguir esclareça conceitos -

Assemblies são como arquivos jar (contendo vários arquivos .class). Seu código pode fazer referência a um assembly existente ou o próprio código pode ser publicado como um assembly para outro código fazer referência e usar (você pode pensar isso como arquivos jar em Java que podem ser adicionados às dependências do projeto).

No final do dia, um assembly é um código compilado que pode ser executado em qualquer sistema operacional com o CLR instalado. É o mesmo que dizer que o arquivo .class ou o jar empacotado pode ser executado em qualquer máquina com a JVM instalada.

No .Net, um assembly pode ser:

Uma colecção de diferentes administráveis partes contendo Types (or Classes), Resources (Bitmaps/Images/Strings/Files), Namespaces, Config Filescompilado Privatelyou Publicly; implantado em uma pasta localou Shared (GAC); discover-ablepor outro programs/assembliese; pode ser versão-ed.

Como o assembly é a menor unidade de segurança de versão, implantação e reutilização de código no Microsoft.Net.

Contém:

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

Assembly é a parte fundamental da programação com o .NET Framework. Ele contém o código que o CLR executa o código MSIL (Microsoft Intermediate Language) em um arquivo executável portátil não será executado se não tiver um manifesto de assembly associado.

Os aplicativos .NET são construídos reunindo qualquer número de montagens. Simplificando, um assembly nada mais é do que um binário auto-descrito e com versão (DLL ou EXE) que contém algumas coleções de tipos (classes, interfaces, estruturas etc.) e recursos opcionais (imagens, tabelas de strings e outros enfeites). Uma coisa a ser dolorosamente ciente agora é que a organização interna de um assembly .NET não se parece com a organização interna de um servidor COM clássico (independentemente das extensões de arquivo compartilhadas).

No .NET, quando compilamos nosso código-fonte, o assembly é gerado no Visual Studio. Assembly consiste em duas partes Manifest e IL (Intermediate Language). O manifesto contém metadados da montagem, os requisitos de versão, a identidade de segurança, os nomes e os hashes de todos os arquivos que compõem a montagem. IL contém informações sobre classes, construtores, método principal etc.

Achei este link muito útil. Ele ainda dá uma idéia de como a IL desempenha um papel no .NET.

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

As soluções do Visual Studio consistem em um ou mais projetos. Por exemplo: os projetos do console podem produzir um montagem . Um assembly é logicamente um pedaço de código que pode ser enviado aos clientes e fisicamente um .EXE (programa executável) ou .DLL (são reutilizáveis ​​por outros programas).