Exporter (0) Imprimer
Développer tout

Comment : générer un assembly multifichier

Mise à jour : novembre 2007

Cette section décrit la procédure utilisée pour créer un assembly multifichier et fournit un exemple complet qui illustre chacune des étapes de la procédure.

Pour 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 des modules de code est .netmodule. Par exemple, si un fichier appelé Stringer crée un espace de noms appelé myStringer référencé dans le code du fichier Client, Stringer doit d'abord être compilé dans un module de code.

  2. 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.

  3. 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.

    Remarque :

    Vous ne pouvez utiliser l'interface IDE Visual Studio 2005 pour C# et Visual Basic que pour créer des assemblys à fichier unique. Si vous souhaitez créer des assemblys multifichiers, vous devez utiliser les compilateurs de ligne de commande ou Visual Studio 2005 avec Visual C++.

L'exemple suivant illustre l'étape 1 de la procédure ci-dessus, en compilant des fichiers ayant des espaces de noms référencés par d'autres fichiers. Cet exemple démarre avec du code simple pour le fichier Stringer. Stringer possède un espace de noms appelé myStringer avec 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 System;
namespace myStringer 
   {
   public class Stringer
      { 
      public void StringerMethod() 
         {
         System.Console.WriteLine("This is a line from StringerMethod.");
         }
      }
   }

Utilisez la commande suivante pour compiler ce code :

csc /t:module Stringer.cs

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 pas comme assembly. Le compilateur produit un module appelé Stringer.netmodule, qui peut être ajouté à un assembly.

À l'étape 2 de la procédure ci-dessus, vous devez compiler des modules ayant des références à d'autres modules. 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 du module Stringer.dll créé à l'étape 1.

L'exemple suivant montre le code pour Client.

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();
   }
}

Utilisez la commande suivante pour compiler ce code :

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

Spécifiez l'option /t:module car ce module sera ajouté à un assembly dans une étape ultérieure. Spécifiez l'option /addmodule car le code de 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.

Remarque :

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 :

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

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

  • Une compilation crée un assembly à deux fichiers :

    vbc /out:Stringer.netmodule Stringer.vb /out:Client.exe Client.vb
    

    csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
    

Vous pouvez utiliser l'utilitaire Assembly Linker (Al.exe) pour créer un assembly à partir d'une collection de modules de code compilés.

Pour créer un assembly multifichier à l'aide de l'utilitaire Assembly Linker

  • À l'invite de commandes, tapez la commande suivante :

    al <nom du module> <nom du module> … /main:<nom de la méthode> /out:<nom du fichier> /target:<type du fichier d'assembly>

    Dans cette commande, les arguments nom du 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: spécifie 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 MSIL (Ildasm.exe) pour examiner le contenu d'un assembly ou déterminer si un fichier est un assembly ou un module.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft