ResourceReader ResourceReader ResourceReader ResourceReader Class

Definizione

Enumera le risorse in un file di risorse (.resources) binario leggendo le coppie nome/valore delle risorse sequenziali.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
Ereditarietà
ResourceReaderResourceReaderResourceReaderResourceReader
Attributi
Implementazioni

Commenti

Importante

La chiamata a metodi da questa classe con dati non attendibili costituisce un rischio per la sicurezza.Calling methods from this class with untrusted data is a security risk. Chiamare i metodi da questa classe solo con dati attendibili.Call the methods from this class only with trusted data. Per altre informazioni, vedere Data Validation (Convalida dei dati).For more information, see Data Validation.

Il ResourceReader classe fornisce un'implementazione standard del IResourceReader interfaccia.The ResourceReader class provides a standard implementation of the IResourceReader interface. Oggetto ResourceReader istanza rappresenta un file con estensione resources autonomo o un file con estensione resources incorporato in un assembly.A ResourceReader instance represents either a standalone .resources file or a .resources file that is embedded in an assembly. Viene utilizzato per enumerare le risorse in un file con estensione resources e recuperare le coppie nome/valore.It is used to enumerate the resources in a .resources file and retrieve its name/value pairs. Si differenzia dal ResourceManager classe, che viene usato per recuperare risorse denominate specificate da un file con estensione resources incorporato in 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. Il ResourceManager classe viene utilizzata per recuperare le risorse i cui nomi sono noti in anticipo, mentre il ResourceReader classe è utile per il recupero di risorse il cui numero o i nomi esatti non sono noti in fase di compilazione.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. Ad esempio, un'applicazione può usare un file di risorse per archiviare le informazioni di configurazione sono organizzate in sezioni e gli elementi in una sezione, in cui il numero di elementi in una sezione o sezioni non è noto in anticipo.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. Le risorse possono quindi essere denominate in modo generico (ad esempio Section1, Section1Item1, Section1Item2e così via) e recuperati utilizzando un ResourceReader oggetto.Resources can then be named generically (such as Section1, Section1Item1, Section1Item2, and so on) and retrieved by using a ResourceReader object.

Importante

Questo tipo implementa la IDisposable interfaccia.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare il tipo direttamente, chiamare relativi Dispose metodo in un try / catch blocco.To dispose of the type directly, call its Dispose method in a try/catch block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Utilizzo di oggetti che implementano IDisposable" nel IDisposable argomento relativo all'interfaccia.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Per altre informazioni sull'uso di ResourceReader di classi, vedere le sezioni seguenti:For more information about using the ResourceReader class, see the following sections:

Creare un'istanza di un oggetto ResourceReaderInstantiating a ResourceReader Object

Un file con estensione resources è un file binario compilato da un file di testo o un file XML con estensione resx Resgen.exe (Resource File Generator).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). Oggetto ResourceReader oggetto può rappresentare un file con estensione resources autonomo o un file con estensione resources incorporato in un assembly.A ResourceReader object can represent either a standalone .resources file or a .resources file that has been embedded in an assembly.

Creare un'istanza di un ResourceReader dell'oggetto che legge da un file. resources autonomi, usare il ResourceReader costruttore di classe con un flusso di input o una stringa che contiene il nome del file con estensione 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'esempio seguente illustra entrambi gli approcci.The following example illustrates both approaches. Il primo crea un ResourceReader oggetto che rappresenta un file con estensione resources denominato Resources1.resources utilizzando il nome di file.The first instantiates a ResourceReader object that represents a .resources file named Resources1.resources by using its file name. Il secondo crea un ResourceReader oggetto che rappresenta un file con estensione resources denominato Resources2.resources usando un flusso creato dal file.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)      

Per creare un ResourceReader creare un'istanza di oggetto che rappresenta un file con estensione resources incorporato, un Assembly oggetto dall'assembly in cui è incorporato il file con estensione resources.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. Relativi Assembly.GetManifestResourceStream metodo restituisce un Stream oggetto che può essere passato al ResourceReader(Stream) costruttore.Its Assembly.GetManifestResourceStream method returns a Stream object that can be passed to the ResourceReader(Stream) constructor. Nell'esempio seguente crea un ResourceReader oggetto che rappresenta un file con estensione resources incorporato.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) 

L'enumerazione delle risorse dell'oggetto ResourceReaderEnumerating a ResourceReader Object's Resources

Per enumerare le risorse in un file con estensione resources, si chiama il GetEnumerator metodo, che restituisce un System.Collections.IDictionaryEnumerator oggetto.To enumerate the resources in a .resources file, you call the GetEnumerator method, which returns an System.Collections.IDictionaryEnumerator object. Si chiama il IDictionaryEnumerator.MoveNext metodo per passare da una risorsa a quella successiva.You call the IDictionaryEnumerator.MoveNext method to move from one resource to the next. Il metodo restituisce false quando tutte le risorse nel file con estensione resources sono state enumerate.The method returns false when all the resources in the .resources file have been enumerated.

Nota

Anche se il ResourceReader classe implementa le IEnumerable interfaccia e il IEnumerable.GetEnumerator metodo, il ResourceReader.GetEnumerator metodo non fornisce il IEnumerable.GetEnumerator implementazione.Although the ResourceReader class implements the IEnumerable interface and the IEnumerable.GetEnumerator method, the ResourceReader.GetEnumerator method does not provide the IEnumerable.GetEnumerator implementation. Al contrario, il ResourceReader.GetEnumerator metodo restituisce un IDictionaryEnumerator oggetto di interfaccia che consente di accedere alla coppia nome/valore di ogni risorsa.Instead, the ResourceReader.GetEnumerator method returns an IDictionaryEnumerator interface object that provides access to each resource's name/value pair.

È possibile recuperare le singole risorse nella raccolta in due modi:You can retrieve the individual resources in the collection in two ways:

Recupero di risorse usando le proprietà IDictionaryEnumeratorRetrieving Resources by Using IDictionaryEnumerator Properties

Il primo metodo di enumerare le risorse in un file con estensione resources richiede direttamente il recupero di coppia nome/valore di ogni risorsa.The first method of enumerating the resources in a .resources file involves directly retrieving each resource's name/value pair. Dopo aver chiamato il IDictionaryEnumerator.MoveNext nome del metodo per spostare a ogni risorsa della raccolta, è possibile recuperare la risorsa dal IDictionaryEnumerator.Key proprietà e i dati delle risorse dal IDictionaryEnumerator.Value proprietà.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.

Nell'esempio seguente viene illustrato come recuperare il nome e il valore di ogni risorsa in un file con estensione resources utilizzando il IDictionaryEnumerator.Key e IDictionaryEnumerator.Value proprietà.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. Per eseguire l'esempio, creare il seguente file di testo denominato ApplicationResources.txt per definire risorse di tipo stringa.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:"  

È possibile convertire il file di risorse di testo in un file binario denominato ApplicationResources.resources usando il comando seguente: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'esempio seguente usa quindi il ResourceReader classe per enumerare ogni risorsa nel file binari. resources autonomi e per visualizzare il nome della chiave e il valore corrispondente.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)

Il tentativo di recuperare i dati di risorse di IDictionaryEnumerator.Value proprietà possono essere generate le eccezioni seguenti:The attempt to retrieve resource data from the IDictionaryEnumerator.Value property can throw the following exceptions:

  • Oggetto FormatException se i dati non sono nel formato previsto.A FormatException if the data is not in the expected format.

  • Oggetto FileNotFoundException se non è possibile trovare l'assembly che contiene il tipo a cui appartengono i dati.A FileNotFoundException if the assembly that contains the type to which the data belongs cannot be found.

  • Oggetto TypeLoadException se non può essere il tipo a cui appartengono i dati non è stata trovata.A TypeLoadException if the type to which the data belongs cannot be cannot be found.

In genere, vengono generate queste eccezioni se il file con estensione resources è stato modificato manualmente, se è non è stato incluso in un'applicazione, l'assembly in cui è definito un tipo oppure è stata eliminata involontariamente o se l'assembly è una versione precedente che è precedente alla data un tipo.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. Se viene generata una di queste eccezioni, è possibile recuperare le risorse mediante l'enumerazione di ogni risorsa e la chiamata di GetResourceData (metodo), come illustrato nella sezione seguente.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. Questo approccio offre alcune informazioni sui dati di tipo che il IDictionaryEnumerator.Value ha tentato di proprietà da restituire.This approach provides you with some information about the data type that the IDictionaryEnumerator.Value property attempted to return.

Il recupero delle risorse in base al nome con GetResourceDataRetrieving Resources by Name with GetResourceData

Il secondo approccio per l'enumerazione delle risorse in un file con estensione resources prevede anche esplorare le risorse nel file chiamando la IDictionaryEnumerator.MoveNext (metodo).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. Per ogni risorsa, si recupera il nome della risorsa dal IDictionaryEnumerator.Key proprietà, che viene quindi passato al GetResourceData(String, String, Byte[]) metodo per recuperare i dati della risorsa.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. Viene restituito come matrice di byte nel resourceData argomento.This is returned as a byte array in the resourceData argument.

Questo approccio è più complesse rispetto al recupero il nome della risorsa e il valore dal IDictionaryEnumerator.Key e IDictionaryEnumerator.Value proprietà, perché restituisce i byte effettivi che costituiscono il valore della risorsa.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. Tuttavia, se il tentativo di recuperare la risorsa genera un'eccezione, il GetResourceData metodo consentono di identificare l'origine dell'eccezione fornendo informazioni sul tipo di dati della risorsa.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. Per altre informazioni sulla stringa che indica il tipo di dati della risorsa, vedere GetResourceData.For more information about the string that indicates the resource's data type, see GetResourceData.

L'esempio seguente illustra come usare questo approccio per recuperare le risorse e per gestire le eccezioni generate.The following example illustrates how to use this approach to retrieve resources and to handle any exceptions that are thrown. A livello di codice crea un file. Resources binario che contiene quattro stringhe, un valore booleano, un numero intero, una singola bitmap e uno personalizzato DateTimeTZI oggetto.It programmatically creates a binary .resources file that contains four strings, one Boolean, one integer, one bitmap, and one custom DateTimeTZI object. Per eseguire l'esempio, eseguire le operazioni seguenti:To run the example, do the following:

  1. Creare un assembly denominato Library. dll che contiene il DateTimeTZI struttura.Create an assembly named Library.dll that contains the DateTimeTZI structure. Di seguito è riportato il codice sorgente per 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
    

    Compilare il codice sorgente in C# usando il comando seguente:Compile the source code in C# by using the following command:

    csc /t:library library.cs  
    

    In alternativa, è possibile compilarlo in Visual Basic usando il comando seguente:Or, you can compile it in Visual Basic by using the following command:

    vbc library.vb /t:library  
    
  2. Compilare ed eseguire il seguente codice sorgente, che crea un file con estensione resources denominato 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
    

    File del codice sorgente è denominato CreateResources.cs.The source code file is named CreateResources.cs. È possibile compilare in C# usando il comando seguente:You can compile it in C# by using the following command:

    csc CreateResources.cs /r:library.dll  
    

    In alternativa, è possibile compilarlo in Visual Basic usando il comando seguente:Or, you can compile it in Visual Basic by using the following command:

    vbc CreateResources.vb /r:library.dll  
    
  3. Compilare ed eseguire il codice seguente per enumerare le risorse nel file 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
    

    Dopo aver modificato il codice sorgente (ad esempio, generando deliberatamente una FormatException alla fine del try blocco) o rinominare l'assembly DLL in modo che non è disponibile in fase di esecuzione, è possibile eseguire l'esempio per vedere come le chiamate a GetResourceData consentono di recuperare o la ricreazione di alcune informazioni sulle risorse.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.

Costruttori

ResourceReader(Stream) ResourceReader(Stream) ResourceReader(Stream) ResourceReader(Stream)

Inizializza una nuova istanza della classe ResourceReader per il flusso specificato.Initializes a new instance of the ResourceReader class for the specified stream.

ResourceReader(String) ResourceReader(String) ResourceReader(String) ResourceReader(String)

Inizializza una nuova istanza della classe ResourceReader per il file di risorse denominato specificato.Initializes a new instance of the ResourceReader class for the specified named resource file.

Metodi

Close() Close() Close() Close()

Rilascia tutte le risorse del sistema operativo associate a questo oggetto ResourceReader.Releases all operating system resources associated with this ResourceReader object.

Dispose() Dispose() Dispose() Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe ResourceReader.Releases all resources used by the current instance of the ResourceReader class.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Restituisce un enumeratore per questo oggetto ResourceReader.Returns an enumerator for this ResourceReader object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetResourceData(String, String, Byte[]) GetResourceData(String, String, Byte[]) GetResourceData(String, String, Byte[]) GetResourceData(String, String, Byte[])

Recupera il nome del tipo e i dati di una risorsa denominata da un file di risorse o da un flusso aperto.Retrieves the type name and data of a named resource from an open resource file or stream.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Rilascia le risorse usate da ResourceReader.Releases the resources used by the ResourceReader.

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Restituisce un enumeratore per questo oggetto ResourceReader.Returns an enumerator for this ResourceReader object.

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte un' IEnumerable a un IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a