ResXResourceWriter Class

public sealed class ResXResourceWriter : IResourceWriter, 
	IDisposable

Public NotInheritable Class ResXResourceWriter
	Implements IResourceWriter, IDisposable

public ref class ResXResourceWriter sealed : IResourceWriter, 
	IDisposable

[<SealedAttribute>]
type ResXResourceWriter = 
    class
        interface IResourceWriter
        interface IDisposable
    end

Inheritance

Object    ResXResourceWriter

Implements

IDisposable, IResourceWriter

Resources are specified as name/value pairs using the AddResource method.

If CompatibleFormat property is , ResXResourceWriter emits .resx files, which can be then read not just by ResXResourceReader but by the original System.Resources.ResXResourceReader class, too.

Example

using System;
using System.Drawing;
using System.IO;
using KGySoft.Resources;

public class Example
{
    [Serializable]
    private class MyCustomClass
    {
        public string StringProp { get; set; }
        public int IntProp { get; set; }
    }

    public static void Main()
    {
        // Check the result with CompatibleFormat = true as well.
        // You will get a much longer result, which will be able to read by System.Resources.ResXResourceReader, too.
        var result = new StringWriter();
        using (var writer = new ResXResourceWriter(result) { CompatibleFormat = false })
        {
            writer.AddResource("string", "string value");
            writer.AddResource("int", 42);
            writer.AddResource("null", (object)null);
            writer.AddResource("file", new ResXFileRef(@"images\Image.jpg", typeof(Bitmap)));
            writer.AddResource("custom", new MyCustomClass { IntProp = 42, StringProp = "blah" });
        }

        Console.WriteLine(result.GetStringBuilder());
    }
}

// The example displays the following output:
// <?xml version="1.0" encoding="utf-8"?>
// <root>
//   <data name="string">
//     <value>string value</value>
//   </data>
//   <data name="int" type="System.Int32">
//     <value>42</value>
//   </data>
//   <assembly alias="KGySoft.CoreLibraries" name="KGySoft.CoreLibraries, Version=3.6.3.1, Culture=neutral, PublicKeyToken=b45eba277439ddfe" />
//   <data name="null" type="KGySoft.Resources.ResXNullRef, KGySoft.CoreLibraries">
//     <value />
//   </data>
//   <data name="file" type="KGySoft.Resources.ResXFileRef, KGySoft.CoreLibraries">
//     <value>images\Image.jpg;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
//   </data>
//   <data name="custom" mimetype="text/kgysoft.net/object.binary.base64">
//     <value>
//       PgAChAQFQkNvbnNvbGVBcHAxLCBWZXJzaW9uPTEuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49bnVsbBVF
//       eGFtcGxlK015Q3VzdG9tQ2xhc3MBAhs8U3RyaW5nUHJvcD5rX19CYWNraW5nRmllbGQDEgAEYmxhaBg8SW50UHJvcD5rX19CYWNr
//       aW5nRmllbGQECEAqAA==
//     </value>
//   </data>
// </root>

Comparison with System.Resources.ResXResourceWriter 

Incompatibility with System.Resources.ResXResourceWriter:

• The System version has several public string fields, which are not intended to be accessed by a consumer code. Therefore the following fields are missing (they are not public) in this version:
  • BinSerializedObjectMimeType
  • ByteArraySerializedObjectMimeType
  • DefaultSerializedObjectMimeType
  • ResMimeType
  • ResourceSchema
  • SoapSerializedObjectMimeType
  • Version
• In this version there are no one parameter constructors. Instead, the second parameter (typeNameConverter) is optional. If used purely from C# (no reflection or whatsoever), this change is a compatible one.
• This ResXResourceWriter is a sealed class.
• After disposing the ResXResourceWriter instance or calling the Close method, calling the Generate method will throw an ObjectDisposedException.
• The System.Resources.ResXResourceWriter.AddAlias method just populates an inner alias list causing that the alias will be recognized on further processing but will never be dumped into the output stream. In this ResXResourceWriter implementation the AddAlias method is somewhat different: not just registers the alias as a known one but also dumps that into the output stream. It can be specified though, whether the dump should be deferred until the alias is actually referenced for the first time.

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

• Compatibility – If CompatibleFormat is , the resulting .resx file can be read by System.Resources.ResXResourceReader.
• Compactness – The more compact output is achieved in multiple ways:
  • If OmitHeader is , the header and the schema is not dumped into the resulting .resx file. If CompatibleFormat is , then only the header comment can be omitted.
  • Whitespace preserving to string values is applied only if it is really necessary (even if CompatibleFormat is ).
  • If an object can only be binary serialized, then instead of using BinaryFormatter it is serialized by BinarySerializationFormatter, which produces a much more compact result (only if CompatibleFormat is ). A new MIME type has been introduced to identify binary data serialized this new way.
• New overloads:
  • AddAlias method now can be called with a String assembly name and not just by an AssemblyName instance. Both overloads have now an optional Boolean argument for specifying whether the alias must be dumped immediately.
  • New AddMetadata(ResXDataNode) overload, working similarly to the existing AddResource(ResXDataNode) method.
• AutoGenerateAlias property – If , alias names for assemblies will be automatically generated without calling AddAlias method. If , the assembly qualified names will be used for non-mscorlib types, unless an alias name was explicitly added by the AddAlias method or the ResXDataNode to dump already contains an alias name.
• Better support of several types:

  Type	Improvement	How it is handled by the System version
  value	Invalid .resx representations of value is fixed when re-written by ResXResourceWriter.	When the System version rewrites such an invalid node, it turns into empty string.
  Array of SByte	Serializing sbyte[] type works properly.	The System.Resources.ResXResourceWriter changes the sbyte[] types to byte[].
  Char	Support of unpaired surrogate characters.	System.Resources.ResXResourceWriter cannot serialize unpaired surrogates, though System.Resources.ResXResourceReader can read them successfully if they are serialized by ResXResourceWriter and CompatibleFormat is .
  String and any type serialized by a TypeConverter.	Strings containing unpaired surrogates and invalid Unicode characters can be written without any error.	System.Resources.ResXResourceWriter cannot serialize such strings, though System.Resources.ResXResourceReader can read them successfully if they are serialized by ResXResourceWriter and CompatibleFormat is .
  DateTime and DateTimeOffset	Serialized in a different way so even the milliseconds part is preserved.	The fixed form can be deserialized by System.Resources.ResXResourceReader, too; however, the DateTime.Kind will be always Local.
  Single, Double and Decimal	-0 (negative zero) value is handled correctly.	The fixed form can be deserialized by System.Resources.ResXResourceReader, too; however, in case of Single and Double -0 will always turn to +0.
  IntPtr, UIntPtr, DBNull and Type instances containing a runtime type.	These types are supported natively (without a mimetype attribute). Only if CompatibleFormat is .	System.Resources.ResXResourceWriter can serialize these type only by BinaryFormatter. Though in .NET Core and .NET Standard Type is not serializable even by BinaryFormatter.
  Generic types	Generic types with a TypeConverter are handled correctly.	Parsing generic type names may fail with System.Resources.ResXResourceReader. The problem does not occur on binary serialization because in that case the type name is not dumped into the .resx file but is encoded in the binary stream.
  Any non-serializable type	As long as the BinarySerializationFormatter can serialize the non-serializable type, this implementation supports non-serializable types as well. This works even if CompatibleFormat is .	If CompatibleFormat is during serialization, deserialization works even with System.Resources.ResXResourceReader as long as KGySoft.CoreLibraries assembly can be loaded and BinaryFormatter can find the AnyObjectSerializerWrapper class.

Reference