Ressources chaîne

Article
04/11/2008

Pour créer des ressources chaîne, exécutez simplement les trois étapes suivantes :

Créez un fichier texte qui contient une entrée nom-valeur pour chaque chaîne.
Convertissez le fichier texte en fichier .resources à l'aide de Resgen.exe.
Créez une DLL, puis incorporez le fichier .resources à l'aide de l'outil Assembly Generation Tool (AL) ou de l'un des compilateurs de langages fournis avec le Kit de développement .NET Framework SDK.

**Remarque **Pour plus d'informations sur AL, consultez Annexe B : Outils pour les ressources.

Si les chaînes sont localisées dans des cultures qui ne sont pas des cultures par défaut, vous devez exécuter les trois étapes précédentes pour chacune des cultures, ainsi que pour une culture par défaut, indépendante du langage. Vous devez également spécifier la culture lorsque vous utilisez AL.

Listing 1. Exemple de fichier texte de chaînes (MyStrings.txt)

; Sample strings for the calculator – Default locale
;
Math_Greeting = Welcome – Integer Calculator
Math_Formula_Label = Formula and Results:
Math_Clear_Button = Clear
Math_Calc_Button = Calculate
Math_Calc_Error = Invalid Formula. Please try again.

Resgen.exe effectue une conversion parmi les trois formats de fichier de ressources : chaînes (fichier .txt), ressources XML (fichier .resx) et compilé (fichier .resources). Pour compiler le fichier de ressources MyStrings.txt, utilisez la ligne de commande suivante pour générer un fichier compilé intermédiaire qui contient plusieurs ressources :

resgen MyStrings.txt MyStrings.resources

À ce stade, vous disposez de trois options d'empaquetage : incorporer des ressources dans votre assembly exécutable, créer des assemblys satellites contenant seulement des ressources ou laisser les ressources dans le fichier .resources et y accéder directement. La dernière option est surtout utile pour les outils ; les véritables applications doivent utiliser des assemblys pour tirer parti de la vérification de la version et de la signature.

Pour de nombreuses applications, en particulier celles qui ne sont pas localisées, il suffit que les ressources soient incorporées dans l'assembly exécutable. Cette opération est réalisée au moment de la compilation, à l'aide du commutateur /res et de la syntaxe suivante :

(csc|vbc) ... /out:WorldCalc.exe /res:MyStrings.resources WorldCalc.cs

**Remarque **Pour des raisons de clarté, les paramètres /target, /addmodule, /a et /r ont été omis dans la ligne précédente.

La ligne de commande précédente compile WorldCalc.cs en WorldCalc.exe et incorpore les ressources du fichier MyStrings.resources. Si vous souhaitez placer les ressources dans une DLL distincte, vous pouvez utiliser une ligne de commande semblable à la suivante :

al /out:WorldCalc.Resources.DLL /embed:MyStrings.resources,MyStrings.resources,Private

Le paramètre /embed utilise la syntaxe suivante :

/embed:<filename>[,<name>[,Private]

Les paramètres sont décrits ci-après.

<filename> — Le nom du fichier .resources.
<name> — Le nom interne des ressources. Généralement utilisé lors de la construction de ResourceManager. Inclut généralement un espace de noms.
Private — Spécifie si les ressources sont visibles aux autres assemblys. (La valeur par défaut est no.)

**Remarque **Vous pouvez utiliser le paramètre /link au lieu de /embed. La DLL de l'assembly de ressources (contenant le manifeste) est ainsi créée. Cependant, elle inclut un lien vers le fichier .resources au lieu d'incorporer les ressources elles-mêmes.

Création de ressources à l'aide de code

Vous pouvez utiliser du code pour créer directement les fichiers .resource. Cette technique est utile lors de l'automatisation de la génération de ressources mises en forme de façon appropriée, spécialement lorsque les ressources sont stockées dans une base de données ou ont migré à partir d'un système différent, tel qu'un système qui utilisait des tables de ressources chaîne antérieures à Win32. Pour créer un fichier .resources, créez ResourceWriter avec un nom de fichier unique, appelez AddResource au moins une fois, puis appelez Close (qui appelle implicitement Generate) pour fermer le fichier. Le petit programme suivant montre l'utilisation de ResourceWriter pour créer un fichier .resources avec cinq entrées.

Listing 2a. Création et lecture des fichiers .resource (ResWrite.cs)

using System;
using System.Collections;
using System.Resources;

class MainApp {
   public static void Main() {
      // First create the resource file and add strings.
      IResourceWriter rw = new ResourceWriter("sample.resources");
      rw.AddResource("test1", "one");
      rw.AddResource("test2", "two");
      rw.AddResource("test3", "three");
      rw.AddResource("test4", "four");
      rw.AddResource("test5", 512341234);
      rw.Close();
      ...
   }
}

Listing 2b. Création et lecture des fichiers .resource (ResWrite.vb)

Imports System
Imports System.Collections
Imports System.Resources

Class MainApp
    
   Public Shared Sub Main()
      ' First create the resource file and add strings.
      Dim rw As ResourceWriter = New ResourceWriter("sample.resources")
      rw.AddResource("test1", "one")
      rw.AddResource("test2", "two")
      rw.AddResource("test3", "three")
      rw.AddResource("test4", "four")
      rw.AddResource("test5", 512341234)
      rw.Close()
      ...
   End Sub
End Class

**Remarque **Vous devez l'assigner à IResourceWriter pour garantir que le code fonctionne toujours avec d'autres classes ResourceWriter prenant en charge les mêmes interfaces.

Le moyen le plus simple d'extraire les ressources d'un fichier est d'itérer sur celles-ci à l'aide de la classe ResourceReader. À partir du code précédent, le code minimum nécessaire pour énumérer les ressources écrites est le suivant (extrait des mêmes fichiers de programme ResWrite.cs et ResWrite.vb) :

Listing 3a. Itération à l'aide de ResourceReader (ResWrite.cs)

      ...
      // Iterate through the resources.
      IResourceReader rr = new ResourceReader("sample.resources");
      IDictionaryEnumerator de = rr.GetEnumerator();
      while (de.MoveNext()) {
            Console.WriteLine(de.Key + " " + de.Value);
      }
      rr.Close();
      ...

Listing 3a. Itération à l'aide de ResourceReader (ResWrite.vb)

      ...
      ' Iterate through the resources.
      Dim rr As ResourceReader = New ResourceReader("sample.resources")
      Dim de As IDictionaryEnumerator = rr.GetEnumerator()
      While de.MoveNext()
         Console.WriteLine((de.Key.ToString() + " " + de.Value.ToString()))
      End While
      rr.Close()
      ...

Dans ce bref exemple, vous créez d'abord ResourceReader pour le fichier .resources que vous avez créé précédemment. Comme lors de l'écriture des ressources, vous l'assignez à IResourceReader pour plus de souplesse. Vous utilisez ensuite DictionaryEnumerator pour passer les ressources en revue, en imprimant le nom ressource et la valeur correspondante sur la console.

Si vous utilisez directement ResourceReader, vous pouvez énumérer les ressources. Cependant, vous ne pouvez pas extraire directement des ressources spécifiques en spécifiant une entrée nommée. Vous pouvez utiliser le puissant ResourceManager, dans la section Extraction de ressources à l'aide de code, à cette fin.

Voir aussi

Partager via

Ressources chaîne

Création de ressources à l'aide de code

Voir aussi

Ressources supplémentaires