Como: Criar um Assembly multi-arquivos

Essa seção descreve os procedimentos usados para criar um assembly de múltiplos arquivos e fornece um exemplo completo que mostra cada passo do procedimento.

Para criar um assembly de arquivos múltiplos

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 os módulos de código é netmodule. Por exemplo, se um arquivo chamado Stringer criar um namespace chamado myStringer mencionado no código do arquivo do cliente, Stringer deve ser compilado primeiro em um módulo de código.

2. Compile todos os outros módulos uando as opções de compilador necessárias para indicar os outros módulos que são referenciados no código.

3. Use o Assembly Linker (Al.exe) para criar o arquivo de saída que contém a manifesto do assembly. Este arquivo contém informação de referência para todos os módulos ou recursos que são parte do assembly.

   Observação

   O Visual Studio 2005 IDE para C# e Visual Basic só pode ser usado para criar assemblies de arquivo único.Se você quiser criar assemblies de arquivos múltiplos, você deve usar compiladores de linha de comando ou Visual Studio 2005 para Visual C++.

O exemplo a seguir ilustra o passo 1 do procedimento acima, compilando arquivos com namespaces referenciados por outros arquivos. Este exemplo começa com alguns códigos simples para o Stringer arquivo. Stringertem um namespace chamado myStringer com 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.
Imports System

Namespace myStringer
    Public Class Stringer
        Public Sub StringerMethod()
            System.Console.WriteLine("This is a line from StringerMethod.")
        End Sub
    End Class
End Namespace

// 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.
using namespace System;

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

Use o seguinte comando para compilar esse código:

vbc /t:module Stringer.vb

csc /t:module Stringer.cs

cl /clr:pure /LN Stringer.cpp

Especificando a módulo de parâmetro com o /t: opção de compilador indica que o arquivo deve ser compilado como um módulo, em vez de fazê-lo como um assembly. O compilador produz um módulo chamado Stringer.netmodule, que pode ser adicionado a um conjunto de módulos (assembly).

No passo dois do procedimento acima, você deve compilar módulos com referências a outros módulos. Esta etapa usa a opção de compilador /addmodule. No exemplo a seguir, um módulo de código chamado Client possui um método de ponto de entrada Main que referencia um método no módulo Stringer.dll criado na etapa 1.

O exemplo a seguir mostra o código para Client.

Imports System
Imports myStringer 'The namespace created in Stringer.netmodule.

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

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

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();
    }
}

#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();
}

Use o seguinte comando para compilar esse código:

vbc /addmodule:Stringer.netmodule /t:module Client.vb

csc /addmodule:Stringer.netmodule /t:module Client.cs

cl /clr:pure /FUStringer.netmodule /LN Client.cpp

Especifique a opção /t:Module porque este módulo irá ser adicionado a um conjunto de módulos (assembly) em uma etapa futura. Especifique a opção /addmodule porque o código Client referencia um namespace criado pelo código na Stringer.netmodule. O compilador produz um módulo chamado Client.netmodule que contém uma referência para outro módulo, Stringer.netmodule.

• Two compilations create a two-file assembly:

vbc /t:module Stringer.vb
vbc Client.vb /addmodule:Stringer.netmodule

csc /t:module Stringer.cs
csc Client.cs /addmodule:Stringer.netmodule

cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule

• Uma compilação cria um conjunto de dois arquivos:

vbc /out:Client.exe Client.vb /out:Stringer.netmodule Stringer.vb

csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs

cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule

Você pode usar o Assembly Linker (Al.exe) para criar um conjunto de módulos (assembly) de uma coleção de módulos de código compilado.

Para criar um conjunto de módulos (assembly) usando o Assembly Linker

• No prompt de comando, digite o seguinte comando:

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

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

No exemplo a seguir, Al.exe cria um conjunto que é um aplicativo executável de console chamado myAssembly.exe. O aplicativo consiste de dois módulos chamados Client.netmodule e Stringer.netmodule e o arquivo executável chamado myAssembly.exe, que contém somente metadados do assembly. O ponto de entrada do conjunto é o método Main na classe MainClientApp, que está localizado na Client.dll.

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

Você pode usar o MSIL Disassembler (ildasm.exe) para examinar o conteúdo de um conjunto de módulos (assembly), ou determinar se um arquivo é um conjunto ou um módulo.

Consulte também

Tarefas

Como: Exibir o conteúdo do Assembly

Conceitos

Criando assemblies

Como o Runtime Localiza Assemblies

Assembly de Arquivos Múltiplos