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

Article
06/11/2024

Remarque

Cet article est spécifique au .NET Framework. Ceci ne s’applique pas aux implémentations plus récentes de .NET, y compris .NET 6 et versions ultérieures.

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

Notes

L'IDE de Visual Studio 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 avec Visual C++. Les assemblys multifichiers ne sont pris en charge que par .NET Framework.

Créer un assembly multifichier

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

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.

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

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

Partage via

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

Créer un assembly multifichier

Voir aussi

Ressources supplémentaires