Como: Criar um assembly multifile

Artigo
06/04/2024

Nota

Este artigo é específico do .NET Framework. Ele não se aplica a implementações mais recentes do .NET, incluindo o .NET 6 e versões posteriores.

Este artigo explica como criar um assembly multifile e fornece código que ilustra cada etapa do procedimento.

Nota

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

Criar um assembly multiarquivo

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

Por exemplo, digamos que o Stringer arquivo tenha um namespace chamado myStringer, que inclui uma classe chamada Stringer. A Stringer classe 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 seguinte comando 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 de compilador /t: indica que o arquivo deve ser compilado como um módulo e não 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 necessárias do compilador para indicar os outros módulos que são referenciados no código. Esta etapa usa a opção de compilador /addmodule .

No exemplo a seguir, um módulo de código chamado Client tem um método de ponto Main 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 seguinte comando 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 faz referência a 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.
Nota

Os compiladores C# e Visual Basic suportam diretamente a criação de assemblies multifile 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. Este arquivo contém informações de referência para todos os módulos ou recursos que fazem parte do assembly.

Na linha de comandos, escreva o seguinte comando:

al<nome<>do módulo nome> do módulo ... /main:<nome> do método/saída:<nome> do arquivo/destino:<tipo de arquivo assembly>

Neste comando, os argumentos de nome de 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 de assembly. A opção /target: especifica que o assembly é um arquivo executável (.exe) do aplicativo de console, um arquivo executável do Windows (.win) ou um arquivo de biblioteca (.lib).

No exemplo a seguir, 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 de assembly. O ponto de entrada do assembly é o Main método 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 IL Disassembler (Ildasm.exe) para examinar o conteúdo de um assembly ou determinar se um arquivo é um assembly ou um módulo.

Partilhar via

Como: Criar um assembly multifile

Criar um assembly multiarquivo

Consulte também

Comentários

Recursos adicionais