Partilhar via


Assemblies no .NET

As assemblies são as unidades fundamentais de implantação, controle de versão, reutilização, escopo de ativação e permissões de segurança para aplicações baseadas em .NET. Uma assemblagem é uma coleção de tipos e recursos que são criados para funcionar em conjunto e formar uma unidade lógica de funcionalidade. Os assemblies assumem a forma de arquivos executáveis (.exe) ou de biblioteca de vínculo dinâmico (.dll) e são os blocos de construção de aplicativos .NET. Eles fornecem ao Common Language Runtime as informações de que ele precisa estar ciente das implementações de tipo.

No .NET e .NET Framework, você pode criar um assembly a partir de um ou mais arquivos de código-fonte. No .NET Framework, assemblies podem conter um ou mais módulos. Dessa forma, projetos maiores podem ser planejados para que vários desenvolvedores possam trabalhar em arquivos ou módulos de código-fonte separados, que são combinados para criar um único assembly. Para obter mais informações sobre módulos, consulte Como criar um assembly multiarquivo.

As assemblagens têm as seguintes propriedades:

  • As assemblies são implementadas como ficheiros.exe ou .dll.

  • Para bibliotecas destinadas ao .NET Framework, você pode compartilhar assemblies entre aplicativos colocando-os no cache de assembly global (GAC). Você deve nomear fortemente assemblies antes de poder incluí-los no GAC. Para obter mais informações, consulte Assemblies de nome forte.

  • As assemblies só são carregadas na memória se forem necessárias. Se não forem usados, não estão carregados. Portanto, os conjuntos podem ser uma maneira eficiente de gerir recursos em projetos maiores.

  • Você pode obter informações sobre um assembly através de programação, usando reflection. Para obter mais informações, consulte Reflection (C#) ou Reflection (Visual Basic).

  • Você pode carregar um assembly apenas para inspecioná-lo usando a MetadataLoadContext classe no .NET e .NET Framework. MetadataLoadContext substitui os Assembly.ReflectionOnlyLoad métodos.

Assemblies no ambiente de execução comum

Os assemblies fornecem ao Common Language Runtime as informações necessárias para o conhecimento das implementações de tipo. Para o tempo de execução, um tipo não existe fora do contexto de um conjunto.

Uma assemblagem define as seguintes informações:

  • Código que o common language runtime executa. Cada montagem pode ter apenas um ponto de entrada: DllMain, WinMain, ou Main.

  • O limite de segurança. Um assembly é a unidade na qual as permissões são solicitadas e concedidas. Para obter mais informações sobre limites de segurança em assemblies, consulte Considerações de segurança do assembly.

  • O limite de tipo. A identidade de cada tipo inclui o nome do conjunto em que reside. Um tipo chamado MyType que é carregado no escopo de um assembly não é o mesmo que um tipo chamado MyType que é carregado no escopo de outro assembly.

  • O limite de escopo de referência: o manifesto do assembly tem metadados que são usados para resolver tipos e satisfazer solicitações de recursos. O manifesto especifica os tipos e recursos a serem expostos fora do assembly e enumera outros assemblies dos quais ele depende. O código Common Intermediate Language (CIL) em um arquivo executável portátil (PE) não será executado a menos que tenha um manifesto de assembly associado.

  • O limite da versão. O assembly é a menor unidade versionável no common language runtime. Todos os tipos e recursos no mesmo assembly são versionados como uma unidade. O assembly manifesto descreve as dependências de versão que você especifica para quaisquer assemblies dependentes. Para obter mais informações sobre versionamento, consulte Versionamento de assembly.

  • A unidade de implantação: quando um aplicativo é iniciado, somente os assemblies que o aplicativo chama inicialmente devem estar presentes. Outros conjuntos, como aqueles que contêm recursos de localização ou classes utilitárias, podem ser recuperados conforme necessário. Esse processo permite que os aplicativos sejam simples e finos quando baixados pela primeira vez. Para obter mais informações sobre como implantar assemblies, consulte Implantar aplicativos.

  • Uma unidade de execução lado a lado: Para obter mais informações sobre como executar várias versões de um assembly, consulte Assemblies e execução lado a lado.

Criar uma assemblagem

As montagens podem ser estáticas ou dinâmicas. Os assemblies estáticos são armazenados em um disco em arquivos executáveis portáteis (PE). As assemblies estáticas podem incluir interfaces, classes e recursos como bitmaps, ficheiros JPEG e outros ficheiros de recursos. Você também pode criar assemblies dinâmicos, que são executados diretamente da memória e não são salvos no disco antes da execução. Você pode salvar assemblies dinâmicos em disco depois que eles forem executados.

Existem várias formas de criar conjuntos. Você pode usar ferramentas de desenvolvimento, como o Visual Studio, que pode criar arquivos .dll ou .exe . Você pode usar ferramentas no SDK do Windows para criar assemblies com módulos de outros ambientes de desenvolvimento. Você também pode usar as APIs do Common Language Runtime, como System.Reflection.Emit, para gerar assemblies dinâmicos.

Compile assemblies criando-os no Visual Studio, criando-os com ferramentas de interface de linha de comando do .NET Core ou criando assemblies do .NET Framework com um compilador de linha de comando. Para obter mais informações sobre como criar assemblies usando a CLI do .NET, consulte Visão geral da CLI do .NET.

Observação

Para criar um assembly no Visual Studio, no menu Build , selecione Build.

Manifesto da assembleia

Cada assemblagem tem um ficheiro de manifesto de assemblagem. Semelhante a um índice, o manifesto de montagem contém:

  • A identidade do assembly (seu nome e versão).

  • Uma tabela de arquivos que descreve todos os outros ficheiros que constituem o assembly, como outros assemblies que você criou e dos quais o seu ficheiro .exe ou .dll depende, ficheiros bitmap ou ficheiros de informação.

  • Uma lista de referências de montagem, que é uma lista de todas as dependências externas, como .dlls ou outros arquivos. As referências de assembly contêm referências a objetos tanto globais quanto privados. Os objetos globais estão disponíveis para todos os outros aplicativos. No .NET Core, os objetos globais são acoplados a um tempo de execução específico do .NET Core. No .NET Framework, os objetos globais residem na cache de assembleia global (GAC). System.IO.dll é um exemplo de uma assembleia no GAC. Os objetos particulares devem estar em um nível de diretório igual ou inferior ao diretório no qual seu aplicativo está instalado.

Os assemblies contêm informações sobre conteúdo, controle de versão e dependências. Assim, os aplicativos que os usam não precisam depender de fontes externas, como o registro em sistemas Windows, para funcionar corretamente. Os assemblies reduzem .dll conflitos e tornam seus aplicativos mais confiáveis e fáceis de implantar. Em muitos casos, pode instalar uma aplicação baseada em .NET simplesmente ao copiar os seus ficheiros para o computador de destino. Para obter mais informações, consulte Manifesto de conjunto.

Adicionar uma referência a um assembly

Para usar um assembly em um aplicativo, você deve adicionar uma referência a ele. Quando um assembly é referenciado, todos os tipos, propriedades, métodos e outros membros acessíveis de seus namespaces estão disponíveis para seu aplicativo como se o código deles fizesse parte do arquivo de origem.

Observação

A maioria dos assemblies da biblioteca de classes .NET são referenciados automaticamente. Se um assembly do sistema não for referenciado automaticamente, adicione uma referência através de uma das seguintes opções:

  • Para .NET e .NET Core, adicione uma referência ao pacote NuGet que contém a biblioteca. Use o Gerenciador de Pacotes NuGet no Visual Studio ou adicione um <elemento PackageReference> para o assembly ao projeto .csproj ou .vbproj .
  • Para o .NET Framework, adicione uma referência ao assembly usando a caixa de diálogo Adicionar referência no Visual Studio ou a opção de linha de comando para os compiladores de -reference ou Visual Basic.

Em C#, você pode usar duas versões do mesmo assembly em um único aplicativo. Para obter mais informações, consulte alias externos.

Título Descrição
Conteúdo da montagem Elementos que compõem uma montagem.
Manifesto da assembleia Dados no manifesto de assemblagem e como são armazenados em assemblagens.
Global Assembly Cache Como o GAC armazena e usa montagens.
Assembléias com nomes fortes Características das assembléias de nome forte.
Considerações de segurança de montagem Como funciona a segurança com assemblies.
Controle de versão do assembly Visão geral da política de controle de versão do .NET Framework.
Colocação de montagem Onde localizar montagens.
Montagens e execução lado a lado Use várias versões do ambiente de execução e/ou um assembly simultaneamente.
Emitir métodos dinâmicos e montagens Como criar compilações dinâmicas.
Como o tempo de execução localiza assembleias Como o .NET Framework resolve referências de assembly em tempo de execução.

Referência

System.Reflection.Assembly

Ver também