ResXResourceReader Class

public sealed class ResXResourceReader : IResourceReader, 
	IEnumerable, IDisposable

Public NotInheritable Class ResXResourceReader
	Implements IResourceReader, IEnumerable, IDisposable

public ref class ResXResourceReader sealed : IResourceReader, 
	IEnumerable, IDisposable

[<SealedAttribute>]
type ResXResourceReader = 
    class
        interface IResourceReader
        interface IEnumerable
        interface IDisposable
    end

Inheritance

Object    ResXResourceReader

Implements

IEnumerable, IDisposable, IResourceReader

You can use the ResXResourceReader class to enumerate resources in .resx files by traversing the dictionary enumerator (IDictionaryEnumerator) that is returned by the GetEnumerator method. You call the methods provided by IDictionaryEnumerator to advance to the next resource and to read the name and value of each resource in the .resx file.

If the SafeMode property is , the value of the IDictionaryEnumerator.Value property is a ResXDataNode instance rather than the resource value. This makes possible to check the raw .resx content before deserialization if the .resx file is from an untrusted source. See also the example at ResXDataNode.

If you want to retrieve named resources from a .resx file rather than enumerating its resources, then you can instantiate a ResXResourceSet object and call its GetString/GetObject, GetMetaString/GetMetaObject and GetAliasValue methods. Also ResXResourceSet supports SafeMode.

Example

 using System;
 using System.Collections;
 using System.IO;
 using KGySoft.Resources;

 public class Example
 {
     private const string resx = @"<?xml version='1.0' encoding='utf-8'?>
 <root>
   <data name='string'>
     <value>Test string</value>
     <comment>Default data type is string.</comment>
   </data>

   <metadata name='meta string'>
     <value>Meta String</value>
   </metadata>

   <data name='int' type='System.Int32'>
     <value>42</value>
   </data>

   <assembly alias='CustomAlias' name='System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' />

   <data name='color' type='System.Drawing.Color, CustomAlias'>
     <value>Red</value>
     <comment>When this entry is deserialized, System.Drawing assembly will be loaded.</comment>
   </data>

   <data name='bytes' type='System.Byte[]'>
     <value>VGVzdCBieXRlcw==</value>
   </data>

   <data name='dangerous' mimetype='application/x-microsoft.net.object.binary.base64'>
     <value>YmluYXJ5</value>
     <comment>BinaryFormatter will throw an exception for this invalid content.</comment>
   </data>

 </root>";

    public static void Main()
    {
        var reader = new ResXResourceReader(new StringReader(resx));
        Console.WriteLine("____Resources in .resx:____");
        Dump(reader, reader.GetEnumerator);
        Console.WriteLine("____Metadata in .resx:____");
        Dump(reader, reader.GetMetadataEnumerator);
        Console.WriteLine("____Aliases in .resx:____");
        Dump(reader, reader.GetAliasEnumerator);
    }

    private static void Dump(ResXResourceReader reader, Func<IDictionaryEnumerator> getEnumeratorFunction)
    {
        var enumerator = getEnumeratorFunction();
        while (enumerator.MoveNext())
        {
            Console.WriteLine($"Name: {enumerator.Key}");
            reader.SafeMode = true;
            Console.WriteLine($"  Value in SafeMode:     {enumerator.Value} ({enumerator.Value.GetType()})");
            try
            {
                reader.SafeMode = false;
                Console.WriteLine($"  Value in non-SafeMode: {enumerator.Value} ({enumerator.Value.GetType()})");
            }
            catch (Exception e)
            {
                Console.WriteLine($"Getting the deserialized value thrown an exception: {e.Message}");
            }
            Console.WriteLine();
        }
    }
}

 // The example displays the following output:
 // ____Resources in .resx:____
 // Name: string
 // Value in SafeMode:     Test string (KGySoft.Resources.ResXDataNode)
 // Value in non-SafeMode: Test string (System.String)

 // Name: int
 // Value in SafeMode:     42 (KGySoft.Resources.ResXDataNode)
 // Value in non-SafeMode: 42 (System.Int32)

 // Name: color
 // Value in SafeMode:     Red (KGySoft.Resources.ResXDataNode)
 // Value in non-SafeMode: Color[Red] (System.Drawing.Color)

 // Name: bytes
 // Value in SafeMode:     VGVzdCBieXRlcw== (KGySoft.Resources.ResXDataNode)
 // Value in non-SafeMode: System.Byte[] (System.Byte[])

 // Name: dangerous
 // Value in SafeMode:     YmluYXJ5 (KGySoft.Resources.ResXDataNode)
 // Getting the deserialized value thrown an exception: End of Stream encountered before parsing was completed.

 // ____Metadata in .resx:____
 // Name: meta string
 // Value in SafeMode:     Meta String (KGySoft.Resources.ResXDataNode)
 // Value in non-SafeMode: Meta String (System.String)

 // ____Aliases in .resx:____
 // Name: CustomAlias
 // Value in SafeMode:     System.Drawing, Version= 4.0.0.0, Culture= neutral, PublicKeyToken= b03f5f7f11d50a3a (System.String)
 // Value in non-SafeMode: System.Drawing, Version= 4.0.0.0, Culture= neutral, PublicKeyToken= b03f5f7f11d50a3a (System.String)

By default, ResXResourceReader allows duplicated keys with different values (see AllowDuplicatedKeys property). Though such a .resx file is not strictly valid, its complete content can be retrieved. When AllowDuplicatedKeys is , GetEnumerator, GetMetadataEnumerator and GetAliasEnumerator return a lazy enumerator for the first time meaning the .resx file is parsed only during the enumeration. When any of the enumerators are obtained for the second time, a cached enumerator is returned with the whole parsed .resx content. If duplicates are disabled, the lastly defined values will be returned of a redefined name. This behavior is similar to the System.Resources.ResXResourceReader class, which does not allow duplicates.

Example

using System;
using System.Collections;
using System.IO;
using KGySoft.Resources;

public class Example
{
    private const string resx = @"<?xml version='1.0' encoding='utf-8'?>
<root>
  <data name='item'>
    <value>Test string</value>
  </data>

  <data name='item'>
    <value>This is a duplicate for key 'item'.</value>
  </data>
</root>";

    public static void Main()
    {
        // Allowing duplicates and lazy reading.
        Console.WriteLine("-------Lazy reading------");
        var reader = new ResXResourceReader(new StringReader(resx)) { AllowDuplicatedKeys = true };
        IDictionaryEnumerator enumerator = reader.GetEnumerator();
        Dump(enumerator); // if resx contains a syntax error, an exception is thrown during the enumeration.

        // Disabling duplicates and lazy reading
        Console.WriteLine("-------Greedy reading------");
        reader = new ResXResourceReader(new StringReader(resx)) { AllowDuplicatedKeys = false };
        enumerator = reader.GetEnumerator(); // if resx contains a syntax error, an exception is thrown here.
        Dump(enumerator);
    }

    private static void Dump(IDictionaryEnumerator enumerator)
    {
        while (enumerator.MoveNext())
        {
            Console.WriteLine($"Key: {enumerator.Key}");
            Console.WriteLine($"Value: {enumerator.Value}");
            Console.WriteLine();
        }
    }
}

// The example displays the following output:
// -------Lazy reading------
// Key: item
// Value: Test string
//
// Key: item
// Value: This is a duplicate for key 'item'.
//
// -------Greedy reading------
// Key: item
// Value: This is a duplicate for key 'item'.

Comparison with System.Resources.ResXResourceReader 

ResXResourceReader can read .resx files produced both by ResXResourceWriter and System.Resources.ResXResourceWriter.

Incompatibility with System.Resources.ResXResourceReader:

• Constructors do not have overloads with AssemblyName[] parameters. The System.Resources.ResXResourceReader uses them to load the assemblies in advance occasionally by calling the obsolete Assembly.LoadPartial method. However, this ResXResourceReader implementation uses the Reflector.ResolveType method, which does not use obsolete techniques (and if SafeMode is , then no type resolving, assembly loading and deserialization occurs at all, until explicit request). If you need a completely custom type resolution the constructor overloads with ITypeResolutionService parameters still can be used.
• This ResXResourceReader is a sealed class.
• After disposing the ResXResourceReader instance or calling the Close method the enumerators cannot be obtained: an ObjectDisposedException will be thrown on calling GetEnumerator, GetMetadataEnumerator and GetAliasEnumerator methods.
• After disposing the ResXResourceReader instance or calling the Close method every source stream will be closed (if any).
• Unlike System.Resources.ResXResourceReader, this implementation returns every resources and metadata of the same name by default. This behavior can be adjusted by AllowDuplicatedKeys property.
• System.Resources.ResXResourceReader often throws ArgumentException on getting the enumerator or on retrieving the value of a ResXDataNode instance, which contains invalid data. In contrast, this implementation may throw XmlException, TypeLoadException or NotSupportedException instead.
• Though the UseResXDataNodes property is still supported, it is obsolete in favor of SafeMode property.
• In System.Resources.ResXResourceReader if UseResXDataNodes property is , the resource and metadata entries are mixed in the returned enumerator, while when it is , then only the resources are returned. In this implementation the GetEnumerator always returns only the resources and GetMetadataEnumerator returns the metadata regardless of the value of the UseResXDataNodes and SafeMode properties.

New features and improvements compared to System.Resources.ResXResourceReader:

• Lazy processing – If AllowDuplicatedKeys is , the .resx file is processed on demand, during the actual enumeration. The .resx file is processed immediately if AllowDuplicatedKeys is . If AllowDuplicatedKeys is and any enumerator is obtained after getting one, the rest of the .resx file is immediately processed.
• Handling duplicates – If AllowDuplicatedKeys is , every occurrence of a duplicated name is returned by the enumerators. Otherwise, only the last occurrence of a name is returned.
• Headers – The .resx header is allowed to be completely missing; however, it is checked when exists and CheckHeader property is . If header tags contain invalid values a NotSupportedException may be thrown during the enumeration. You can configure the ResXResourceWriter class to omit the header by the ResXResourceWriter.OmitHeader property.
• Using ResXDataNode instances – The SafeMode (UseResXDataNodes) property can be toggled also after getting an enumerator or even during the enumeration.
• Clear purpose of the enumerators – The System.Resources.ResXResourceReader.GetEnumerator either returns resources only or returns both resources and metadata mixed together depending on the value of the System.Resources.ResXResourceReader.UseResXDataNodes property. This ResXResourceReader implementation has separated GetEnumerator, GetMetadataEnumerator and GetAliasEnumerator methods, which return always the resources, metadata and aliases, respectively.
• Security – If SafeMode is , no deserialization, assembly loading and type resolving occurs until a deserialization is explicitly requested by calling the ResXDataNode.GetValue or ResXDataNode.GetValueSafe methods on the IDictionaryEnumerator.Value instances returned by the GetEnumerator and GetMetadataEnumerator methods.
• Base path – The BasePath property, which is used for resolving file references can be set during the enumeration, too.
• New MIME type – A new MIME type text/kgysoft.net/object.binary.base64 is supported, indicating that an object is serialized by BinarySerializationFormatter instead of BinaryFormatter. The ResXResourceWriter can produce such .resx content if ResXResourceWriter.CompatibleFormat is .
• Soap formatter support (.NET Framework only) – The Soap formatter support is provided without referencing the System.Runtime.Serialization.Formatters.Soap.dll assembly. If the assembly cannot be loaded from the GAC (platform dependent), then a NotSupportedException will be thrown.
• Type resolving – If an ITypeResolutionService instance is passed to one of the constructors, it is used also for the type references in ResXFileRef instances.

Reference