ResourceReader Classe

Définition

Énumère les ressources dans un fichier de ressources binaire (.resources) en lisant les paires nom/valeur séquentielles de ressources.Enumerates the resources in a binary resources (.resources) file by reading sequential resource name/value pairs.

public ref class ResourceReader sealed : System::Resources::IResourceReader
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ResourceReader : System.Resources.IResourceReader
type ResourceReader = class
    interface IResourceReader
    interface IEnumerable
    interface IDisposable
Public NotInheritable Class ResourceReader
Implements IResourceReader
Héritage
ResourceReader
Attributs
Implémente

Remarques

Important

L’appel de méthodes de cette classe avec des données non approuvées est un risque de sécurité.Calling methods from this class with untrusted data is a security risk. Appelez les méthodes de cette classe avec des données approuvées uniquement.Call the methods from this class only with trusted data. Pour plus d’informations, consultez Validation des données.For more information, see Data Validation.

La classe ResourceReader fournit une implémentation standard de l’interface IResourceReader.The ResourceReader class provides a standard implementation of the IResourceReader interface. Une instance ResourceReader représente un fichier. Resources autonome ou un fichier. Resources incorporé dans un assembly.A ResourceReader instance represents either a standalone .resources file or a .resources file that is embedded in an assembly. Il est utilisé pour énumérer les ressources dans un fichier. Resources et récupérer ses paires nom/valeur.It is used to enumerate the resources in a .resources file and retrieve its name/value pairs. Il diffère de la classe ResourceManager, qui est utilisée pour récupérer des ressources nommées spécifiées à partir d’un fichier. Resources incorporé dans un assembly.It differs from the ResourceManager class, which is used to retrieve specified named resources from a .resources file that is embedded in an assembly. La classe ResourceManager est utilisée pour récupérer des ressources dont les noms sont connus à l’avance, tandis que la classe ResourceReader est utile pour récupérer des ressources dont le nombre ou les noms précis ne sont pas connus au moment de la compilation.The ResourceManager class is used to retrieve resources whose names are known in advance, whereas the ResourceReader class is useful for retrieving resources whose number or precise names are not known at compile time. Par exemple, une application peut utiliser un fichier de ressources pour stocker des informations de configuration qui sont organisées en sections et en éléments dans une section, où le nombre de sections ou d’éléments d’une section n’est pas connu à l’avance.For example, an application may use a resources file to store configuration information that is organized into sections and items in a section, where the number of sections or items in a section is not known in advance. Les ressources peuvent ensuite être nommées de façon générique (par exemple Section1, Section1Item1, Section1Item2, etc.) et récupérées à l’aide d’un objet ResourceReader.Resources can then be named generically (such as Section1, Section1Item1, Section1Item2, and so on) and retrieved by using a ResourceReader object.

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Pour plus d’informations sur l’utilisation de la classe ResourceReader, consultez les sections suivantes :For more information about using the ResourceReader class, see the following sections:

Instanciation d’un objet ResourceReaderInstantiating a ResourceReader Object

Un fichier. Resources est un fichier binaire qui a été compilé à partir d’un fichier texte ou d’un fichier XML. resx par Resgen. exe (générateur de fichiers de ressources).A .resources file is a binary file that has been compiled from either a text file or an XML .resx file by Resgen.exe (Resource File Generator). Un objet ResourceReader peut représenter soit un fichier. Resources autonome, soit un fichier. Resources qui a été incorporé dans un assembly.A ResourceReader object can represent either a standalone .resources file or a .resources file that has been embedded in an assembly.

Pour instancier un objet ResourceReader qui lit à partir d’un fichier. Resources autonome, utilisez le constructeur de classe ResourceReader avec un flux d’entrée ou une chaîne qui contient le nom de fichier. resources.To instantiate a ResourceReader object that reads from a standalone .resources file, use the ResourceReader class constructor with either an input stream or a string that contains the .resources file name. L’exemple suivant illustre ces deux approches.The following example illustrates both approaches. La première instancie un objet ResourceReader qui représente un fichier. resources nommé Resources1.resources à l’aide de son nom de fichier.The first instantiates a ResourceReader object that represents a .resources file named Resources1.resources by using its file name. Le deuxième instancie un objet ResourceReader qui représente un fichier. resources nommé Resources2.resources à l’aide d’un flux créé à partir du fichier.The second instantiates a ResourceReader object that represents a .resources file named Resources2.resources by using a stream created from the file.

// Instantiate a standalone .resources file from its filename.
var rr1 = new System.Resources.ResourceReader("Resources1.resources");

// Instantiate a standalone .resources file from a stream.
var fs = new System.IO.FileStream(@".\Resources2.resources",
                                  System.IO.FileMode.Open);
var rr2 = new System.Resources.ResourceReader(fs);      
' Instantiate a standalone .resources file from its filename.
Dim rr1 As New System.Resources.ResourceReader("Resources1.resources")

' Instantiate a standalone .resources file from a stream.
Dim fs As New System.IO.FileStream(".\Resources2.resources",
                                   System.IO.FileMode.Open)
Dim rr2 As New System.Resources.ResourceReader(fs)      

Pour créer un objet ResourceReader qui représente un fichier. Resources incorporé, instanciez un objet Assembly à partir de l’assembly dans lequel le fichier. Resources est incorporé.To create a ResourceReader object that represents an embedded .resources file, instantiate an Assembly object from the assembly in which the .resources file is embedded. Sa méthode Assembly.GetManifestResourceStream retourne un objet Stream qui peut être passé au constructeur ResourceReader(Stream).Its Assembly.GetManifestResourceStream method returns a Stream object that can be passed to the ResourceReader(Stream) constructor. L’exemple suivant instancie un objet ResourceReader qui représente un fichier. Resources incorporé.The following example instantiates a ResourceReader object that represents an embedded .resources file.

System.Reflection.Assembly assem = 
             System.Reflection.Assembly.LoadFrom(@".\MyLibrary.dll"); 
System.IO.Stream fs = 
             assem.GetManifestResourceStream("MyCompany.LibraryResources.resources");
var rr = new System.Resources.ResourceReader(fs); 
Dim assem As System.Reflection.Assembly = 
             System.Reflection.Assembly.LoadFrom(".\MyLibrary.dll") 
Dim fs As System.IO.Stream = 
             assem.GetManifestResourceStream("MyCompany.LibraryResources.resources")
Dim rr As New System.Resources.ResourceReader(fs) 

Énumération des ressources d’un objet ResourceReaderEnumerating a ResourceReader Object's Resources

Pour énumérer les ressources dans un fichier. Resources, vous appelez la méthode GetEnumerator, qui retourne un objet System.Collections.IDictionaryEnumerator.To enumerate the resources in a .resources file, you call the GetEnumerator method, which returns an System.Collections.IDictionaryEnumerator object. Vous appelez la méthode IDictionaryEnumerator.MoveNext pour passer d’une ressource à l’autre.You call the IDictionaryEnumerator.MoveNext method to move from one resource to the next. La méthode retourne false lorsque toutes les ressources du fichier. Resources ont été énumérées.The method returns false when all the resources in the .resources file have been enumerated.

Notes

Bien que la classe ResourceReader implémente l’interface IEnumerable et la méthode IEnumerable.GetEnumerator, la méthode ResourceReader.GetEnumerator ne fournit pas l’implémentation IEnumerable.GetEnumerator.Although the ResourceReader class implements the IEnumerable interface and the IEnumerable.GetEnumerator method, the ResourceReader.GetEnumerator method does not provide the IEnumerable.GetEnumerator implementation. Au lieu de cela, la méthode ResourceReader.GetEnumerator retourne un objet d’interface IDictionaryEnumerator qui fournit l’accès à la paire nom/valeur de chaque ressource.Instead, the ResourceReader.GetEnumerator method returns an IDictionaryEnumerator interface object that provides access to each resource's name/value pair.

Vous pouvez récupérer les ressources individuelles dans la collection de deux façons :You can retrieve the individual resources in the collection in two ways:

  • Vous pouvez effectuer une itération sur chaque ressource de la collection System.Collections.IDictionaryEnumerator et utiliser des propriétés System.Collections.IDictionaryEnumerator pour récupérer le nom et la valeur de la ressource.You can iterate each resource in the System.Collections.IDictionaryEnumerator collection and use System.Collections.IDictionaryEnumerator properties to retrieve the resource name and value. Nous vous recommandons cette technique lorsque toutes les ressources sont du même type, ou que vous connaissez le type de données de chaque ressource.We recommend this technique when all the resources are of the same type, or you know the data type of each resource.

  • Vous pouvez récupérer le nom de chaque ressource lorsque vous itérez le System.Collections.IDictionaryEnumerator collection et appeler la méthode GetResourceData pour récupérer les données de la ressource.You can retrieve the name of each resource when you iterate the System.Collections.IDictionaryEnumerator collection and call the GetResourceData method to retrieve the resource's data. Nous vous recommandons cette approche si vous ne connaissez pas le type de données de chaque ressource ou si l’approche précédente lève des exceptions.We recommend this approach when you do not know the data type of each resource or if the previous approach throws exceptions.

Récupération de ressources à l’aide des propriétés IDictionaryEnumeratorRetrieving Resources by Using IDictionaryEnumerator Properties

La première méthode d’énumération des ressources dans un fichier. Resources implique la récupération directe de la paire nom/valeur de chaque ressource.The first method of enumerating the resources in a .resources file involves directly retrieving each resource's name/value pair. Après avoir appelé la méthode IDictionaryEnumerator.MoveNext pour passer à chaque ressource de la collection, vous pouvez récupérer le nom de la ressource à partir de la propriété IDictionaryEnumerator.Key et des données de ressource de la propriété IDictionaryEnumerator.Value.After you call the IDictionaryEnumerator.MoveNext method to move to each resource in the collection, you can retrieve the resource name from the IDictionaryEnumerator.Key property and the resource data from the IDictionaryEnumerator.Value property.

L’exemple suivant montre comment récupérer le nom et la valeur de chaque ressource dans un fichier. Resources à l’aide des propriétés IDictionaryEnumerator.Key et IDictionaryEnumerator.Value.The following example shows how to retrieve the name and value of each resource in a .resources file by using the IDictionaryEnumerator.Key and IDictionaryEnumerator.Value properties. Pour exécuter l’exemple, créez le fichier texte suivant nommé ApplicationResources. txt pour définir des ressources de type chaîne.To run the example, create the following text file named ApplicationResources.txt to define string resources.

Title="Contact Information"  
Label1="First Name:"  
Label2="Middle Name:"  
Label3="Last Name:"  
Label4="SSN:"  
Label5="Street Address:"  
Label6="City:"  
Label7="State:"  
Label8="Zip Code:"  
Label9="Home Phone:"  
Label10="Business Phone:"  
Label11="Mobile Phone:"  
Label12="Other Phone:"  
Label13="Fax:"  
Label14="Email Address:"  
Label15="Alternate Email Address:"  

Vous pouvez ensuite convertir le fichier de ressources texte en un fichier binaire nommé ApplicationResources. Resources à l’aide de la commande suivante :You can then convert the text resource file to a binary file named ApplicationResources.resources by using the following command:

Resgen ApplicationResources. txtresgen ApplicationResources.txt

L’exemple suivant utilise ensuite la classe ResourceReader pour énumérer chaque ressource dans le fichier. Resources binaire autonome et afficher son nom de clé et sa valeur correspondante.The following example then uses the ResourceReader class to enumerate each resource in the standalone binary .resources file and to display its key name and corresponding value.

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

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Resources in ApplicationResources.resources:");
      ResourceReader res = new ResourceReader(@".\ApplicationResources.resources");
      IDictionaryEnumerator dict = res.GetEnumerator();
      while (dict.MoveNext())
         Console.WriteLine("   {0}: '{1}' (Type {2})", 
                           dict.Key, dict.Value, dict.Value.GetType().Name);
      res.Close();
   }
}
// The example displays the following output:
//       Resources in ApplicationResources.resources:
//          Label3: '"Last Name:"' (Type String)
//          Label2: '"Middle Name:"' (Type String)
//          Label1: '"First Name:"' (Type String)
//          Label7: '"State:"' (Type String)
//          Label6: '"City:"' (Type String)
//          Label5: '"Street Address:"' (Type String)
//          Label4: '"SSN:"' (Type String)
//          Label9: '"Home Phone:"' (Type String)
//          Label8: '"Zip Code:"' (Type String)
//          Title: '"Contact Information"' (Type String)
//          Label12: '"Other Phone:"' (Type String)
//          Label13: '"Fax:"' (Type String)
//          Label10: '"Business Phone:"' (Type String)
//          Label11: '"Mobile Phone:"' (Type String)
//          Label14: '"Email Address:"' (Type String)
//          Label15: '"Alternate Email Address:"' (Type String)
Imports System.Collections
Imports System.Resources

Module Example
   Public Sub Main()
      Console.WriteLine("Resources in ApplicationResources.resources:")
      Dim res As New ResourceReader(".\ApplicationResources.resources")
      Dim dict As IDictionaryEnumerator = res.GetEnumerator()
      Do While dict.MoveNext()
         Console.WriteLine("   {0}: '{1}' (Type {2})", dict.Key, dict.Value, dict.Value.GetType().Name)
      Loop
      res.Close()
   End Sub
End Module
' The example displays output like the following:
'       Resources in ApplicationResources.resources:
'          Label3: '"Last Name:"' (Type String)
'          Label2: '"Middle Name:"' (Type String)
'          Label1: '"First Name:"' (Type String)
'          Label7: '"State:"' (Type String)
'          Label6: '"City:"' (Type String)
'          Label5: '"Street Address:"' (Type String)
'          Label4: '"SSN:"' (Type String)
'          Label9: '"Home Phone:"' (Type String)
'          Label8: '"Zip Code:"' (Type String)
'          Title: '"Contact Information"' (Type String)
'          Label12: '"Other Phone:"' (Type String)
'          Label13: '"Fax:"' (Type String)
'          Label10: '"Business Phone:"' (Type String)
'          Label11: '"Mobile Phone:"' (Type String)
'          Label14: '"Email Address:"' (Type String)
'          Label15: '"Alternate Email Address:"' (Type String)

La tentative de récupération des données de ressources à partir de la propriété IDictionaryEnumerator.Value peut lever les exceptions suivantes :The attempt to retrieve resource data from the IDictionaryEnumerator.Value property can throw the following exceptions:

En règle générale, ces exceptions sont levées si le fichier. Resources a été modifié manuellement, si l’assembly dans lequel un type est défini n’a pas été inclus dans une application ou s’il a été supprimé par inadvertance, ou si l’assembly est une version antérieure qui met à jour type.Typically, these exceptions are thrown if the .resources file has been modified manually, if the assembly in which a type is defined has either not been included with an application or has been inadvertently deleted, or if the assembly is an older version that predates a type. Si l’une de ces exceptions est levée, vous pouvez récupérer des ressources en énumérant chaque ressource et en appelant la méthode GetResourceData, comme le montre la section suivante.If one of these exceptions is thrown, you can retrieve resources by enumerating each resource and calling the GetResourceData method, as the following section shows. Cette approche vous fournit des informations sur le type de données que la propriété IDictionaryEnumerator.Value a tenté de retourner.This approach provides you with some information about the data type that the IDictionaryEnumerator.Value property attempted to return.

Récupération des ressources par nom avec GetResourceDataRetrieving Resources by Name with GetResourceData

La deuxième approche de l’énumération des ressources dans un fichier. Resources consiste également à parcourir les ressources dans le fichier en appelant la méthode IDictionaryEnumerator.MoveNext.The second approach to enumerating resources in a .resources file also involves navigating through the resources in the file by calling the IDictionaryEnumerator.MoveNext method. Pour chaque ressource, vous récupérez le nom de la ressource à partir de la propriété IDictionaryEnumerator.Key, qui est ensuite transmise à la méthode GetResourceData(String, String, Byte[]) pour récupérer les données de la ressource.For each resource, you retrieve the resource's name from the IDictionaryEnumerator.Key property, which is then passed to the GetResourceData(String, String, Byte[]) method to retrieve the resource's data. Elle est retournée sous la forme d’un tableau d’octets dans l’argument resourceData.This is returned as a byte array in the resourceData argument.

Cette approche est plus compliquée que la récupération du nom et de la valeur de la ressource à partir des propriétés IDictionaryEnumerator.Key et IDictionaryEnumerator.Value, car elle retourne les octets réels qui constituent la valeur de la ressource.This approach is more awkward than retrieving the resource name and value from the IDictionaryEnumerator.Key and IDictionaryEnumerator.Value properties, because it returns the actual bytes that form the resource value. Toutefois, si la tentative de récupération de la ressource lève une exception, la méthode GetResourceData peut aider à identifier la source de l’exception en fournissant des informations sur le type de données de la ressource.However, if the attempt to retrieve the resource throws an exception, the GetResourceData method can help identify the source of the exception by supplying information about the resource's data type. Pour plus d’informations sur la chaîne qui indique le type de données de la ressource, consultez GetResourceData.For more information about the string that indicates the resource's data type, see GetResourceData.

L’exemple suivant illustre l’utilisation de cette approche pour récupérer des ressources et pour gérer les exceptions levées.The following example illustrates how to use this approach to retrieve resources and to handle any exceptions that are thrown. Il crée par programme un fichier. Resources binaire qui contient quatre chaînes, une valeur booléenne, un entier, une image bitmap et un objet DateTimeTZI personnalisé.It programmatically creates a binary .resources file that contains four strings, one Boolean, one integer, one bitmap, and one custom DateTimeTZI object. Pour exécuter l’exemple, procédez comme suit :To run the example, do the following:

  1. Créez un assembly nommé Library. dll qui contient la structure DateTimeTZI.Create an assembly named Library.dll that contains the DateTimeTZI structure. Voici le code source de l’assembly.The following is the source code for the assembly.

    using System;
    
    [Serializable] public struct DateTimeTZI
    {
      DateTime Date;
      TimeZoneInfo TimeZone;
       
      public DateTimeTZI(DateTime date, TimeZoneInfo tz)
      {
         this.Date = date;
         this.TimeZone = tz;
      }
    
       public override string ToString()
       {
         return String.Format("{0:dd/MM/yyyy hh:mm:ss tt} {1}", 
                              Date, TimeZone.StandardName);
       }
    }
    
    <Serializable> Public Structure DateTimeTZI
      Dim [Date] As DateTime
      Dim TimeZone As TimeZoneInfo
       
      Public Sub New([date] As DateTime, tz As TimeZoneInfo)
         Me.[Date] = [date]
         Me.TimeZone = tz
      End Sub
      
      Public Overrides Function ToString() As String
         Return String.Format("{0:dd/MM/yyyy hh:mm:ss tt} {1}", 
                              [Date], TimeZone.StandardName)
      End Function
    End Structure
    

    Compilez le code C# source dans à l’aide de la commande suivante :Compile the source code in C# by using the following command:

    csc /t:library library.cs  
    

    Vous pouvez le compiler dans Visual Basic à l’aide de la commande suivante :Or, you can compile it in Visual Basic by using the following command:

    vbc library.vb /t:library  
    
  2. Compilez et exécutez le code source suivant, qui crée un fichier. resources nommé ContactResources. resources.Compile and execute the following source code, which creates a .resources file named ContactResources.resources.

    using System;
    using System.Drawing;
    using System.Drawing.Imaging;
    using System.IO;
    using System.Resources;
    using System.Runtime.Serialization.Formatters.Binary;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          // Bitmap as stream.
          MemoryStream bitmapStream = new MemoryStream();
          Bitmap bmp = new Bitmap(@".\ContactsIcon.jpg");
          bmp.Save(bitmapStream, ImageFormat.Jpeg);
              
          // Define resources to be written.
          using (ResourceWriter rw = new ResourceWriter(@".\ContactResources.resources"))
          {
             rw.AddResource("Title", "Contact List");
             rw.AddResource("NColumns", 5);         
             rw.AddResource("Icon", bitmapStream);         
             rw.AddResource("Header1", "Name");
             rw.AddResource("Header2", "City");
             rw.AddResource("Header3", "State");  
             rw.AddResource("VersionDate", new DateTimeTZI(
                            new DateTime(2012, 5, 18),  
                            TimeZoneInfo.Local));
             rw.AddResource("ClientVersion", true);
             rw.Generate();
          }
       }
    }
    
    Imports System.Drawing
    Imports System.IO
    Imports System.Resources
    Imports System.Runtime.Serialization.Formatters.Binary
    
    Imports System.Text
    
    Module Example
       Public Sub Main()
          ' Bitmap as stream.
          Dim bitmapStream As New MemoryStream()
          Dim bmp As New Bitmap(".\ContactsIcon.jpg")
          bmp.Save(bitmapStream, Imaging.ImageFormat.jpeg)
              
          ' Define resources to be written.
          Using rw As New ResourceWriter(".\ContactResources.resources")
             rw.AddResource("Title", "Contact List")
             rw.AddResource("NColumns", 5)         
             rw.AddResource("Icon", bitmapStream)         
             rw.AddResource("Header1", "Name")
             rw.AddResource("Header2", "City")
             rw.AddResource("Header3", "State")  
             rw.AddResource("VersionDate", New DateTimeTZI(#05/18/2012#, 
                                                           TimeZoneInfo.Local))
             rw.AddResource("ClientVersion", True)
             rw.Generate()
          End Using
       End Sub
    End Module
    

    Le fichier de code source est nommé CreateResources.cs.The source code file is named CreateResources.cs. Vous pouvez la compiler dans C# à l’aide de la commande suivante :You can compile it in C# by using the following command:

    csc CreateResources.cs /r:library.dll  
    

    Vous pouvez le compiler dans Visual Basic à l’aide de la commande suivante :Or, you can compile it in Visual Basic by using the following command:

    vbc CreateResources.vb /r:library.dll  
    
  3. Compilez et exécutez le code suivant pour énumérer les ressources dans le fichier ContactResources. resources.Compile and run the following code to enumerate the resources in the ContactResources.resources file.

    using System;
    using System.Collections;
    using System.Drawing;
    using System.IO;
    using System.Resources;
    using System.Runtime.Serialization.Formatters.Binary;
    
    public class Example
    {
       public static void Main()
       {
          ResourceReader rdr = new ResourceReader(@".\ContactResources.resources");  
          IDictionaryEnumerator dict = rdr.GetEnumerator();
          while (dict.MoveNext()) {
             Console.WriteLine("Resource Name: {0}", dict.Key);
             try {
                Console.WriteLine("   Value: {0}", dict.Value);
             }
             catch (FileNotFoundException) {
                Console.WriteLine("   Exception: A file cannot be found.");
                DisplayResourceInfo(rdr, (string) dict.Key, false);
             }
             catch (FormatException) {
                Console.WriteLine("   Exception: Corrupted data.");
                DisplayResourceInfo(rdr, (string) dict.Key, true);
             }
             catch (TypeLoadException) {
                Console.WriteLine("   Exception: Cannot load the data type.");
                DisplayResourceInfo(rdr, (string) dict.Key, false);   
             }
          } 
       }
    
       private static void DisplayResourceInfo(ResourceReader rr, 
                                       string key, bool loaded)
       {                                
          string dataType = null;
          byte[] data = null;
          rr.GetResourceData(key, out dataType, out data);
                
          // Display the data type.
          Console.WriteLine("   Data Type: {0}", dataType);
          // Display the bytes that form the available data.      
          Console.Write("   Data: ");
          int lines = 0;
          foreach (var dataItem in data) {
             lines++;
             Console.Write("{0:X2} ", dataItem);
             if (lines % 25 == 0)
                Console.Write("\n         ");
          }
          Console.WriteLine();
          // Try to recreate current state of  data.
          // Do: Bitmap, DateTimeTZI
          switch (dataType) 
          {  
             // Handle internally serialized string data (ResourceTypeCode members).
             case "ResourceTypeCode.String":
                BinaryReader reader = new BinaryReader(new MemoryStream(data));
                string binData = reader.ReadString();
                Console.WriteLine("   Recreated Value: {0}", binData);
                break;
             case "ResourceTypeCode.Int32":
                Console.WriteLine("   Recreated Value: {0}", 
                                  BitConverter.ToInt32(data, 0));
                break;
             case "ResourceTypeCode.Boolean":
                Console.WriteLine("   Recreated Value: {0}", 
                                  BitConverter.ToBoolean(data, 0));
                break;
             // .jpeg image stored as a stream.
             case "ResourceTypeCode.Stream":  
                const int OFFSET = 4;
                int size = BitConverter.ToInt32(data, 0);
                Bitmap value1 = new Bitmap(new MemoryStream(data, OFFSET, size));
                Console.WriteLine("   Recreated Value: {0}", value1); 
                break;
             // Our only other type is DateTimeTZI.
             default:
                // No point in deserializing data if the type is unavailable.
                if (dataType.Contains("DateTimeTZI") && loaded) { 
                   BinaryFormatter binFmt = new BinaryFormatter();
                   object value2 = binFmt.Deserialize(new MemoryStream(data));
                   Console.WriteLine("   Recreated Value: {0}", value2);
                }    
                break;
          }
          Console.WriteLine();
       }
    }
    
    Imports System.Collections
    Imports System.Drawing
    Imports System.IO
    Imports System.Resources
    Imports System.Runtime.Serialization.Formatters.Binary
    
    Module Example
       Public Sub Main()
          Dim rdr As New ResourceReader(".\ContactResources.resources")  
          Dim dict As IDictionaryEnumerator = rdr.GetEnumerator()
          Do While dict.MoveNext()
             Console.WriteLine("Resource Name: {0}", dict.Key)
             Try
                Console.WriteLine("   Value: {0}", dict.Value)
             Catch e As FileNotFoundException
                Console.WriteLine("   Exception: A file cannot be found.")
                DisplayResourceInfo(rdr, CStr(dict.Key), False)
             Catch e As FormatException
                Console.WriteLine("   Exception: Corrupted data.")
                DisplayResourceInfo(rdr, CStr(dict.Key), True)
             Catch e As TypeLoadException
                Console.WriteLine("   Exception: Cannot load the data type.")
                DisplayResourceInfo(rdr, CStr(dict.Key), False)   
             End Try
          Loop 
       End Sub
    
       Private Sub DisplayResourceInfo(rr As ResourceReader, 
                                       key As String, loaded As Boolean)
          Dim dataType As String = Nothing
          Dim data() As Byte = Nothing
          rr.GetResourceData(key, dataType, data)
                
          ' Display the data type.
          Console.WriteLine("   Data Type: {0}", dataType)
          ' Display the bytes that form the available data.      
          Console.Write("   Data: ")
          Dim lines As Integer = 0
          For Each dataItem In data
             lines += 1
             Console.Write("{0:X2} ", dataItem)
             If lines Mod 25 = 0 Then Console.Write("{0}         ", vbCrLf)
          Next
          Console.WriteLine()
          ' Try to recreate current state of  data.
          ' Do: Bitmap, DateTimeTZI
          Select Case dataType   
             ' Handle internally serialized string data (ResourceTypeCode members).
             Case "ResourceTypeCode.String"
                Dim reader As New BinaryReader(New MemoryStream(data))
                Dim binData As String = reader.ReadString()
                Console.WriteLine("   Recreated Value: {0}", binData)
             Case "ResourceTypeCode.Int32"
                Console.WriteLine("   Recreated Value: {0}", 
                                  BitConverter.ToInt32(data, 0))
             Case "ResourceTypeCode.Boolean"
                Console.WriteLine("   Recreated Value: {0}", 
                                  BitConverter.ToBoolean(data, 0))
             ' .jpeg image stored as a stream.
             Case "ResourceTypeCode.Stream"  
                Const OFFSET As Integer = 4
                Dim size As Integer = BitConverter.ToInt32(data, 0)
                Dim value As New Bitmap(New MemoryStream(data, OFFSET, size))
                Console.WriteLine("   Recreated Value: {0}", value) 
             ' Our only other type is DateTimeTZI.
             Case Else
                ' No point in deserializing data if the type is unavailable.
                If dataType.Contains("DateTimeTZI") And loaded Then 
                   Dim binFmt As New BinaryFormatter()
                   Dim value As Object = binFmt.Deserialize(New MemoryStream(data))
                   Console.WriteLine("   Recreated Value: {0}", value)
                End If    
          End Select
          Console.WriteLine()
       End Sub
    End Module
    

    Après avoir modifié le code source (par exemple, en levant délibérément un FormatException à la fin du bloc try) ou en renommant l’assembly. dll de la bibliothèque afin qu’il ne soit pas disponible au moment de l’exécution, vous pouvez exécuter l’exemple pour voir comment les appels à GetResourceData vous permettent d’extraire ou de recréer des informations sur les ressources.After modifying the source code (for example, by deliberately throwing a FormatException at the end of the try block) or renaming the Library.dll assembly so that it is unavailable at runtime, you can run the example to see how calls to GetResourceData enable you to retrieve or recreate some resource information.

Constructeurs

ResourceReader(Stream)

Initialise une nouvelle instance de la classe ResourceReader pour le flux spécifié.Initializes a new instance of the ResourceReader class for the specified stream.

ResourceReader(String)

Initialise une nouvelle instance de la classe ResourceReader pour le fichier de ressources nommé spécifié.Initializes a new instance of the ResourceReader class for the specified named resource file.

Méthodes

Close()

Libère toutes les ressources du système d'exploitation associées à cet objet ResourceReader.Releases all operating system resources associated with this ResourceReader object.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe ResourceReader.Releases all resources used by the current instance of the ResourceReader class.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetEnumerator()

Retourne un énumérateur pour cet objet ResourceReader.Returns an enumerator for this ResourceReader object.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetResourceData(String, String, Byte[])

Récupère le nom du type et les données d'une ressource nommée à partir d'un fichier de ressources ouvert ou d'un flux.Retrieves the type name and data of a named resource from an open resource file or stream.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère les ressources utilisées par le ResourceReader.Releases the resources used by the ResourceReader.

IEnumerable.GetEnumerator()

Retourne un énumérateur pour cet objet ResourceReader.Returns an enumerator for this ResourceReader object.

Méthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à