ResXResourceReader Classe

  • Référence

Définition

Espace de noms:
System.Resources
Assembly:
System.Windows.Forms.dll

Énumère les fichiers (.resx) et flux de ressources XML et lit les paires nom/valeur de ressource séquentielles.

public ref class ResXResourceReader : System::Resources::IResourceReader
public ref class ResXResourceReader : IDisposable, System::Collections::IEnumerable, System::Resources::IResourceReader
public class ResXResourceReader : System.Resources.IResourceReader
public class ResXResourceReader : IDisposable, System.Collections.IEnumerable, System.Resources.IResourceReader
type ResXResourceReader = class
    interface IResourceReader
    interface IEnumerable
    interface IDisposable
Public Class ResXResourceReader
Implements IResourceReader
Public Class ResXResourceReader
Implements IDisposable, IEnumerable, IResourceReader
Héritage
Object
ResXResourceReader
Implémente
IEnumerable IDisposable IResourceReader

Exemples

L’exemple suivant montre comment utiliser un ResXResourceReader pour itérer dans les ressources d’un fichier .resx. Tout d’abord, est ResXResourceReaderrsxr créé pour le fichier items.resx. Ensuite, la GetEnumerator méthode est utilisée pour créer un IDictionaryEnumerator pour itérer dans les ressources et afficher le contenu dans la console.

#using <system.windows.forms.dll>
#using <System.dll>

using namespace System;
using namespace System::Resources;
using namespace System::Collections;
void main()
{

   // Create a ResXResourceReader for the file items.resx.
   ResXResourceReader^ rsxr = gcnew ResXResourceReader( "items.resx" );


   // Iterate through the resources and display the contents to the console.
   IEnumerator^ myEnum = rsxr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      DictionaryEntry^ d = safe_cast<DictionaryEntry^>(myEnum->Current);
      Console::WriteLine( "{0}:\t {1}", d->Key, d->Value );
   }


   //Close the reader.
   rsxr->Close();
}

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

class ReadResXResources
{
   public static void Main()
   {

      // Create a ResXResourceReader for the file items.resx.
      ResXResourceReader rsxr = new ResXResourceReader("items.resx");

      // Iterate through the resources and display the contents to the console.
      foreach (DictionaryEntry d in rsxr)
      {
    Console.WriteLine(d.Key.ToString() + ":\t" + d.Value.ToString());
      }

     //Close the reader.
     rsxr.Close();
   }
}

Imports System.Resources
Imports System.Collections

Class ReadResXResources
   
   Public Shared Sub Main()
      
      ' Create a ResXResourceReader for the file items.resx.
      Dim rsxr As ResXResourceReader
      rsxr = New ResXResourceReader("items.resx")

      ' Iterate through the resources and display the contents to the console.
      Dim d As DictionaryEntry
      For Each d In  rsxr
         Console.WriteLine(d.Key.ToString() + ":" + ControlChars.Tab + d.Value.ToString())
      Next d
      
      'Close the reader.
      rsxr.Close()

   End Sub

End Class

Remarques

Important

L’appel de méthodes de cette classe avec des données non approuvées est un risque de sécurité. Appelez les méthodes de cette classe avec des données approuvées uniquement. Pour plus d’informations, consultez Valider toutes les entrées.

La ResXResourceReader classe fournit une implémentation par défaut de l’interface IResourceReader qui lit les informations de ressource dans un format XML. Pour lire les informations sur les ressources à partir d’un format de ressource binaire, utilisez la ResourceReader classe .

Vous utilisez la ResXResourceReader classe pour énumérer les ressources dans les fichiers .resx en parcourant l’énumérateur de dictionnaire (IDictionaryEnumerator) retourné par la GetEnumerator méthode. Vous appelez les méthodes fournies par IDictionaryEnumerator pour passer à la ressource suivante et lire le nom et la valeur de chaque ressource dans le fichier .resx.

Notes

La ResXResourceReader classe fournit deux énumérateurs. La ResXResourceReader.GetEnumerator méthode retourne un IDictionaryEnumerator objet ; nous vous recommandons d’utiliser cette méthode pour énumérer des ressources. La ResXResourceReader.IEnumerable.GetEnumerator méthode est une implémentation d’interface explicite qui retourne un IEnumerator objet ; nous ne recommandons pas son utilisation.

L’exemple suivant utilise la GetEnumerator méthode pour obtenir un IDictionaryEnumerator objet utilisé pour énumérer les ressources dans un fichier .resx. L’exemple inclut une CreateResourceFile routine qui crée le fichier de ressources nécessaire.

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

public class Example
{
   private const string resxFilename = @".\CountryHeaders.resx";
    
   public static void Main()
   {
      // Create a resource file to read.
      CreateResourceFile();
      
      // Enumerate the resources in the file.
      ResXResourceReader rr = new ResXResourceReader(resxFilename);
      IDictionaryEnumerator dict = rr.GetEnumerator();
      while (dict.MoveNext())
         Console.WriteLine("{0}: {1}", dict.Key, dict.Value);   
   }

   private static void CreateResourceFile()
   {
      ResXResourceWriter rw = new ResXResourceWriter(resxFilename);
      string[] resNames = {"Country", "Population", "Area", 
                           "Capital", "LCity" };
      string[] columnHeaders = { "Country Name", "Population (2010}", 
                                 "Area", "Capital", "Largest City" };
      string[] comments = { "The localized country name", "", 
                            "The area in square miles", "", 
                            "The largest city based on 2010 data" };
      rw.AddResource("Title", "Country Information");
      rw.AddResource("nColumns", resNames.Length);
      for (int ctr = 0; ctr < resNames.Length; ctr++) {
         ResXDataNode node = new ResXDataNode(resNames[ctr], columnHeaders[ctr]);
         node.Comment = comments[ctr];
         rw.AddResource(node);
      }
      rw.Generate();
      rw.Close();
   }
}
// The example displays the following output:
//       Title: Country Information
//       nColumns: 5
//       Country: Country Name
//       Population: Population (2010}
//       Area: Area
//       Capital: Capital
//       LCity: Largest City

Imports System.Collections
Imports System.Resources

Module Example
   Private Const resxFilename As String = ".\CountryHeaders.resx"
     
   Public Sub Main()
      ' Create a resource file to read.
      CreateResourceFile()
      
      ' Enumerate the resources in the file.
      Dim rr As New ResXResourceReader(resxFilename)
      Dim dict As IDictionaryEnumerator = rr.GetEnumerator()
      Do While dict.MoveNext()
         Console.WriteLine("{0}: {1}", dict.Key, dict.Value)   
      Loop
   End Sub
   
   Private Sub CreateResourceFile()
      Dim rw As New ResxResourceWriter(resxFilename)
      Dim resNames() As String = {"Country", "Population", "Area", 
                                  "Capital", "LCity" }
      Dim columnHeaders() As String = { "Country Name", "Population (2010}", 
                                        "Area", "Capital", "Largest City" }
      Dim comments() As String = { "The localized country name", "", 
                                   "The area in square miles", "", 
                                   "The largest city based on 2010 data" }
      rw.AddResource("Title", "Country Information")
      rw.AddResource("nColumns", resNames.Length)
      For ctr As Integer = 0 To resNames.Length - 1
         Dim node As New ResXDataNode(resNames(ctr), columnHeaders(ctr))
         node.Comment = comments(ctr)
         rw.AddResource(node)
      Next
      rw.Generate()
      rw.Close()
   End Sub
End Module
' The example displays the following output:
'       Title: Country Information
'       nColumns: 5
'       Country: Country Name
'       Population: Population (2010}
'       Area: Area
'       Capital: Capital
'       LCity: Largest City

Si la UseResXDataNodes propriété est true, la valeur de la IDictionaryEnumerator.Value propriété est un ResXDataNode objet plutôt que la valeur de ressource. Cela rend le commentaire d’un élément de ressource disponible à partir de la ResXDataNode.Comment propriété . L’exemple suivant définit la UseResXDataNodes propriété sur true et énumère les ressources dans un fichier .resx,

using System;
using System.Collections;
using System.ComponentModel.Design;
using System.Resources;

public class Example
{
   private const string resxFilename = @".\CountryHeaders.resx";
    
   public static void Main()
   {
      // Create a resource file to read.
      CreateResourceFile();
      
      // Enumerate the resources in the file.
      ResXResourceReader rr = new ResXResourceReader(resxFilename);
      rr.UseResXDataNodes = true;
      IDictionaryEnumerator dict = rr.GetEnumerator();
      while (dict.MoveNext()) {
         ResXDataNode node = (ResXDataNode) dict.Value;
         Console.WriteLine("{0,-20} {1,-20} {2}", 
                           node.Name + ":", 
                           node.GetValue((ITypeResolutionService) null), 
                           ! String.IsNullOrEmpty(node.Comment) ? "// " + node.Comment : "");
      }
   }

   private static void CreateResourceFile()
   {
      ResXResourceWriter rw = new ResXResourceWriter(resxFilename);
      string[] resNames = {"Country", "Population", "Area", 
                           "Capital", "LCity" };
      string[] columnHeaders = { "Country Name", "Population (2010}", 
                                 "Area", "Capital", "Largest City" };
      string[] comments = { "The localized country name", "", 
                            "The area in square miles", "", 
                            "The largest city based on 2010 data" };
      rw.AddResource("Title", "Country Information");
      rw.AddResource("nColumns", resNames.Length);
      for (int ctr = 0; ctr < resNames.Length; ctr++) {
         ResXDataNode node = new ResXDataNode(resNames[ctr], columnHeaders[ctr]);
         node.Comment = comments[ctr];
         rw.AddResource(node);
      }
      rw.Generate();
      rw.Close();
   }
}
// The example displays the following output:
//    Title:               Country Information
//    nColumns:            5
//    Country:             Country Name         // The localized country name
//    Population:          Population (2010}
//    Area:                Area                 // The area in square miles
//    Capital:             Capital
//    LCity:               Largest City         // The largest city based on 2010 data

Imports System.Collections
Imports System.ComponentModel.Design
Imports System.Resources

Module Example
   Private Const resxFilename As String = ".\CountryHeaders.resx"
     
   Public Sub Main()
      ' Create a resource file to read.
      CreateResourceFile()
      
      ' Enumerate the resources in the file.
      Dim rr As New ResXResourceReader(resxFilename)
      rr.UseResXDataNodes = True
      Dim dict As IDictionaryEnumerator = rr.GetEnumerator()
      Do While dict.MoveNext()
         Dim node As ResXDataNode = DirectCast(dict.Value, ResXDataNode)
         Console.WriteLine("{0,-20} {1,-20} {2}", 
                           node.Name + ":", 
                           node.GetValue(CType(Nothing, ITypeResolutionService)), 
                           If(Not String.IsNullOrEmpty(node.Comment), "// " + node.Comment, ""))
      Loop
   End Sub
   
   Private Sub CreateResourceFile()
      Dim rw As New ResxResourceWriter(resxFilename)
      Dim resNames() As String = {"Country", "Population", "Area", 
                                  "Capital", "LCity" }
      Dim columnHeaders() As String = { "Country Name", "Population (2010}", 
                                        "Area", "Capital", "Largest City" }
      Dim comments() As String = { "The localized country name", "", 
                                   "The area in square miles", "", 
                                   "The largest city based on 2010 data" }
      rw.AddResource("Title", "Country Information")
      rw.AddResource("nColumns", resNames.Length)
      For ctr As Integer = 0 To resNames.Length - 1
         Dim node As New ResXDataNode(resNames(ctr), columnHeaders(ctr))
         node.Comment = comments(ctr)
         rw.AddResource(node)
      Next
      rw.Generate()
      rw.Close()
   End Sub
End Module
' The example displays the following output:
'    Title:               Country Information
'    nColumns:            5
'    Country:             Country Name         // The localized country name
'    Population:          Population (2010}
'    Area:                Area                 // The area in square miles
'    Capital:             Capital
'    LCity:               Largest City         // The largest city based on 2010 data

Si UseResXDataNodes a la valeur true, les ResXDataNode éléments de l’énumération peuvent être :

  • Ressources nommées avec leurs données. Dans ce cas, la ResXDataNode.FileRef propriété est null.

  • Ressources nommées avec le nom du fichier qui contient les données de ressource. Dans ce cas, la ResXDataNode.FileRef propriété retourne un ResXFileRef objet qui fournit des informations sur la ressource, y compris son nom de fichier. Si des noms de fichiers relatifs sont utilisés, vous devez toujours définir la BasePath propriété pour fournir un point de référence pour le chemin du fichier relatif.

Si vous souhaitez récupérer des ressources nommées à partir d’un fichier .resx plutôt que d’énumérer ses ressources, vous pouvez instancier un ResXResourceSet objet et appeler ses GetString méthodes et GetObject .

Notes

La ResXResourceReader classe contient une demande de lien et une demande d’héritage au niveau de la classe qui s’applique à tous les membres. Une SecurityException exception est levée lorsque l’appelant immédiat ou la classe dérivée n’a pas d’autorisation de confiance totale.

Constructeurs

ResXResourceReader(Stream)

Initialise une nouvelle instance de la classe ResXResourceReader pour le flux spécifié.
ResXResourceReader(Stream, AssemblyName[])

Initialise une nouvelle instance de la classe ResXResourceReader en utilisant un flux et un tableau de noms d'assemblys.
ResXResourceReader(Stream, ITypeResolutionService)

Initialise une nouvelle instance de la classe ResXResourceReader en utilisant un flux d’entrée et un service de résolution de type.
ResXResourceReader(String)

Initialise une nouvelle instance de la classe ResXResourceReader pour le fichier de ressources spécifié.
ResXResourceReader(String, AssemblyName[])

Initialise une nouvelle instance de la classe ResXResourceReader en utilisant un nom de fichier de ressources XML et un tableau de noms d'assemblys.
ResXResourceReader(String, ITypeResolutionService)

Initialise une nouvelle instance de la classe ResXResourceReader en utilisant un nom de fichier et un service de résolution de type.
ResXResourceReader(TextReader)

Initialise une nouvelle instance de la classe ResXResourceReader pour le TextReader spécifié.
ResXResourceReader(TextReader, AssemblyName[])

Initialise une nouvelle instance de la classe ResXResourceReader en utilisant un objet TextReader et un tableau de noms d'assemblys.
ResXResourceReader(TextReader, ITypeResolutionService)

Initialise une nouvelle instance de la classe ResXResourceReader en utilisant un lecteur de flux de texte et un service de résolution de type.

Propriétés

BasePath

Obtient ou définit le chemin d'accès de base pour le chemin de fichier relatif spécifié dans un objet ResXFileRef.
UseResXDataNodes

Obtient ou définit une valeur qui indique si des objets ResXDataNode sont retournés pendant la lecture du flux ou du fichier de ressources XML actuel.

Méthodes

Close()

Libère toutes les ressources utilisées par ResXResourceReader.
Dispose(Boolean)

Libère les ressources non managées utilisées par ResXResourceReader et libère éventuellement les ressources managées.
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Finalize()

Ce membre se substitue à la méthode Finalize().
FromFileContents(String)

Crée un objet ResXResourceReader et l'initialise pour lire une chaîne dont le contenu se présente sous la forme d'un fichier de ressources XML.
FromFileContents(String, AssemblyName[])

Crée un objet ResXResourceReader et l'initialise pour lire une chaîne dont le contenu se présente sous la forme d'un fichier de ressources XML et pour utiliser un tableau d'objets AssemblyName afin de résoudre les noms de types spécifiés dans une ressource.
FromFileContents(String, ITypeResolutionService)

Crée un objet ResXResourceReader et l'initialise pour lire une chaîne dont le contenu se présente sous la forme d'un fichier de ressources XML et pour utiliser un objet ITypeResolutionService afin de résoudre les noms de types spécifiés dans une ressource.
GetEnumerator()

Retourne un énumérateur pour l'objet ResXResourceReader actuel.
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetMetadataEnumerator()

Fournit un énumérateur de dictionnaire qui peut récupérer les propriétés au moment du design du flux ou du fichier de ressources XML actuel.
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère les ressources non managées utilisées par ResXResourceReader et libère éventuellement les ressources managées. Pour obtenir une description de ce membre, consultez la méthode Dispose().
IEnumerable.GetEnumerator()

Retourne un énumérateur pour l'objet ResXResourceReader actuel. Pour obtenir une description de ce membre, consultez la méthode GetEnumerator().

Méthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)

Active la parallélisation d'une requête.
AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.

S’applique à

Voir aussi