using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Diagnostics;

using System.Collections.ObjectModel;

using System.Threading;

using System.ComponentModel;

using System.Xml.Linq;

using System.Reflection;

using System.Data;

using System.Xml.Schema;

using System.Text.RegularExpressions;

using System.Net;

using System.Xml.XPath;

using System.Globalization;

using System.ComponentModel.DataAnnotations;

using System.Collections;

using System.Runtime.InteropServices;

using System.Runtime.Serialization;

​

​

// https://stackoverflow.com/questions/45844241/custom-serialization-of-a-dictionary-fails-when-xml-has-indentation-line-break

​

    public class MyCollection : System.Collections.Generic.Dictionary<string, string>, IXmlSerializable

    {

        public XmlSchema GetSchema()

        {

            return null;

        }

​

        public void ReadXml(XmlReader reader)

        {

            using (var subReader = reader.ReadSubtree())

            {

                XmlKeyValueListHelper.ReadKeyValueXml(subReader, this);

            }

            // Consume the EndElement also (or move past the current element if reader.IsEmptyElement).

            reader.Read();

        }

​

        public void WriteXml(System.Xml.XmlWriter writer)

        {

            XmlKeyValueListHelper.WriteKeyValueXml(writer, this);

        }

    }

​

    public static class XmlKeyValueListHelper

    {

        private const string XmlElementName = "MyData";

        private const string XmlAttributeId = "Id";

​

        public static void WriteKeyValueXml(System.Xml.XmlWriter writer, ICollection<KeyValuePair<string, string>> collection)

        {

            foreach (var pair in collection)

            {

                writer.WriteStartElement(XmlElementName);

                writer.WriteAttributeString(XmlAttributeId, pair.Key);

                writer.WriteString(pair.Value);

                writer.WriteEndElement();

            }

        }

​

        public static void ReadKeyValueXml(System.Xml.XmlReader reader, ICollection<KeyValuePair<string, string>> collection)

        {

            if (reader.IsEmptyElement)

            {

                reader.Read();

                return;

            }

​

            reader.ReadStartElement(); // Advance to the first sub element of the list element.

            while (reader.NodeType != XmlNodeType.EndElement)

            {

                if (reader.NodeType == XmlNodeType.Element && reader.LocalName == XmlElementName)

                {

                    var tag = reader.GetAttribute(XmlAttributeId);

                    string content;

                    if (reader.IsEmptyElement)

                    {

                        content = string.Empty;

                        // Move past the end of item element

                        reader.Read();

                    }

                    else

                    {

                        // Read content and move past the end of item element

                        content = reader.ReadElementContentAsString();

                    }

                    collection.Add(new KeyValuePair<string, string>(tag, content));

                }

                else

                {

                    // For instance a comment.

                    reader.Skip();

                }

            }

            // Move past the end of the list element

            reader.ReadEndElement();

        }

    }

​

    public class Root

    {

        public MyCollection MyCollection { get; set; }

​

        public string ZValue { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            TestRead(new MyCollection { {"", ""}, { "1", "some content" }, { "2", "some other content" } }, true);

            TestRead(new MyCollection { {"", ""}, { "1", "some content" }, { "2", "some other content" } }, false);

            TestRead(new MyCollection { }, false);

​

            ConsoleAndDebug.WriteLine("Done");

        }

​

        static void TestRead(MyCollection old, bool addSpoiler)

        {

            var root = new Root { MyCollection = old, ZValue = "zvalue" };

​

            var document = XDocument.Parse(root.GetXml());

​

            if (addSpoiler)

            {

                var child = document.Root.Element("MyCollection").Elements().FirstOrDefault();

                if (child != null)

                {

                    child.AddBeforeSelf(new XComment("A comment"));

                    child.AddBeforeSelf(new XText("spoiler"));

                    child.AddAfterSelf(new XElement("foo", new XElement("bar", "some bar text")));

                }

            }

​

            Console.WriteLine("Testing XML: ");

            Console.WriteLine(document);

            var xmlIndented = document.ToString(SaveOptions.None);

            var xmlUnindented = document.ToString(SaveOptions.DisableFormatting);

​

            TestRead(root, xmlUnindented);

            TestRead(root, xmlIndented);

​

            Console.WriteLine("");

        }

​

        static void TestRead(Root old, string xml)

        {

            var newRoot = xml.LoadFromXml<Root>();

​

            Assert.IsTrue(newRoot.MyCollection.Count == old.MyCollection.Count);

            Assert.IsTrue(newRoot.ZValue == old.ZValue);

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

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

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            if (value == false)

                throw new AssertionFailedException("failed");

        }

    }

​

    public static class ConsoleAndDebug

    {

        public static void WriteLine(object s)

        {

            Console.WriteLine(s);

            Debug.WriteLine(s);

        }

    }

​

    public static class XmlSerializationHelper

    {

        public static T LoadFromXml<T>(this string xmlString, XmlSerializer serial = null)

        {

            serial = serial ?? new XmlSerializer(typeof(T));

            T returnValue = default(T);

            using (StringReader reader = new StringReader(xmlString))

            {

                object result = serial.Deserialize(reader);

                if (result is T)

                {

                    returnValue = (T)result;

                }

            }

            return returnValue;

        }

​

        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 class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine();

​

            TestClass.Test();

        }

    }

​