questions/51467120/how-to-serialize-a-class-that-may-only-have-unique-instances

CSharp · Console

/Program.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;
using System.IO;
using System.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO.Compression;

    // https://stackoverflow.com/questions/51467120/how-to-serialize-a-class-that-may-only-have-unique-instances
    public sealed class MyClassDTO
    {
        public string Name { get; set; }

        public static implicit operator MyClassDTO(MyClass obj) => obj == null ? null : new MyClassDTO { Name = obj.Name };

        public static implicit operator MyClass(MyClassDTO dto) => dto == null ? null : MyClass.Parse(dto.Name);
    }

    public sealed class MyClass
    {
        private static readonly Dictionary<string, MyClass> Cache;

        static MyClass()
        {
            Cache = new Dictionary<string, MyClass>()
            {
                { "one", new MyClass("one") { OtherRuntimeData = "other runtime data 1" } },
                { "two", new MyClass("two") { OtherRuntimeData = "other runtime data 2" } },
            };
        }

		// XmlSerializer required parameterless constructor.
		private MyClass() => throw new NotImplementedException();

        private MyClass(string name) => this.Name = name;

		public string Name { get; }

        public string OtherRuntimeData { get; set; }

        public static MyClass Parse(string from) => Cache[from];
		
		public static IEnumerable<MyClass> Instances => Cache.Values;
    }

	public class RootObject
	{
		// Technique taken from https://stackoverflow.com/questions/3280362/most-elegant-xml-serialization-of-color-structure
		[XmlElement(Type=typeof(MyClassDTO))]
		public MyClass MyClass { get; set; }
	}

    public class TestClass
    {
        public static void Test()
        {
			var root = new RootObject { MyClass = MyClass.Instances.Last() };

			var xml = root.GetXml(true);
			
			Console.WriteLine(xml);
			
			var root2 = xml.LoadFromXml<RootObject>();
			
			Assert.IsTrue(object.ReferenceEquals(root.MyClass, root2.MyClass));
			
			Console.WriteLine("\n{0} successfully round-tripped.", nameof(root.MyClass));			
        }
    }

    public static class XmlSerializationHelper
    {
        public static T LoadFromXml<T>(this string xmlString, XmlSerializer serial = null)
        {
            serial = serial ?? new XmlSerializer(typeof(T));
            using (var reader = new StringReader(xmlString))
            {
				return (T)serial.Deserialize(reader);
            }
        }

        public static string GetXml<T>(this T obj, bool omitStandardNamespaces)
        {
			return obj.GetXml(null, omitStandardNamespaces);
        }
		
        public static string GetXml<T>(this T obj, XmlSerializer serializer = null, bool omitStandardNamespaces = false)
        {
            XmlSerializerNamespaces ns = null;
            if (omitStandardNamespaces)
            {
                ns = new XmlSerializerNamespaces();
                ns.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.
            }			
            using (var textWriter = new StringWriter())
            {
                var settings = new XmlWriterSettings() { Indent = true }; // For cosmetic purposes.
                using (var xmlWriter = XmlWriter.Create(textWriter, settings))
                    (serializer ?? new XmlSerializer(obj.GetType())).Serialize(xmlWriter, obj, ns);
                return textWriter.ToString();
            }
        }
		
		public static string GetOuterXml(this XmlNode node, bool indent = true)
		{
			if (node == null)
				return null;
			using (var textWriter = new StringWriter())
			{
				var settings = new XmlWriterSettings
				{
					Indent = indent,
					OmitXmlDeclaration = true,
				};
				using (var xmlWriter = XmlWriter.Create(textWriter, settings))
				{
					node.WriteTo(xmlWriter);
				}
				return textWriter.ToString();
			}
		}
    }
				
    public static class XmlAssert
    {
        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality
        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects
        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson
        public static void AreEqual(
            XElement expected,
            XElement actual)
        {
            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));
        }

        private static XElement Normalize(XElement element)
        {
            if (element.HasElements)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()),
                    element.Elements()
                           .OrderBy(a => a.Name.ToString())
                           .Select(e => Normalize(e)));

            }

            if (element.IsEmpty)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()));
            }

            return new XElement(element.Name, element.Attributes()
                .OrderBy(a => a.Name.ToString()), element.Value);
        }
    }
    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }

        public AssertionFailedException(string s) : base(s) { }
    }

    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }

        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }
						
	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Roslyn 2.0 Compiler; Environment version: " + Environment.Version);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Uncaught exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}