Comment : générer un assembly multifichier

  • Article

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 pour les 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.

    RemarqueRemarque

    L'IDE Visual Studio 2005 pour C# et Visual Basic ne peut être utilisé 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 a 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.
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

// 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.
using namespace System;

namespace myStringer
{
    public ref 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

csc /t:module Stringer.cs

cl /clr:pure /LN Stringer.cpp

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.

Imports System
Imports myStringer 'The namespace created in Stringer.netmodule.

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

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");
        myStringInstance.StringerMethod();
    }
}

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

Utilisez la commande suivante pour compiler ce code :

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

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

cl /clr:pure /FUStringer.netmodule /LN Client.cpp

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.

RemarqueRemarque

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

cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule
  • Une compilation crée un assembly à deux fichiers :
vbc /out:Client.exe Client.vb /out:Stringer.netmodule Stringer.vb

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

cl /clr:pure /LN Stringer.cpp
cl /clr:pure Client.cpp /link /ASSEMBLYMODULE:Stringer.netmodule

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.

Voir aussi

Tâches

Comment : afficher le contenu d'un assembly

Concepts

Création d'assemblys

Méthode de localisation des assemblys par le runtime

Assemblys multifichiers