ResXDataNode Class

[SerializableAttribute]
public sealed class ResXDataNode : ISerializable, 
	ICloneable

<SerializableAttribute>
Public NotInheritable Class ResXDataNode
	Implements ISerializable, ICloneable

[SerializableAttribute]
public ref class ResXDataNode sealed : ISerializable, 
	ICloneable

[<SealedAttribute>]
[<SerializableAttribute>]
type ResXDataNode = 
    class
        interface ISerializable
        interface ICloneable
    end

Inheritance

Object    ResXDataNode

Implements

ICloneable, ISerializable

The ResXDataNode class supports the representation of rich data types within a resource file. It can support the storage of any object in a resource file.

You can create a ResXDataNode object by calling one of its overloaded class constructors. You can then add the resource item or element to a resource file by one of the following options:

• Call the ResXResourceWriter.AddResource(ResXDataNode) or ResXResourceWriter.AddMetadata(ResXDataNode) method.
• Call the ResXResourceSet.SetObject(string, object) or ResXResourceSet.SetMetaObject(string, object) method and then call the Save method on it.
• Call the SetObject or SetMetaObject method on any IExpandoResourceManager implementation (such as ResXResourceManager, HybridResourceManager, DynamicResourceManager) and then call the SaveResourceSet or SaveAllResources methods on them.

To retrieve a ResXDataNode object from a resource you have the following options:

• Enumerate the ResXDataNode objects in an XML (.resx file) by instantiating a ResXResourceReader object, setting the ResXResourceReader.SafeMode property to , and calling the ResXResourceReader.GetEnumerator or ResXResourceReader.GetMetadataEnumerator method to get an enumerator. See also the example below.
• Instantiate a new ResXResourceSet from a .resx file, set ResXResourceSet.SafeMode to , and call the ResXResourceSet.GetObject or ResXResourceSet.GetMetaObject methods with a key, which exists in the .resx file. You can use the ResXResourceSet.GetEnumerator and ResXResourceSet.GetMetadataEnumerator methods in a similar way as in case of the ResXResourceReader class.
• Instantiate a new ResXResourceManager/HybridResourceManager or DynamicResourceManager class, set SafeMode to , and call the GetObject or GetMetaObject methods with a key, which exists in the .resx file.

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 in an unsafe way, 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()
    {
        // In SafeMode the enumerator values will be ResXDataNode instances instead of deserialized objects
        var reader = new ResXResourceReader(new StringReader(resx)) { SafeMode = true };

        Console.WriteLine("____Resources in .resx:____");
        Dump(reader.GetEnumerator());

        Console.WriteLine("____Metadata in .resx:____");
        Dump(reader.GetMetadataEnumerator());
    }

    private static void Dump(IDictionaryEnumerator enumerator)
    {
        while (enumerator.MoveNext())
        {
            var node = (ResXDataNode)enumerator.Value;
            Console.WriteLine($"Name: {node.Name}");
            Console.WriteLine($"  Type:        {node.TypeName}");
            Console.WriteLine($"  Alias value: {node.AssemblyAliasValue}");
            Console.WriteLine($"  MIME type:   {node.MimeType}");
            Console.WriteLine($"  Comment:     {node.Comment}");
            Console.WriteLine($"  Raw value:   {node.ValueData}");
            try
            {
                var value = node.GetValueSafe();
                Console.WriteLine($"  Real value:  {value} ({value.GetType()})");
            }
            catch (Exception e)
            {
                Console.WriteLine($"  Safe deserialization of the node threw an exception: {e.Message}");
                try
                {
                    var value = node.GetValue();
                    Console.WriteLine($"  Real value (unsafe):  {value} ({value.GetType()})");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"  Unsafe deserialization of the node threw an exception: {ex.Message}");
                }
            }
            Console.WriteLine();
        }
    }
}

// The example displays the following output:
//  ____Resources in .resx:____
// Name: string
//   Type:
//   Alias value:
//   MIME type:
//   Comment:     Default data type is string.
//   Raw value:   Test string
//   Real value:  Test string (System.String)
// 
// Name: int
//   Type:        System.Int32
//   Alias value:
//   MIME type:
//   Comment:
//   Raw value:   42
//   Real value:  42 (System.Int32)
// 
// Name: color
//   Type:        System.Drawing.Color, CustomAlias
//   Alias value: System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
//   MIME type:
//   Comment:     When this entry is deserialized in an unsafe way, System.Drawing assembly will be loaded.
//   Raw value:   Red
//   Safe deserialization of the node threw an exception: Type "System.Drawing.Color, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" in the data at line 18, position 4 cannot be resolved.
// You may try to specify the expected type or use the unsafe GetValue if the resource is from a trusted source.
//   Real value (unsafe):  Color[Red] (System.Drawing.Color)
// 
// Name: bytes
//  Type:        System.Byte[]
//  Alias value:
//   MIME type:
//   Comment:
//   Raw value:   VGVzdCBieXRlcw==
//   Real value:  System.Byte[] (System.Byte[])
// 
// Name: dangerous
//   Type:
//   Alias value:
//   MIME type:   application/x-microsoft.net.object.binary.base64
//   Comment:     BinaryFormatter will throw an exception for this invalid content.
//   Raw value:   YmluYXJ5
//   Safe deserialization of the node threw an exception: In safe mode it is not allowed to deserialize resource "dangerous" because it was serialized by BinaryFormatter. Line 27, position 4.
//   Unsafe deserialization of the node threw an exception: End of Stream encountered before parsing was completed.
// 
// ____Metadata in .resx:____
// Name: meta string
//   Type:
//   Alias value:
//   MIME type:
//   Comment:
//   Raw value:   Meta String
//   Real value:  Meta String (System.String)

Comparison with System.Resources.ResXDataNode 

If instantiated from a System.Resources.ResXDataNode or System.Resources.ResXFileRef instance, an internal conversion into KGySoft.Resources.ResXDataNode and KGySoft.Resources.ResXFileRef automatically occurs.

Unlike System.Resources.ResXDataNode, this ResXDataNode implementation really preserves the original information stored in the .resx file. No deserialization, assembly loading and type resolving occurs until a deserialization is explicitly requested by calling the GetValue or GetValueSafe methods.

Incompatibility with System.Resources.ResXDataNode:

• Name property is read-only. If you want to use a new name, instantiate a new ResXDataNode instance by the ResXDataNode(string, object) constructor and pass the new name and the original ResXDataNode as parameters.
• There are no GetValueTypeName methods. The problem with System.Resources.ResXDataNode.GetValueTypeName methods is that they are unsafe as they may deserialize the inner object, load assemblies and can throw various unexpected exceptions. Instead, you can read the original type information stored in the .resx file by TypeName and AssemblyAliasValue properties. Based on the retrieved information you can decide whether you really want to deserialize the object by the GetValue method.
• There is no GetValue method with AssemblyName[] argument. That overload ended up using the obsolete Assembly.LoadWithPartialName method. The weakly referenced assemblies however are handled automatically by using Reflector.ResolveType method so this overload is actually not needed.
• The GetValue method has three parameters instead of one. But all of them are optional so if called from a regular C# code, the method is compatible with the System.Resources.ResXDataNode.GetValue(ITypeResolutionService) method.
• There are no public constructors with Func<Type, string> arguments. In the system version these typeNameConverter parameters are used exclusively by non-public methods, which are called by the ResXResourceWriter class. But you can pass such a custom typeNameConverter to the ResXResourceWriter constructors.
• There is no GetNodePosition method because it returned a Point structure from the System.Drawing assembly, which is not referenced by this library. Use GetNodeLinePosition and GetNodeColumnPosition methods instead.
• The FileRef property returns the same reference during the lifetime of the ResXDataNode instance. This is alright as ResXFileRef is immutable. Unlike the system version, the FileRef property in this ResXDataNode contains exactly the same type information as the original .resx file.
• The System.Resources.ResXDataNode.GetValue method often throws XmlException if the node contains invalid data. In contrast, this GetValue implementation may throw XmlException, TypeLoadException, SerializationException or NotSupportedException instead, depending on the actual issue.

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

• Preserving original type information – The originally stored type information, MIME type and the current assembly alias are preserved (see TypeName, MimeType and AssemblyAliasValue properties). The system version may replace type information with assembly qualified names when the .resx file is parsed. If the assembly qualified name is really needed, you can get it after explicit deserialization by calling GetType().AssemblyQualifiedName on the Object returned by the GetValue method.
• Raw content – You can use the ValueData property to read the original raw String content stored in the .resx file for this element.
• Advanced string representation – The ToString method displays the string representation (either of the deserialized object if already cached, or the raw content) so can be used easily in a format argument and provides more debugging information.
• Security – No deserialization, assembly loading and type resolving occurs until a deserialization is explicitly requested by calling the GetValue method. Additionally, the GetValueSafe methods ensure that only the explicitly specified type or natively supported types are accepted and no assemblies are loaded even if a type is specified by its assembly qualified name. In safe mode resources serialized by BinaryFormatter are completely disabled. You can check the TypeName, MimeType and AssemblyAliasValue properties to get information about the type before obtaining the object. You can even check the raw string content by the ValueData property.
• Performance – As there is no deserialization and assembly/type resolving during parsing a .resx file by the ResXResourceReader class, the parsing is much faster. This is true even if ResXResourceReader.SafeMode is , because there are always ResXDataNode instances stored internally and deserialization occurs only when a resource is actually accessed.
• Support of non-serializable types – When serializing an object, the System.Resources.ResXDataNode type throws an InvalidOperationException for non-serializable types. This implementation can serialize also such types (though in safe mode they must be explicitly specified as expected types). It is highly recommended to save such resources with compatible mode disabled (see ResXResourceWriter.CompatibleFormat property and the ResXResourceSet.Save methods) so the BinarySerializationFormatter class can be used for the serialization. If the resource is saved in compatible format, then the legacy BinaryFormatter will used (not supported in .NET 8 and later and deserialization will be denied in safe mode) with an CustomSerializerSurrogateSelector instance to allow the serialization. Though the serialization stream will be compatible with .NET Framework the resource itself might not be able to be deserialized by the System.Resources.ResXResourceReader class. In order to serialize any object in .NET 8 or later, compatible mode must be disabled so the much safer BinarySerializationFormatter class can be used.
• Support of generics – This ResXDataNode class uses a special SerializationBinder implementation, which supports generic types correctly.

Reference