Exemple d'assembly multifichier

Cette section fournit un exemple complet illustrant les étapes nécessaires à la création d'un assembly multifichier.

Étape 1 — Compilation de 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 sur la 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.");
         }
      }
   }

Utilisez la commande suivante pour compiler ce code :

vbc /t:module Stringer.vb
[C#]
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.

Étape 2 — Compilation de modules ayant des références à d'autres modules

Cette étape utilise l'option du compilateur /addmodule. Dans cet exemple, un module de code appelé Client a une méthode Main comme 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.

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

Utilisez la commande suivante pour compiler ce code :

vbc /addmodule:Stringer.netmodule /t:module Client.vb
[C#]
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
  [C#]
  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
  [C#]
  csc /out:Client.exe Client.cs /out:Stringer.netmodule Stringer.cs
  

Étape 3 — Création d'un assembly multifichier à l'aide de l'utilitaire Assembly Linker

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 commande, 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 MSIL Disassembler (Ildasm.exe) pour examiner le contenu d'un assembly ou déterminer si un fichier est un assembly ou un module.

Voir aussi

Création d'assemblys | Visualisation du contenu des assemblys | Méthode de localisation des assemblys par le runtime | Génération d'un assembly multifichier