Créer des assemblys satellites pour les applications .NET

Article
05/10/2023

Les fichiers de ressources jouent un rôle central dans les applications localisées. Ils permettent à une application d’afficher des chaînes, des images et d’autres données dans la langue et la culture de l’utilisateur et de fournir des données de remplacement si les ressources relatives à la langue et la culture de l’utilisateur ne sont pas disponibles. .NET utilise un modèle Hub and Spoke pour localiser et récupérer les ressources localisées. Le hub est l’assembly principal qui contient le code exécutable non localisable et les ressources pour une culture unique, appelée culture neutre ou par défaut. La culture par défaut est la culture de secours de l’application ; elle est utilisée quand aucune ressource localisée n’est disponible. Vous utilisez l’attribut NeutralResourcesLanguageAttribute pour désigner la culture de la culture par défaut de l’application. Chaque spoke se connecte à un assembly satellite qui contient les ressources d’une culture localisée unique, mais ne contient pas de code. Dans la mesure où les assemblys satellites ne font pas partie de l’assembly principal, vous pouvez facilement remplacer ou mettre à jour les ressources correspondant à une culture spécifique sans remplacer l’assembly principal de l’application.

Notes

Les ressources de la culture par défaut d’une application peuvent aussi être stockées dans un assembly satellite. Pour cela, vous affectez à l’attribut NeutralResourcesLanguageAttribute la valeur UltimateResourceFallbackLocation.Satellite.

Nom et emplacement de l’assembly satellite

Le modèle Hub and Spoke nécessite que vous placiez les ressources à des emplacements spécifiques afin qu’elles soient facilement trouvées et utilisées. Si vous ne compilez pas et ne nommez pas les ressources comme prévu ou si vous ne les placez pas aux endroits corrects, le Common Language Runtime ne sera pas en mesure de les trouver et utilisera les ressources de la culture par défaut à la place. Le gestionnaire de ressources .NET est représenté par le type ResourceManager et il est utilisé pour accéder automatiquement aux ressources localisées. Le gestionnaire des ressources nécessite les éléments suivants :

Un seul assembly satellite doit inclure toutes les ressources d’une culture particulière. En d’autres termes, vous devez compiler plusieurs fichiers .txt ou ..resx en un seul fichier .resources binaire.
Il doit exister un sous-répertoire distinct dans le répertoire de l’application pour chaque culture localisée qui stocke les ressources de cette culture. Le nom du sous-répertoire doit être identique au nom de la culture. Vous pouvez aussi stocker vos assemblys satellites dans le Global Assembly Cache. Dans ce cas, le composant des informations de culture du nom fort de l’assembly doit indiquer sa culture. Pour plus d’informations, consultez Installer des assemblys satellites dans le Global Assembly Cache.

Notes

Si votre application comporte des ressources pour les sous-cultures, placez chaque sous-culture dans un sous-répertoire distinct sous le répertoire de l’application. Ne placez pas les sous-cultures dans des sous-répertoires sous le répertoire de leur culture principale.
L’assembly satellite doit avoir le même nom que l’application et doit utiliser l’extension de nom de fichier « . resources.dll ». Par exemple, si une application est nommée Example.exe, le nom de chaque assembly satellite doit être Example.resources.dll. Le nom de l’assembly satellite n’indique pas la culture de ses fichiers de ressources. Toutefois, l’assembly satellite apparaît dans un répertoire qui spécifie la culture.
Des informations sur la culture de l’assembly satellite doivent être incluses dans les métadonnées de l’assembly. Pour stocker le nom de culture dans les métadonnées de l’assembly satellite, vous spécifiez l’option /culture quand vous utilisez Assembly Linker pour incorporer des ressources dans l’assembly satellite.

L’illustration suivante propose un exemple de structure de répertoires et de la configuration requise pour les emplacements des applications que vous n’installez pas dans le Global Assembly Cache. Les éléments avec les extensions .txt et ..resources ne sont pas fournis avec l’application finale. Il s’agit des fichiers de ressources intermédiaires utilisés pour créer les assemblys de ressources satellites finaux. Dans cet exemple, vous pouvez remplacer les fichiers .txt par les fichiers .resx. Pour plus d’informations, consultez Empaqueter et déployer des ressources.

L’illustration suivante montre le répertoire d’assemblys satellites :

Répertoire d’assemblys satellites avec sous-répertoires de cultures localisées.

Compiler des assemblys satellites

Vous utilisez le Générateur de fichiers de ressources (resgen.exe) pour compiler les fichiers texte ou XML (.resx) qui contiennent des ressources en fichiers .resources binaires. Vous utilisez ensuite Assembly Linker (al.exe) pour compiler les fichiers .resources en assemblys satellites. al.exe crée un assembly à partir des fichiers .resources que vous spécifiez. Les assemblys satellites ne peuvent contenir que des ressources ; ils ne peuvent contenir aucun code exécutable.

La commandeal.exe suivante crée un assembly satellite pour l’application Example à partir du fichier de ressources en allemand strings.de.resources.

al -target:lib -embed:strings.de.resources -culture:de -out:Example.resources.dll

La commandeal.exe suivante crée également un assembly satellite pour l’application Example à partir du fichier. strings.de.resources. L’option /template permet à l’assembly satellite d’hériter de toutes les métadonnées de l’assembly à l’exception des informations de culture de l’assembly parent (Example.dll).

al -target:lib -embed:strings.de.resources -culture:de -out:Example.resources.dll -template:Example.dll

Le tableau suivant décrit plus en détail les options al.exe utilisées dans ces commandes :

Option	Description
`-target:lib`	Spécifie que votre assembly satellite est compilé dans un fichier de bibliothèque (.dll). Comme un assembly satellite ne contient pas de code exécutable et n’est pas l’assembly principal d’une application, vous devez enregistrer les assemblys satellites en tant que DLL.
`-embed:strings.de.resources`	Spécifie le nom du fichier de ressources à incorporer quand al.exe compile l’assembly. Vous pouvez incorporer plusieurs fichiers .resources dans un assembly satellite mais, si vous suivez le modèle Hub and Spoke, vous devez compiler un assembly satellite pour chaque culture. Toutefois, vous pouvez créer des fichiers .resources séparés pour les chaînes et les objets.
`-culture:de`	Spécifie la culture de la ressource à compiler. Le Common Language Runtime utilise ces informations lors de la recherche des ressources pour une culture spécifiée. Si vous omettez cette option, al.exe compile quand même la ressource, mais le runtime n’est pas en mesure de la trouver quand un utilisateur la demande.
`-out:Example.resources.dll`	Spécifie le nom du fichier de sortie. Le nom doit respecter la norme d’appellation baseName.resources. extension, où baseName est le nom de l’assembly principal et extension est une extension valide (par exemple, .dll). Le runtime n’est pas en mesure de déterminer la culture d’un assembly satellite en fonction du nom de son fichier de sortie ; vous devez utiliser l’option /culture pour la spécifier.
`-template:Example.dll`	Spécifie un assembly à partir duquel l’assembly satellite va hériter de toutes les métadonnées de l’assembly, à l’exception du champ de culture. Cette option affecte les assemblys satellites uniquement si vous spécifiez un assembly qui a un nom fort.

Pour obtenir une liste complète des options disponibles avec al.exe, consultez Assembly Linker (al.exe).

Notes

Il peut arriver que vous souhaitiez utiliser la tâche MSBuild .NET Core pour compiler des assemblys satellites, même si vous ciblez .NET Framework. Par exemple, vous pouvez utiliser l’option déterministe du compilateur C# pour pouvoir comparer des assemblys de différents builds. Dans ce cas, définissez GenerateSatelliteAssembliesForCore sur true dans le fichier .csproj pour générer des assemblys satellites à l’aide de csc.exe au lieu de Al.exe (Assembly Linker).

<Project>
    <PropertyGroup>
        <GenerateSatelliteAssembliesForCore>true</GenerateSatelliteAssembliesForCore>
    </PropertyGroup>
</Project>

La tâche MSBuild .NET Core utilise csc.exe au lieu de al.exe pour générer par défaut des assemblys satellites. Pour en savoir plus, consultez Faciliter l’activation de la génération d’un assembly satellite « Core ».

Exemple d’assemblys satellites

Voici un exemple « Hello world » simple qui affiche une boîte de message contenant un message d’accueil localisé. L’exemple contient des ressources pour les cultures Anglais (États-Unis), Français (France) et Russe (Russie), et sa culture de secours est Anglais. Pour créer l’exemple, effectuez les étapes suivantes :

Créez un fichier de ressources nommé Greeting.resx ou Greeting.txt pour contenir la ressource de la culture par défaut. Stockez une chaîne unique nommée HelloString dont la valeur est « Hello world! » dans ce fichier.
Pour indiquer que l’anglais (en) est la culture par défaut de l’application, ajoutez l’attribut System.Resources.NeutralResourcesLanguageAttribute suivant au fichier AssemblyInfo de l’application ou au fichier de code source principal qui sera compilé dans l’assembly principal de l’application.
```
[assembly: NeutralResourcesLanguage("en")]
```
```
<Assembly: NeutralResourcesLanguage("en")>
```
Ajoutez la prise en charge de cultures supplémentaires (en-US, fr-FR, et ru-RU) à l’application comme suit :
- Pour prendre en charge la culture en-US ou Anglais (États-Unis), créez un fichier de ressources nomméGreeting.en-US.resx ou Greeting.en-US.txt et stockez-le dans une chaîne unique nommée HelloString dont la valeur est « Hi world! ».
- Pour prendre en charge la culturefr-FR ou Français (France), créez un fichier de ressources nommé Greeting.fr-FR.resx ou Greeting.fr-FR.txt et stockez-le dans une chaîne unique nommée HelloString dont la valeur est « Salut tout le monde ! ».
- Pour prendre en charge la culture ru-RU ou Russe (Russie), créez un fichier de ressources nommé Greeting.ru-RU.resx ou Greeting.ru-RU.txt et stockez-le dans une chaîne unique nommée HelloString dont la valeur est « Всем привет! ».
Utilisez resgen.exe pour compiler chaque fichier de ressources texte ou XML en un fichier ..resources binaire. La sortie est un ensemble de fichiers ayant le même nom de fichier racine que les fichiers .resx ou .txt, mais avec l’extension .resources. Si vous créez l’exemple avec Visual Studio, le processus de compilation est géré automatiquement. Si vous n’utilisez pas Visual Studio, exécutez les commandes suivantes pour compiler les fichiers .resx en fichiers .resources :
```
resgen Greeting.resx
resgen Greeting.en-us.resx
resgen Greeting.fr-FR.resx
resgen Greeting.ru-RU.resx
```
Si vos ressources se trouvent dans des fichiers texte au lieu de fichiers XML, remplacez l’extension .resx par .txt.

Compilez le code source suivant avec les ressources de la culture par défaut dans l’assembly principal de l’application :

Important

Si vous utilisez la ligne de commande plutôt que Visual Studio pour créer l’exemple, vous devez modifier l’appel au constructeur de la classe ResourceManager comme suit :ResourceManager rm = new ResourceManager("Greeting", typeof(Example).Assembly);

using System;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Threading;
using System.Windows.Forms;

class Example
{
   static void Main()
   {
      // Create array of supported cultures
      string[] cultures = {"en-CA", "en-US", "fr-FR", "ru-RU"};
      Random rnd = new Random();
      int cultureNdx = rnd.Next(0, cultures.Length);
      CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;

      try {
         CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
         Thread.CurrentThread.CurrentCulture = newCulture;
         Thread.CurrentThread.CurrentUICulture = newCulture;
         ResourceManager rm = new ResourceManager("Example.Greeting",
                                                  typeof(Example).Assembly);
         string greeting = String.Format("The current culture is {0}.\n{1}",
                                         Thread.CurrentThread.CurrentUICulture.Name,
                                         rm.GetString("HelloString"));

         MessageBox.Show(greeting);
      }
      catch (CultureNotFoundException e) {
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName);
      }
      finally {
         Thread.CurrentThread.CurrentCulture = originalCulture;
         Thread.CurrentThread.CurrentUICulture = originalCulture;
      }
   }
}

Imports System.Globalization
Imports System.Resources
Imports System.Threading

Module Module1

    Sub Main()
        ' Create array of supported cultures
        Dim cultures() As String = {"en-CA", "en-US", "fr-FR", "ru-RU"}
        Dim rnd As New Random()
        Dim cultureNdx As Integer = rnd.Next(0, cultures.Length)
        Dim originalCulture As CultureInfo = Thread.CurrentThread.CurrentCulture

        Try
            Dim newCulture As New CultureInfo(cultures(cultureNdx))
            Thread.CurrentThread.CurrentCulture = newCulture
            Thread.CurrentThread.CurrentUICulture = newCulture
            Dim greeting As String = String.Format("The current culture is {0}.{1}{2}",
                                                   Thread.CurrentThread.CurrentUICulture.Name,
                                                   vbCrLf, My.Resources.Greetings.HelloString)

            MsgBox(greeting)
        Catch e As CultureNotFoundException
            Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName)
        Finally
            Thread.CurrentThread.CurrentCulture = originalCulture
            Thread.CurrentThread.CurrentUICulture = originalCulture
        End Try
    End Sub
End Module

Si l’application se nomme Example et que vous compilez à partir de la ligne de commande, la commande pour le compilateur C# est :

csc Example.cs -res:Greeting.resources

La commande correspondante du compilateur Visual Basic est :

vbc Example.vb -res:Greeting.resources

Créez un sous-répertoire dans le répertoire principal de l’application pour chaque culture localisée prise en charge par l’application. Vous devez créer des sous-répertoires en-US, fr-FR et ru-RU. Visual Studio crée automatiquement ces sous-répertoires dans le cadre du processus de compilation.
Incorporez les fichiers .resources individuels spécifiques à la culture dans des assemblys satellites et enregistrez-les dans le répertoire approprié. La commande à exécuter pour chaque fichier .resources est la suivante :
```
al -target:lib -embed:Greeting.culture.resources -culture:culture -out:culture\Example.resources.dll
```
où culture est le nom de la culture dont les ressources sont contenues dans l’assembly satellite. Visual Studio gère automatiquement ce processus.

Vous pouvez ensuite exécuter l’exemple. Il choisit au hasard comme culture actuelle l’une des cultures prises en charge et affiche un message d’accueil localisé.

Installer des assemblys satellites dans le Global Assembly Cache

Au lieu d’installer des assemblys dans un sous-répertoire de l’application locale, vous pouvez les installer dans le Global Assembly Cache. Ceci est particulièrement utile si vous avez des bibliothèques de classes et des assemblys de ressources de bibliothèques de classes qui sont utilisés par plusieurs applications.

Pour être installés dans le Global Assembly Cache, les assemblys doivent avoir un nom fort. Les assemblys avec nom fort sont signés avec une paire de clés publique/privée valide. Ils contiennent des informations de version que le runtime utilise pour déterminer l’assembly à utiliser pour répondre à une demande de liaison. Pour plus d’informations sur les noms forts et le contrôle de version, consultez Contrôle de version des assemblys. Pour plus d’informations sur les noms forts, consultez Assemblys avec nom fort.

Quand vous développez une application, il est peu probable que vous puissiez accéder à la paire de clés publique/privée finale. Pour installer un assembly satellite dans le Global Assembly Cache et vous assurer qu’il fonctionne comme prévu, vous pouvez utiliser une technique appelée signature différée. Quand vous différez la signature d’un assembly, vous réservez au moment de la génération un espace dans le fichier pour la signature de nom fort. La signature réelle est différée jusqu’à une date ultérieure, quand la paire de clés publique/privée finale est disponible. Pour plus d’informations sur la signature différée, consultez Temporiser la signature d’un assembly.

Obtenir la clé publique

Pour différer la signature d’un assembly, vous devez avoir accès à la clé publique. Vous pouvez soit obtenir la clé publique réelle à partir de l’organisation de votre société qui effectuera la signature finale, soit créer une clé publique en utilisant l’outil Strong Name (sn.exe).

La commande Sn.exe suivante crée une paire de clés publique/privée de test. L’option –k spécifie queSn.exe doit créer une paire de clés et l’enregistrer dans un fichier nommé TestKeyPair.snk.

sn –k TestKeyPair.snk

Vous pouvez extraire la clé publique du fichier contenant la paire de clés de test. La commande suivante extrait la clé publique de TestKeyPair.snk et l’enregistre dans PublicKey.snk :

sn –p TestKeyPair.snk PublicKey.snk

Temporisation de signature d'un assembly

Après avoir obtenu ou créé la clé publique, utilisez Assembly Linker (al.exe) pour compiler l’assembly et spécifier une signature différée.

La commande al.exe suivante crée un assembly satellite avec nom fort pour l’application StringLibrary à partir du fichier strings.ja.resources :

al -target:lib -embed:strings.ja.resources -culture:ja -out:StringLibrary.resources.dll -delay+ -keyfile:PublicKey.snk

L’option -delay+ indique qu’Assembly Linker doit différer la signature de l’assembly. L’option -keyfile spécifie le nom du fichier de clé qui contient la clé publique à utiliser pour différer la signature de l’assembly.

Nouvelle signature d’un assembly

Avant de déployer votre application, vous devez signer à nouveau l’assembly satellite à signature différée avec la vraie valeur de paire de clés. Pour cela, utilisez Sn.exe.

La commande Sn.exe suivante signe StringLibrary.resources.dll avec la paire de clés stockée dans le fichier RealKeyPair.snk. L’option –R spécifie qu’un assembly déjà signé ou à signature différée doit être à nouveau signé.

sn –R StringLibrary.resources.dll RealKeyPair.snk

Installation d’un assembly satellite dans le Global Assembly Cache

Quand le runtime recherche des ressources dans le processus de secours pour les ressources, il cherche d’abord dans le Global Assembly Cache. (Pour plus d’informations, consultez la section « Processus de secours pour les ressources » de Empaqueter et déployer des ressources.) Dès qu’un assembly satellite est signé avec un nom fort, il peut être installé dans le global assembly cache à l’aide de l’outil Global Assembly Cache (gacutil.exe).

La commande Gacutil.exe suivante installe StringLibrary.resources.dll* dans le Global Assembly Cache :

gacutil -i:StringLibrary.resources.dll

L’option /i spécifie que Gacutil.exe doit installer l’assembly spécifié dans le Global Assembly Cache. Une fois l’assembly satellite installé dans le cache, les ressources qu’il contient deviennent disponibles pour toutes les applications conçues pour utiliser l’assembly satellite.

Ressources dans le Global Assembly Cache : un exemple

L’exemple suivant utilise une méthode dans une bibliothèque de classes .NET pour extraire et retourner un message d’accueil localisé à partir d’un fichier de ressources. La bibliothèque et ses ressources sont inscrites dans le Global Assembly Cache. L’exemple contient des ressources pour les cultures Anglais (États-Unis), Français (France) et Russe (Russie). L’anglais est la culture par défaut ; ses ressources sont stockées dans l’assembly principal. L’exemple diffère initialement la signature de la bibliothèque et ses assemblys satellites avec une clé publique, puis les signe à nouveau avec une paire de clés publique/privée. Pour créer l’exemple, effectuez les étapes suivantes :

Si vous n’utilisez pas Visual Studio, utilisez la commande Strong Name Tool (Sn.exe) suivante pour créer une paire de clés publique/privée nommée ResKey.snk :
```
sn –k ResKey.snk
```
Si vous utilisez Visual Studio, utilisez l’onglet Signature de la boîte de dialogue Propriétés du projet pour générer le fichier de clé.
Utilisez la commande Strong Name Tool (Sn.exe) suivante pour créer un fichier de clé publique nommé PublicKey.snk :
```
sn –p ResKey.snk PublicKey.snk
```
Créez un fichier de ressources nommé Strings.resx pour contenir la ressource de la culture par défaut. Stockez une chaîne unique nommée Greeting dont la valeur est « How do you do? » dans ce fichier.
Pour indiquer que l’anglais « en » est la culture par défaut de l’application, ajoutez l’attribut System.Resources.NeutralResourcesLanguageAttribute suivant au fichier AssemblyInfo de l’application ou au fichier de code source principal qui sera compilé dans l’assembly principal de l’application :
```
[assembly:NeutralResourcesLanguageAttribute("en")]
```
```
<Assembly: NeutralResourcesLanguageAttribute("en")>
```
Ajoutez la prise en charge de cultures supplémentaires (en-US, fr-FR et ru-RU) à l’application comme suit :
- Pour prendre en charge la culture « en-US » ou Anglais (États-Unis), créez un fichier de ressources nommé Strings.en-US.resx ou Strings.en-US.txt et stockez-le dans une chaîne unique nommée Greeting dont la valeur est « Hello! ».
- Pour prendre en charge la culture « fr-FR » ou Français (France), créez un fichier de ressources nommé Strings.fr-FR.resx ou Strings.fr-FR.txt et stockez-le dans une chaîne unique nommée Greeting dont la valeur est « Bonjour ! ».
- Pour prendre en charge la culture « ru-RU » ou Russe (Russie), créez un fichier de ressources nommé Strings.ru-RU.resx ou Strings.ru-RU.txt et stockez-le dans une chaîne unique nommée Greeting dont la valeur est « Привет! ».
Utilisez resgen.exe pour compiler chaque fichier de ressources texte ou XML en un fichier .resources binaire. La sortie est un ensemble de fichiers ayant le même nom de fichier racine que les fichiers .resx ou .txt, mais avec l’extension .resources. Si vous créez l’exemple avec Visual Studio, le processus de compilation est géré automatiquement. Si vous n’utilisez pas Visual Studio, exécutez la commande suivante pour compiler les fichiers .resx en fichiers .resources :
```
resgen filename
```
Où filename représente le chemin d’accès facultatif, le nom de fichier et l’extension du fichier .resx ou texte.

Compilez le code source suivant pour StringLibrary.vb ou StringLibrary.cs avec les ressources de la culture par défaut dans un assembly de bibliothèque à signature différée nommé StringLibrary.dlll :

Important

Si vous utilisez la ligne de commande plutôt que Visual Studio pour créer l’exemple, vous devez modifier l’appel au constructeur de classe ResourceManager pour ResourceManager rm = new ResourceManager("Strings", typeof(Example).Assembly);.

using System;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Threading;

[assembly:NeutralResourcesLanguageAttribute("en")]

public class StringLibrary
{
   public string GetGreeting()
   {
      ResourceManager rm = new ResourceManager("Strings",
                           Assembly.GetAssembly(typeof(StringLibrary)));
      string greeting = rm.GetString("Greeting");
      return greeting;
   }
}

Imports System.Globalization
Imports System.Reflection
Imports System.Resources
Imports System.Threading

<Assembly: NeutralResourcesLanguageAttribute("en")>

Public Class StringLibrary
    Public Function GetGreeting() As String
        Dim rm As New ResourceManager("Strings", _
                                      Assembly.GetAssembly(GetType(StringLibrary)))
        Dim greeting As String = rm.GetString("Greeting")
        Return greeting
    End Function
End Class

La commande pour le compilateur C# est :

csc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.cs

La commande correspondante du compilateur Visual Basic est :

vbc -t:library -resource:Strings.resources -delaysign+ -keyfile:publickey.snk StringLibrary.vb

Créez un sous-répertoire dans le répertoire principal de l’application pour chaque culture localisée prise en charge par l’application. Vous devez créer des sous-répertoires en-US, fr-FR et ru-RU. Visual Studio crée automatiquement ces sous-répertoires dans le cadre du processus de compilation. Comme tous les assemblys satellites ont le même nom de fichier, les sous-répertoires permettent de stocker des assemblys satellites individuels spécifiques à la culture jusqu’à ce qu’ils soient signés avec une paire de clés publique/privée.
Incorporez les fichiers ..resources individuels spécifiques à la culture dans des assemblys satellites à signature différée et enregistrez-les dans le répertoire approprié. La commande à exécuter pour chaque fichier .resources est la suivante :
```
al -target:lib -embed:Strings.culture.resources -culture:culture -out:culture\StringLibrary.resources.dll -delay+ -keyfile:publickey.snk
```
où culture est le nom d’une culture. Dans cet exemple, les noms de culture sont en-US, fr-FR et ru-RU.
Signez à nouveau StringLibrary.dll à l’aide de Strong Name tool (sn.exe) comme suit :
```
sn –R StringLibrary.dll RealKeyPair.snk
```
Signez à nouveau les assemblys satellites individuels. Pour ce faire, utilisez Strong Name tool (sn.exe) comme suit pour chaque assembly satellite :
```
sn –R StringLibrary.resources.dll RealKeyPair.snk
```
Inscrivez StringLibrary.dll et chacun de ses assemblys satellites dans le Global Assembly Cache à l’aide de la commande suivante :
```
gacutil -i filename
```
où filename représente le nom du fichier à inscrire.

Si vous utilisez Visual Studio, créez un projet Application console nommé Example, ajoutez-lui une référence à StringLibrary.dll et le code source suivant, puis compilez.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-GB", "en-US", "fr-FR", "ru-RU" };
      Random rnd = new Random();
      string cultureName = cultureNames[rnd.Next(0, cultureNames.Length)];
      Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName);
      Console.WriteLine("The current UI culture is {0}",
                        Thread.CurrentThread.CurrentUICulture.Name);
      StringLibrary strLib = new StringLibrary();
      string greeting = strLib.GetGreeting();
      Console.WriteLine(greeting);
   }
}

Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim cultureNames() As String = {"en-GB", "en-US", "fr-FR", "ru-RU"}
        Dim rnd As New Random()
        Dim cultureName As String = cultureNames(rnd.Next(0, cultureNames.Length))
        Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultureName)
        Console.WriteLine("The current UI culture is {0}",
                          Thread.CurrentThread.CurrentUICulture.Name)
        Dim strLib As New StringLibrary()
        Dim greeting As String = strLib.GetGreeting()
        Console.WriteLine(greeting)
    End Sub
End Module

Pour compiler à partir de la ligne de commande, utilisez la commande suivante pour le compilateur C# :

csc Example.cs -r:StringLibrary.dll

La ligne de commande pour le compilateur Visual Basic est :

vbc Example.vb -r:StringLibrary.dll

Exécutez Example.exe.

Partager via