Procédure : Générer un assembly multifichier

Cet article explique comment créer un assembly multifichier et fournit le code illustrant chaque étape de la procédure.

Créer un assembly multifichier

1. Compilez tous les fichiers contenant des espaces de noms référencés par d'autres modules de l'assembly dans des modules de code. L’extension par défaut pour les modules de code est .netmodule.

   Par exemple, supposons que le fichier Stringer a un espace de noms appelé myStringer, qui inclut une classe appelée Stringer. La classe Stringer contient une méthode appelée StringerMethod qui écrit une seule ligne dans la 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
   

2. Utilisez la commande suivante pour compiler ce code :

   cl /clr:pure /LN Stringer.cpp
   

   csc /t:module Stringer.cs
   

   vbc /t:module Stringer.vb
   

   La spécification du paramètre module à l’aide de l’option du compilateur /t: indique que le fichier doit être compilé comme module et non comme assembly. Le compilateur produit un module appelé Stringer.netmodule, qui peut être ajouté à un assembly.

3. Compilez tous les autres modules à l'aide des options du compilateur nécessaires pour indiquer les autres modules référencés dans le code. Cette étape utilise l’option du compilateur /addmodule.

   Dans l’exemple suivant, un module de code appelé Client a une méthode Main de point d’entrée, qui référence une méthode dans le module Stringer.netmodule créé à l’étape 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
   

4. Utilisez la commande suivante pour compiler ce 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
   

   Spécifiez l’option /t:module, car ce module sera ajouté à un assembly lors d’une étape ultérieure. Spécifiez l’option /addmodule, car le code dans Client référence un espace de noms créé par le code dans Stringer.netmodule. Le compilateur produit un module appelé Client.netmodule qui contient une référence à un autre module, Stringer.netmodule.

   Notes

   Les compilateurs C# et Visual Basic prennent en charge la création directe d'assemblys multifichiers à l'aide de deux syntaxes différentes.

   Deux compilations créent un assembly à deux fichiers :

   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
   

   Une compilation crée un assembly à deux fichiers :

   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
   

5. Utilisez l’utilitaire Assembly Linker (Al.exe) pour créer le fichier de sortie qui contient le manifeste d’assembly. Ce fichier contient des informations sur les références de tous les modules ou ressources faisant partie de l'assembly.

   Saisissez ensuite la commande suivante dans l’invite de commandes :

   al<nom_module><nom_module> … /main:<nom_méthode>/out:<nom_fichier>/target:<type_fichier_assembly>

   Dans cette commande, les arguments nom_module spécifient le nom de chaque module à inclure dans l’assembly. L’option /main: spécifie le nom de la méthode représentant le point d’entrée de l’assembly. L’option /out: spécifie le nom du fichier de sortie, qui contient les métadonnées de l’assembly. L’option /target: indique que l’assembly est un fichier exécutable (.exe) d’application console, un fichier exécutable Windows (.win) ou un fichier bibliothèque (.lib).

   Dans l’exemple suivant, Al.exe crée un assembly qui est un exécutable d’application console appelé myAssembly.exe. L’application se compose de deux modules appelés Client.netmodule et Stringer.netmodule, et du fichier exécutable appelé myAssembly.exe qui contient uniquement les métadonnées de l’assembly. Le point d’entrée de l’assembly est la méthode Main de la classe MainClientApp, qui est située dans Client.dll.

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

   Vous pouvez utiliser le Désassembleur IL (Ildasm.exe) pour examiner le contenu d’un assembly, ou pour déterminer si un fichier est un assembly ou un module.

Voir aussi

• Créer des assemblys
• Comment : Afficher le contenu d’un assembly
• Méthode de localisation des assemblys par le runtime
• Assemblys multifichiers