Procedura: compilare un assembly su più file

Articolo
08/11/2011

In questa sezione viene descritta la procedura utilizzata per creare un assembly su più file, corredata di un esempio completo in cui sono illustrati tutti i passaggi.

Per creare un assembly su più file

Compilare in moduli di codice tutti i file contenenti spazi dei nomi a cui fanno riferimento altri moduli dell'assembly. L'estensione predefinita per i moduli di codice è netmodule. Se ad esempio un file denominato Stringer crea uno spazio dei nomi denominato myStringer a cui si fa riferimento nel codice del file Client, sarà innanzitutto necessario compilare Stringer in un modulo di codice.
Compilare tutti gli altri moduli, utilizzando le opzioni di compilatore necessarie per indicare gli altri moduli a cui si fa riferimento nel codice.

Utilizzare l'utilità Assembly Linker (Al.exe) per creare un file di output contenente il manifesto dell'assembly. In questo file sono contenute informazioni di riferimento per tutti i moduli o le risorse che fanno parte dell'assembly.

Nota
È possibile utilizzare l'IDE di Visual Studio 2005 per C# e Visual Basic solo per la creazione di assembly su singolo file.Per creare assembly su più file, è necessario utilizzare i compilatori da riga di comando o Visual Studio 2005 con Visual C++.

Nell'esempio riportato di seguito viene illustrato il passaggio 1 della procedura sopra indicata, mediante la compilazione di file con spazi dei nomi a cui fanno riferimento altri file. Questo esempio ha inizio con un semplice blocco di codice per il file Stringer. Stringer presenta uno spazio dei nomi myStringer con una classe denominata Stringer. Nella classe Stringer è disponibile un metodo denominato StringerMethod, che consente di scrivere una singola riga nella 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.");
        }
    };
}

Per compilare il codice, utilizzare il comando seguente:

vbc /t:module Stringer.vb

csc /t:module Stringer.cs

cl /clr:pure /LN Stringer.cpp

Specificando il parametro module con l'opzione di compilatore /t: si indica che è necessario compilare il file come modulo anziché come assembly. Il compilatore crea un modulo denominato Stringer.netmodule, che può essere aggiunto a un assembly.

Nel passaggio due della procedura è necessario compilare i moduli con riferimenti ad altri moduli. In questo passaggio viene utilizzata l'opzione del compilatore /addmodule. Nell'esempio riportato di seguito un modulo di codice denominato Client dispone di un metodo di punto di ingresso Main contenente riferimenti a un metodo del modulo Stringer.dll creato nel passaggio 1.

Nell'esempio seguente viene mostrato il codice per 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();
}

Per compilare il codice, utilizzare il comando seguente:

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

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

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

Specificare l'opzione /t:module, poiché tale modulo verrà aggiunto a un assembly in un passaggio successivo. Specificare l'opzione /addmodule poiché nel codice di Client sono presenti riferimenti allo spazio dei nomi creato dal codice in Stringer.netmodule. Il compilatore crea un modulo denominato Client.netmodule contenente un riferimento a un altro modulo, Stringer.netmodule.

Nota
Nei compilatori di C# e di Visual Basic viene supportata la creazione diretta di assembly su più file utilizzando le due diverse sintassi descritte di seguito.

Un assembly su due file viene creato da due compilazioni:

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

Un assembly su due file viene creato da una compilazione:

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

Per creare un assembly da un insieme di moduli di codice compilati, è possibile utilizzare Assembly Linker (Al.exe).

Per creare un assembly su più file tramite Assembly Linker

Al prompt dei comandi digitare il seguente comando:

al <nome modulo> <nome modulo> … /main:<nome metodo> /out:<nome file> /target:<tipo file di assembly>

Gli argomenti nome modulo di questo comando consentono di specificare il nome di ogni modulo da includere nell'assembly. L'opzione /main: consente di specificare il nome del metodo che corrisponde al punto di ingresso dell'assembly. L'opzione /out: consente di specificare il nome del file di output, contenente i metadati dell'assembly. L'opzione /target: consente di specificare che l'assembly è un file eseguibile (EXE) da console, un file eseguibile di Windows (WIN) o una libreria (LIB).

Nell'esempio seguente l'utilità Al.exe consente di creare un assembly denominato myAssembly.exe, che corrisponde al file eseguibile da console. L'applicazione è costituita da due moduli denominati Client.netmodule e Stringer.netmodule e dal file eseguibile denominato myAssembly.exe, contenente solo i metadati dell'assembly. Il punto di ingresso dell'assembly è costituito dal metodo Main della classe MainClientApp, situata nel file Client.dll.

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

È possibile utilizzare MSIL Disassembler (Ildasm.exe) per esaminare i contenuti di un assembly o determinare se un file sia un assembly o un modulo.

Vedere anche

Attività

Procedura: visualizzare il contenuto dell'assembly

Concetti

Creazione degli assembly

Come il runtime individua gli assembly

Assembly su più file

Condividi tramite