Procedura: compilare un assembly multifile

Articolo
03/18/2024

In questo articolo viene illustrato come creare un assembly su più file e viene visualizzato il codice che illustra ogni passaggio della procedura.

Nota

L'IDE di Visual Studio per C# e Visual Basic può essere utilizzato esclusivamente per creare assembly su singolo file. Per creare assembly su più file, è necessario utilizzare i compilatori della riga di comando o Visual Studio con Visual C++. Gli assembly multifile sono supportati solo da .NET Framework.

Creare un assembly multifile

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.

Si supponga, ad esempio, che il file Stringer abbia uno spazio dei nomi denominato myStringer, che include 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.
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

Per compilare il codice, utilizzare il comando seguente:
```
cl /clr:pure /LN Stringer.cpp
```
```
csc /t:module Stringer.cs
```
```
vbc /t:module Stringer.vb
```
Specificando il parametro module con l'opzione del compilatore /t: si indica che è necessario compilare il file come modulo anziché come assembly. Il compilatore produce un modulo denominato Stringer.netmodule, che può essere aggiunto a un assembly.

Compilare tutti gli altri moduli, utilizzando le opzioni di compilatore necessarie per indicare gli altri moduli a cui si fa riferimento nel codice. Questo passaggio usa l'opzione del compilatore /addmodule.

Nell'esempio seguente un modulo di codice denominato Client contiene un metodo Main del punto di ingresso che fa riferimento a un metodo nel modulo Stringer.netmodule creato nel passaggio 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

Per compilare il codice, utilizzare il comando seguente:
```
cl /clr:pure /FUStringer.netmodule /LN Client.cpp
```
```
csc /addmodule:Stringer.netmodule /t:module Client.cs
```
```
vbc /addmodule:Stringer.netmodule /t:module Client.vb
```
Specificare l'opzione /t:module poiché il modulo verrà aggiunto a un assembly in un passaggio successivo. Specificare l'opzione /addmodule poiché il codice in Client fa riferimento a uno spazio dei nomi creato dal codice in Stringer.netmodule. Il compilatore genera un modulo denominato Client.netmodule che contiene 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:
```
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
```
Un assembly su due file viene creato da una compilazione:
```
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
```
Usare Assembly Linker (Al.exe) per creare il 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.

Al prompt dei comandi digitare quanto segue:

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

In questo comando gli argomenti nome modulo specificano il nome di ogni modulo da includere nell'assembly. L'opzione /main: specifica il nome del metodo che corrisponde al punto di ingresso dell'assembly. L'opzione /out: specifica il nome del file di output che contiene i metadati dell'assembly. L'opzione /target: specifica che l'assembly è un file eseguibile dell'applicazione console (.exe), un file eseguibile di Windows (.win) o una libreria (.lib).

Nell'esempio seguente Al.exe crea un assembly che è un eseguibile dell'applicazione console denominato myAssembly.exe. L'applicazione è costituita da due moduli denominati Client.netmodule e Stringer.netmodulee 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, che si trova in Client.dll.
```
al Client.netmodule Stringer.netmodule /main:MainClientApp.Main /out:myAssembly.exe /target:exe
```
È possibile usare il Disassemblatore del linguaggio intermedio (Ildasm.exe) per esaminare i contenuti di un assembly o determinare se un file è un assembly o un modulo.

Procedura: compilare un assembly multifile

Creare un assembly multifile

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive