Procedura: Compilare un assembly con più fileHow to: Build a Multifile Assembly

In questo articolo viene illustrato come creare un assembly su più file e viene visualizzato il codice che illustra ogni passaggio della procedura.This article explains how to create a multifile assembly and provides code that illustrates each step in the procedure.

Nota

L'IDE di Visual Studio per C# e Visual Basic può essere utilizzato esclusivamente per creare assembly su singolo file.The Visual Studio IDE for C# and Visual Basic can only be used to create single-file assemblies. Per creare assembly su più file, è necessario utilizzare i compilatori della riga di comando o Visual Studio con Visual C++.If you want to create multifile assemblies, you must use the command-line compilers or Visual Studio with Visual C++.

Per creare un assembly su più fileTo create a multifile assembly

  1. Compilare in moduli di codice tutti i file contenenti spazi dei nomi a cui fanno riferimento altri moduli dell'assembly.Compile all files that contain namespaces referenced by other modules in the assembly into code modules. L'estensione predefinita per i moduli di codice è .netmodule.The default extension for code modules is .netmodule.

    Si supponga, ad esempio, che il file Stringer abbia uno spazio dei nomi denominato myStringer, che include una classe denominata Stringer.For example, let's say the Stringer file has a namespace called myStringer, which includes a class called Stringer. Nella classe Stringer è disponibile un metodo denominato StringerMethod, che consente di scrivere una singola riga nella console.The Stringer class contains a method called StringerMethod that writes a single line to the 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.
    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
    

    Per compilare il codice, utilizzare il comando seguente:Use the following command to compile this code:

    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.Specifying the module parameter with the /t: compiler option indicates that the file should be compiled as a module rather than as an assembly. Il compilatore crea un modulo denominato Stringer.netmodule, che può essere aggiunto a un assembly.The compiler produces a module called Stringer.netmodule, which can be added to an assembly.

  2. Compilare tutti gli altri moduli, utilizzando le opzioni di compilatore necessarie per indicare gli altri moduli a cui si fa riferimento nel codice.Compile all other modules, using the necessary compiler options to indicate the other modules that are referenced in the code. Questo passaggio usa l'opzione del compilatore /addmodule.This step uses the /addmodule compiler option.

    Nell'esempio riportato di seguito un modulo di codice denominato Client contiene un metodo Main del punto di ingresso che fa riferimento a un metodo nel modulo Stringer.dll creato nel passaggio 1.In the following example, a code module called Client has an entry point Main method that references a method in the Stringer.dll module created in step 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 System
    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:Use the following command to compile this code:

    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.Specify the /t:module option because this module will be added to an assembly in a future step. Specificare l'opzione /addmodule poiché nel codice di Client sono presenti riferimenti allo spazio dei nomi creato dal codice in Stringer.netmodule.Specify the /addmodule option because the code in Client references a namespace created by the code in Stringer.netmodule. Il compilatore crea un modulo denominato Client.netmodule contenente un riferimento a un altro modulo, Stringer.netmodule.The compiler produces a module called Client.netmodule that contains a reference to another module, 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.The C# and Visual Basic compilers support directly creating multifile assemblies using the following two different syntaxes.

    • Un assembly su due file viene creato da due compilazioni:Two compilations create a two-file assembly:

      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:One compilation creates a two-file assembly:

      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
      
  3. Usare Assembly Linker (Al.exe) per creare il file di output contenente il manifesto dell'assembly.Use the Assembly Linker (Al.exe) to create the output file that contains the assembly manifest. In questo file sono contenute informazioni di riferimento per tutti i moduli o le risorse che fanno parte dell'assembly.This file contains reference information for all modules or resources that are part of the assembly.

    Al prompt dei comandi digitare il seguente comando:At the command prompt, type the following command:

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

    In questo comando gli argomenti nome modulo specificano il nome di ogni modulo da includere nell'assembly.In this command, the module name arguments specify the name of each module to include in the assembly. L'opzione /main: specifica il nome del metodo che corrisponde al punto di ingresso dell'assembly.The /main: option specifies the method name that is the assembly's entry point. L'opzione /out: specifica il nome del file di output che contiene i metadati dell'assembly.The /out: option specifies the name of the output file, which contains assembly metadata. L'opzione /target: specifica che l'assembly è un file eseguibile da console (file con estensione exe), un file eseguibile di Windows (file con estensione win) o una libreria (file con estensione lib).The /target: option specifies that the assembly is a console application executable (.exe) file, a Windows executable (.win) file, or a library (.lib) file.

    Nell'esempio seguente l'utilità Al.exe consente di creare un assembly denominato myAssembly.exe, che corrisponde al file eseguibile da console.In the following example, Al.exe creates an assembly that is a console application executable called myAssembly.exe. 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.The application consists of two modules called Client.netmodule and Stringer.netmodule, and the executable file called myAssembly.exe, which contains only assembly metadata. Il punto di ingresso dell'assembly è costituito dal metodo Main della classe MainClientApp, situata nel file Client.dll.The entry point of the assembly is the Main method in the class MainClientApp, which is located in Client.dll.

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

    È possibile usare MSIL Disassembler (Ildasm.exe) per esaminare i contenuti di un assembly o determinare se un file è un assembly o un modulo.You can use the MSIL Disassembler (Ildasm.exe) to examine the contents of an assembly, or determine whether a file is an assembly or a module.

Vedere ancheSee also