ResXResourceSet Class

[SerializableAttribute]
public sealed class ResXResourceSet : ResourceSet, 
	IExpandoResourceSet, IDisposable, IEnumerable

 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 set = new ResXResourceSet(new StringReader(resx));
        Console.WriteLine("____Resources in .resx:____");
        Dump(set, set.GetEnumerator);
        Console.WriteLine("____Metadata in .resx:____");
        Dump(set, set.GetMetadataEnumerator);
        Console.WriteLine("____Aliases in .resx:____");
        Dump(set, set.GetAliasEnumerator);
    }

    private static void Dump(ResXResourceSet set, Func<IDictionaryEnumerator> getEnumeratorFunction)
    {
        var enumerator = getEnumeratorFunction();
        while (enumerator.MoveNext())
        {
            Console.WriteLine($"Name: {enumerator.Key}");
            set.SafeMode = true;
            Console.WriteLine($"  Value in SafeMode:     {enumerator.Value} ({enumerator.Value.GetType()})");
            try
            {
                set.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)

using System;
using System.IO;
using System.Text;
using KGySoft.Resources;

public class Example
{
    public static void Main()
    {
        const string key = "myKey";
        var set = new ResXResourceSet();

        // GetString/GetObject: reads a resource by key (GetMetaString/GetMetaObject for metadata, GetAliasValue for alias)
        Console.WriteLine($"Getting a non-existing key: {set.GetString(key) ?? "<null>"}");

        // SetObject: adds a new resource or replaces an existing one (SetMetaObject for metadata, SetAliasValue for assembly alias)
        // you can even remove entries by RemoveObject/RemoveMetaObject/RemoveAliasValue)
        set.SetObject(key, "a string value");
        Console.WriteLine($"Getting an existing key: {set.GetString(key) ?? "<null>"}");

        var savedContent = new StringBuilder();
        set.Save(new StringWriter(savedContent), compatibleFormat: false); // try compatibleFormat: true as well
        Console.WriteLine("Saved .resx content:");
        Console.WriteLine(savedContent);
    }
}

// The example displays the following output:
// Getting a non-existing key: <null>
// Getting an existing key: a string value
// Saved .resx content:
// <?xml version="1.0" encoding="utf-8"?>
// <root>
//   <data name="myKey">
//     <value>a string value</value>
//   </data>
// </root>

using System;
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 (when there is neither 'type' nor 'mimetype' attribute).</comment>
  </data>

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

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

    public static void Main()
    {
        // please note that default value of SafeMode is false. Nevertheless, reading the .resx containing an invalid node (dangerous)
        // will not cause any problem because nothing is deserialized yet.
        var set = ResXResourceSet.FromFileContents(resx); // same as "new ResXResourceSet(new StringReader(resx));"

        // enabling SafeMode changes the GetObject/GetString behavior
        set.SafeMode = true;

        Console.WriteLine($"Return type of GetObject in safe mode: {set.GetObject("string").GetType()}");

        Console.WriteLine();
        Console.WriteLine("*** Demonstrating SafeMode=true ***");
        TreatSafely(set, "unknown");
        TreatSafely(set, "string");
        TreatSafely(set, "binary");
        TreatSafely(set, "dangerous");

        set.SafeMode = false;
        Console.WriteLine();
        Console.WriteLine("*** Demonstrating SafeMode=false ***");
        TreatUnsafely(set, "unknown");
        TreatUnsafely(set, "string");
        TreatUnsafely(set, "binary");
        TreatUnsafely(set, "dangerous");
    }

    private static void TreatSafely(ResXResourceSet set, string resourceName)
    {
        // in SafeMode GetObject returns a ResXDataNode
        var resource = set.GetObject(resourceName) as ResXDataNode;
        if (resource == null)
        {
            Console.WriteLine($"Resource name '{resourceName}' does not exist in resource set or SafeMode is off.");
            return;
        }

        if (resource.TypeName == null && resource.MimeType == null)
        {
            // to deserialize a node considered safe call GetValue
            Console.WriteLine($"Resource with name '{resourceName}' is a string so it is safe. Its value is '{resource.GetValue()}'");
            return;
        }

        if (resource.TypeName != null)
        {
            Console.WriteLine($"Resource with name '{resourceName}' is a '{resource.TypeName}'. If we trust this type we can call GetValue to deserialize it.");
        }
        else
        {
            Console.WriteLine($"Resource with name '{resourceName}' has only mime type: '{resource.MimeType}'.");
            Console.WriteLine("  We cannot tell its type before we deserialize it. We can consider this entry potentially dangerous.");
        }

        // In SafeMode GetString(resourceName) never fails.
        // resource.ValueData is similar but ValueData can be null if we allow cleanup .resx content after deserialization.
        Console.WriteLine($"  Raw string value: {set.GetString(resourceName)}");
    }

    private static void TreatUnsafely(ResXResourceSet set, string resourceName)
    {
        // If SafeMode is false, GetObject returns null for existing resources containing null value, too.
        // Use ContainsResource to distinct non-existing and null values.
        if (!set.ContainsResource(resourceName))
        {
            Console.WriteLine($"The resource set does not contain a resource named '{resourceName}'.");
            return;
        }
        try
        {
            // If SafeMode is false, GetObject tries to deserialize the resource.
            // GetString would throw an InvalidOperationException on non-string values.
            var value = set.GetObject(resourceName);
            Console.WriteLine($"Type of resource with name '{resourceName}' is {value?.GetType().ToString() ?? "<none>"}. String representation: {value ?? "<null>"}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"Obtaining '{resourceName}' failed with an error: {e.Message}");
        }
    }
}

// The example displays the following output:
// Return type of GetObject in safe mode: KGySoft.Resources.ResXDataNode
// 
// *** Demonstrating SafeMode=true ***
// Resource name 'unknown' does not exist in resource set or SafeMode is off.
// Resource with name 'string' is a string so it is safe. Its value is 'Test string'
// Resource with name 'binary' is a 'System.Byte[]'. If we trust this type we can call GetValue to deserialize it.
//   Raw string value: VGVzdCBieXRlcw==
// Resource with name 'dangerous' has only mime type: 'application/x-microsoft.net.object.binary.base64'.
//   We cannot tell its type before we deserialize it. We can consider this entry potentially dangerous.
//   Raw string value: boo!
// 
// *** Demonstrating SafeMode=false ***
// The resource set does not contain a resource named 'unknown'.
// Type of resource with name 'string' is System.String. String representation: Test string
// Type of resource with name 'binary' is System.Byte[]. String representation: System.Byte[]
// Obtaining 'dangerous' failed with an error: The input is not a valid Base-64 string as it contains a non-base 64 character,
// more than two padding characters, or an illegal character among the padding characters.