Como: criar um assembly de vários arquivos

Artigo
05/10/2023

Este artigo explica como criar um assembly de vários arquivos e fornece código que ilustra cada etapa no procedimento.

Observação

O IDE do Visual Studio para C# e Visual Basic pode ser usado apenas para criar assemblies de arquivo único. Se quiser criar assemblies de vários arquivos, você precisará usar os compiladores de linha de comando ou Visual Studio com o Visual C++. Os assemblies multifile são compatíveis apenas com .NET Framework.

Criar um assembly de vários arquivos

Compile todos os arquivos que contêm namespaces referenciados por outros módulos no assembly nos módulos de código. A extensão padrão para módulos de código é .netmodule.

Por exemplo, digamos que o arquivo Stringer tem um namespace chamado myStringer, que inclui uma classe chamada Stringer. A classe Stringer contém um método chamado StringerMethod que grava uma única linha no console.

// Assembly building example in the .NET Framework.
using namespace System;

namespace myStringer
{
    public ref class Stringer
    {
    public:
        void StringerMethod()
        {
            System::Console::WriteLine("This is a line from StringerMethod.");
        }
    };
}

// Assembly building example in the .NET Framework.
using System;

namespace myStringer
{
    public class Stringer
    {
        public void StringerMethod()
        {
            System.Console.WriteLine("This is a line from StringerMethod.");
        }
    }
}

' Assembly building example in the .NET Framework.
Namespace myStringer
    Public Class Stringer
        Public Sub StringerMethod()
            System.Console.WriteLine("This is a line from StringerMethod.")
        End Sub
    End Class
End Namespace

Use o comando a seguir para compilar esse código:
```
cl /clr:pure /LN Stringer.cpp
```
```
csc /t:module Stringer.cs
```
```
vbc /t:module Stringer.vb
```
Especificar o parâmetro module com a opção do compilador /t: indica que o arquivo deve ser compilado como um módulo em vez de como um assembly. O compilador produz um módulo chamado Stringer.netmodule, que pode ser adicionado a um assembly.

Compile todos os outros módulos, usando as opções do compilador necessárias para indicar os outros módulos que são referenciados no código. Esta etapa usa a opção do compilador /addmodule.

No exemplo a seguir, um módulo de código chamado Cliente possui um método Main de ponto de entrada que faz referência a um método no módulo Stringer.netmodule criado na etapa 1.

#using "Stringer.netmodule"

using namespace System;
using namespace myStringer; //The namespace created in Stringer.netmodule.

ref class MainClientApp
{
    // Static method Main is the entry point method.
public:
    static void Main()
    {
        Stringer^ myStringInstance = gcnew Stringer();
        Console::WriteLine("Client code executes");
        myStringInstance->StringerMethod();
    }
};

int main()
{
    MainClientApp::Main();
}

using System;
using myStringer;

class MainClientApp
{
    // Static method Main is the entry point method.
    public static void Main()
    {
        Stringer myStringInstance = new Stringer();
        Console.WriteLine("Client code executes");
        myStringInstance.StringerMethod();
    }
}

Imports myStringer

Class MainClientApp
    ' Static method Main is the entry point method.
    Public Shared Sub Main()
        Dim myStringInstance As New Stringer()
        Console.WriteLine("Client code executes")
        myStringInstance.StringerMethod()
    End Sub
End Class

Use o comando a seguir para compilar esse código:
```
cl /clr:pure /FUStringer.netmodule /LN Client.cpp
```
```
csc /addmodule:Stringer.netmodule /t:module Client.cs
```
```
vbc /addmodule:Stringer.netmodule /t:module Client.vb
```
Especifique a opção /t:module porque este módulo será adicionado a um assembly em uma etapa futura. Especifique a opção /addmodule porque o código em Client referencia um namespace criado pelo código em Stringer.netmodule. O compilador produz um módulo chamado Client.netmodule que contém uma referência a outro módulo, Stringer.netmodule.
Observação

Os compiladores C# e Visual Basic dão suporte à criação de assemblies de vários arquivos diretamente usando as duas sintaxes diferentes a seguir.

Duas compilações criam um assembly de dois arquivos:
```
cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule
```
```
csc /t:module Stringer.cs
csc Client.cs /addmodule:Stringer.netmodule
```
```
vbc /t:module Stringer.vb
vbc Client.vb /addmodule:Stringer.netmodule
```
Uma compilação cria um assembly de dois arquivos:
```
cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule
```
```
csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
```
```
vbc /out:Client.exe Client.vb /out:Stringer.netmodule Stringer.vb
```
Use o Assembly Linker (Al.exe) para criar o arquivo de saída que contém o manifesto do assembly. Esse arquivo contém informações de referência para todos os módulos ou recursos que fazem parte do assembly.

No prompt de comando, digite o comando a seguir:

al<nome do módulo><nome do módulo> … /main:<nome do método>/out:<nome de arquivo>/target:<tipo de arquivo do assembly>

Neste comando, os argumentos nome do módulo especificam o nome de cada módulo a ser incluído no assembly. A opção /main: especifica o nome do método que é o ponto de entrada do assembly. A opção /out: especifica o nome do arquivo de saída, que contém metadados do assembly. A opção /target: especifica que o assembly está em um arquivo executável de aplicativo de console (.exe), um arquivo executável do Windows (.win) ou um arquivo de biblioteca (.lib).

No exemplo a seguir, o Al.exe cria um assembly que é um executável de aplicativo de console chamado myAssembly.exe. O aplicativo consiste em dois módulos chamados Client.netmodule e Stringer.netmodule e o arquivo executável chamado myAssembly.exe que contém apenas metadados do assembly. O ponto de entrada do assembly é o método Main na classe MainClientApp, que está localizado em Client.dll.
```
al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe
```
Você pode usar o Desmontador IL (Ildasm.exe) para examinar o conteúdo de um assembly ou determinar se um arquivo é um assembly ou um módulo.

Como: criar um assembly de vários arquivos

Criar um assembly de vários arquivos

Confira também

Comentários

Recursos adicionais