Esempio di assembly su più file

In questa sezione viene fornito un esempio completo che illustra i passaggi necessari per la creazione di un assembly su più file.

Passaggio 1 — 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 SDK.
Imports System
Namespace myStringer 
   Public Class Stringer
      Public Sub StringerMethod() 
         Console.WriteLine("This is a line from StringerMethod.")
      End Sub
   End Class
End Namespace
[C#]
// Assembly building example in the .NET Framework SDK.
using System;
namespace myStringer 
   {
   public 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
[C#]
csc /t:module Stringer.cs

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

Passaggio 2 — Compilazione di moduli contenenti riferimenti ad altri moduli

In questo passaggio viene utilizzata l'opzione di compilazione /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
   ' 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
[C#]
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();
   }
}

Per compilare il codice, utilizzare il comando seguente:

vbc /addmodule:Stringer.netmodule /t:module Client.vb
[C#]
csc /addmodule:Stringer.netmodule /t:module Client.cs

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. Un modulo denominato Client.netmodule, contenente un riferimento a un altro modulo, Stringer.netmodule, viene creato dal compilatore.

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

• Un assembly su due file viene creato da due compilazioni:

  vbc /t:module Stringer.vb
  vbc Client.vb /addmodule:Stringer.netmodule
  [C#]
  csc /t:module Stringer.cs
  csc Client.cs /addmodule:Stringer.netmodule
  

• Un assembly su due file viene creato da una compilazione:

  vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vb
  [C#]
  csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
  

Passaggio 3 — Creazione di un assembly su più file tramite Assembly Linker

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 comando seguente:

  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

Creazione degli assembly | Visualizzazione dei contenuti dell'assembly | Come il runtime individua gli assembly | Creazione di un assembly su più file