Compartilhar via

Como fazer para: Construir um assembly de múltiplos arquivos

Observação

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 exemplos de código que ilustram cada etapa do procedimento.

Observação

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

Criar um assembly de vários arquivos

  1. 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

  2. Use o seguinte comando para compilar este código:

    cl /clr:pure /LN Stringer.cpp

    csc /t:module Stringer.cs

    vbc /t:module Stringer.vb

    Especificar o parâmetro do módulo com a opção /t: do compilador 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.

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

    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

  4. Use o seguinte comando para compilar este 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 no Cliente 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.

    Observação

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

    Duas compilações criam uma assemblagem 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 gera um assembly composto por 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

  5. Utilize 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 seguinte comando:

    al < nome do módulo>< nome do módulonome do módulo> … /main: < nome do método>/out:<nome do arquivo>/target:<assembly file type>

    Nesse comando, os argumentos de nome do módulo especificam o nome de cada módulo a ser incluído no assembly. A /main: opção especifica o nome do método que é o ponto de entrada do assembly. A /out: opção especifica o nome do arquivo de saída, que contém metadados de assembly. A /target: opção especifica que o assembly é um arquivo executável do aplicativo de console (.exe), 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 método Main na classe MainClientApp, localizada em Client.dll.

    al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe

    Você pode usar IL Disassembler (Ildasm.exe) para examinar o conteúdo de um assembly ou determinar se um arquivo é um assembly ou um módulo.

Consulte também

  • Last updated on