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/41069853/c-sharp-serialize-object-containing-another-serialised-object-in-xml#41069853

​

​

    [Serializable()]

    public class SerializableDictionary<TKey, TVal> : Dictionary<TKey, TVal>, IXmlSerializable, ISerializable {

        private const string DictionaryNodeName = "Dictionary";

        private const string ItemNodeName = "Item";

        private const string KeyNodeName = "Key";

        private const string ValueNodeName = "Value";

​

        public SerializableDictionary() {

        }

​

        public SerializableDictionary(IDictionary<TKey, TVal> dictionary)

            : base(dictionary) {

        }

​

        public SerializableDictionary(IEqualityComparer<TKey> comparer)

            : base(comparer) {

        }

​

        public SerializableDictionary(int capacity)

            : base(capacity) {

        }

​

        public SerializableDictionary(IDictionary<TKey, TVal> dictionary, IEqualityComparer<TKey> comparer)

            : base(dictionary, comparer) {

        }

​

        public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer)

            : base(capacity, comparer) {

        }

​

        protected SerializableDictionary(SerializationInfo info, StreamingContext context) {

            int itemCount = info.GetInt32("ItemCount");

            for (int i = 0; i < itemCount; i++) {

                KeyValuePair<TKey, TVal> kvp = (KeyValuePair<TKey, TVal>)info.GetValue(String.Format("Item{0}", i), typeof(KeyValuePair<TKey, TVal>));

                this.Add(kvp.Key, kvp.Value);

            }

        }

​

        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) {

            info.AddValue("ItemCount", this.Count);

            int itemIdx = 0;

            foreach (KeyValuePair<TKey, TVal> kvp in this) {

                info.AddValue(String.Format("Item{0}", itemIdx), kvp, typeof(KeyValuePair<TKey, TVal>));

                itemIdx++;

            }

        }

​

​

        void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer) {

            //writer.WriteStartElement(DictionaryNodeName);

            foreach (KeyValuePair<TKey, TVal> kvp in this) {

                writer.WriteStartElement(ItemNodeName);

                writer.WriteStartElement(KeyNodeName);

                KeySerializer.Serialize(writer, kvp.Key);

                writer.WriteEndElement();

                writer.WriteStartElement(ValueNodeName);

                ValueSerializer.Serialize(writer, kvp.Value);

                writer.WriteEndElement();

                writer.WriteEndElement();

            }

            //writer.WriteEndElement();

        }

​

        void IXmlSerializable.ReadXml(System.Xml.XmlReader reader) {

            if (reader.IsEmptyElement) {

                return;

            }

​

            // Move past container

            if (!reader.Read()) {

                throw new XmlException("Error in Deserialization of Dictionary");

            }

​

            //reader.ReadStartElement(DictionaryNodeName);

            while (reader.NodeType != XmlNodeType.EndElement) {

                reader.ReadStartElement(ItemNodeName);

                reader.ReadStartElement(KeyNodeName);

                TKey key = (TKey)KeySerializer.Deserialize(reader);

                reader.ReadEndElement();

                reader.ReadStartElement(ValueNodeName);

                TVal value = (TVal)ValueSerializer.Deserialize(reader);

                reader.ReadEndElement();

                reader.ReadEndElement();

                this.Add(key, value);

                reader.MoveToContent();

            }

            //reader.ReadEndElement();

​

            reader.ReadEndElement(); // Read End Element to close Read of containing node

        }

​

        System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema() {

            return null;

        }

​

        protected XmlSerializer ValueSerializer {

            get {

                if (valueSerializer == null) {

                    valueSerializer = new XmlSerializer(typeof(TVal));

                }

                return valueSerializer;

            }

        }

​

        private XmlSerializer KeySerializer {

            get {

                if (keySerializer == null) {

                    keySerializer = new XmlSerializer(typeof(TKey));

                }

                return keySerializer;

            }

        }

​

        private XmlSerializer keySerializer = null;

        private XmlSerializer valueSerializer = null;

    }

​

    class TestClass

    {

        public static void Test()

        {

            var dict = new SerializableDictionary<string, object>()

            {

                { "user1", true },

                { "user2", false },

            };

            var xml = dict.GetXml();

            Console.WriteLine("Serialized dictionary: ");

            Console.WriteLine(xml);

            var dict2 = xml.LoadFromXml<SerializableDictionary<string, object>>();

            var xml2 = dict2.GetXml();

            Console.WriteLine("Deserialized and re-serialized dictionary: ");

            Console.WriteLine(xml2);

            if (xml == xml2)

            {

                Console.WriteLine("Serialized and re-serialized XML are identical.");

            }

            else

            {

                throw new InvalidOperationException("Serialized and re-serialized XML are NOT identical.");

            }

            if (Newtonsoft.Json.JsonConvert.SerializeObject(dict) != Newtonsoft.Json.JsonConvert.SerializeObject(dict2))

            {

                throw new InvalidOperationException("Newtonsoft.Json.JsonConvert.SerializeObject(dict) != Newtonsoft.Json.JsonConvert.SerializeObject(dict2)");

            }

            else

            {

                Console.WriteLine("Original and deserialized dictionaries have identical JSON.");

            }

        }

    }

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }

​

    public static class XmlSerializationHelper

    {

        public static T LoadFromXml<T>(this string xmlString)

        {

            using (StringReader reader = new StringReader(xmlString))

            {

                return (T)new XmlSerializer(typeof(T)).Deserialize(reader);

            }

        }

​

        public static string GetXml<T>(this T obj, 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))

                    new XmlSerializer(obj.GetType()).Serialize(xmlWriter, obj, ns);

                return textWriter.ToString();

            }

        }

    }

​