Como: Criar um assembly multi-arquivos
Esta seção descreve o procedimento usado para criar um assembly de múltiplos arquivos e fornece um exemplo completo que ilustra cada uma das etapas do procedimento.
Para criar um assembly de arquivos múltiplos
Compile todos os arquivos que contenham 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.
Compile todos os outros módulos, usando as opções necessárias do compilador para indicar os outros módulos mencionados no código.
Use o Assembly Linker (Al.exe) para criar o arquivo de saída que contém a manifesto do assembly.Esse arquivo contém informações de referência para todos os módulos ou recursos que fazem parte do conjunto.
.gif "Observação")
Observação:O Visual Studio 2005 O IDE para translation from VPE for Csharp 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 a etapa 1 do procedimento acima, ao compilar os arquivos com namespaces referenciados por outros arquivos.Este exemplo começa com alguns códigos simples para o Stringer arquivo. Stringer tenha 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()
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.");
}
}
}
Use o seguinte comando para compilar este código:
vbc /t:module Stringer.vb
csc /t:module Stringer.cs
Especificando o módulo parâmetro a / t: opção do compilador indica que o arquivo deve ser compilado sistema autônomo um módulo em vez de um assembly.O compilador produz um módulo chamado Stringer. netmodule, which can be added to an assembly.
Na etapa 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
' Shared method Main is the entry point method.
Public Shared Sub Main()
Dim myStringInstance As New Stringer()
Console.WriteLine("Client code executes")
'myStringComp.Stringer()
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");
//myStringComp.Stringer();
myStringInstance.StringerMethod();
}
}
Use o seguinte comando para compilar este código:
vbc /addmodule:Stringer.netmodule /t:module Client.vb
csc /addmodule:Stringer.netmodule /t:module Client.cs
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 o /addmodule opção 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 that contains a reference to another module, Stringer. netmodule.
| Observação: |
|---|
O C# e Visual Basic compiladores suportam diretamente a criação de vários arquivos conjuntos de módulos (assemblies) usando as seguintes dois diferentes sintaxes. |
Two compilations create a two-file assembly:
vbc /t:module Stringer.vb vbc Client.vb /addmodule:Stringer.netmodulecsc /t:module Stringer.cs csc Client.cs /addmodule:Stringer.netmoduleUma compilação cria um conjunto de dois arquivos:
vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vbcsc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
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.The / principal: opção especifica o nome do método que é o ponto de entrada do assembly.The /out: opção especifica o nome do arquivo de saída, que contém metadados do assembly.The / destino: 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 em dois módulos chamados Client. netmodule and Stringer. netmodule, and the executable file called myAssembly.exe, which contains only assembly metadata .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 Sumário do assembly