using System;

using System.Collections.Generic;

using System.Linq;

using System.Xml.Serialization;

using System.Xml;

using System.Xml.Linq;

using System.Xml.Schema;

using System.IO;

​

​

    public static class XmlExtensions

    {

        public static T Deserialize<T>(this XContainer element, XmlSerializer serializer = null)

        {

            using (var reader = element.CreateReader())

            {

                object result = (serializer ?? new XmlSerializer(typeof(T))).Deserialize(reader);

                if (result is T)

                    return (T)result;

            }

            return default(T);

        }

​

        public static XElement SerializeToXElement<T>(this T obj, XmlSerializer serializer = null)

        {

            var doc = new XDocument();

            using (var writer = doc.CreateWriter())

                (serializer ?? new XmlSerializer(obj.GetType())).Serialize(writer, obj);

            var element = doc.Root;

            if (element != null)

                element.Remove();

            return element;

        }

​

        public static XName ContainerElementName { get { return (XName)"Object"; } }

​

        public static XName ContainerAttributeName { get { return (XName)"Name"; } }

​

        public static XElement SetItem<T>(this XDocument doc, string attributeValue, T obj)

        {

            return doc.SetItem(ContainerElementName, ContainerAttributeName, attributeValue, obj);

        }

​

        static XElement SetItem<T>(this XDocument doc, XName containerElementName, XName containerAttributeName, string attributeValue, T obj)

        {

            if (doc == null || containerElementName == null || containerAttributeName == null || attributeValue == null)

                throw new ArgumentNullException();

            if (doc.Root == null)

                throw new ArgumentException("doc.Root == null");

            var container = doc.Root.Elements(containerElementName).Where(e => (string)e.Attribute(containerAttributeName) == attributeValue).SingleOrDefault();

            if (container == null)

            {

                container = new XElement(containerElementName, new XAttribute(containerAttributeName, attributeValue));

                doc.Root.Add(container);

            }

            else

            {

                // Remove old content.

                container.RemoveNodes();

            }

​

            var element = obj.SerializeToXElement();

            container.Add(element);

            return element;

        }

​

        public static T GetItem<T>(this XDocument doc, string attributeValue)

        {

            return doc.GetItem<T>(ContainerElementName, ContainerAttributeName, attributeValue);

        }

​

        static T GetItem<T>(this XDocument doc, XName containerElementName, XName containerAttributeName, string attributeValue)

        {

            if (doc == null || containerElementName == null || containerAttributeName == null || attributeValue == null)

                throw new ArgumentNullException();

            if (doc.Root == null)

                throw new ArgumentException("doc.Root == null");

            var container = doc.Root.Elements(containerElementName).Where(e => (string)e.Attribute(containerAttributeName) == attributeValue).SingleOrDefault();

            if (container == null)

                return default(T);

            var element = container.Elements().SingleOrDefault();

            if (element == null)

                return default(T);

            return element.Deserialize<T>();

        }

​

        public static XDocument CreateDefaultXDocument()

        {

            var xml = @"<StoredObjects></StoredObjects>";

            return XDocument.Parse(xml);

        }

    }

​

    public class MYOBJECT_TYPE

    {

        public string Value { get; set; }

​

        public List<int> Values { get; set; }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var doc = XmlExtensions.CreateDefaultXDocument();

​

            var test1 = new MYOBJECT_TYPE { Value = "1hello", Values = new List<int> { 1, 11, 111, 1111, 11111 } };

            var test3 = new MYOBJECT_TYPE { Value = "3hello", Values = new List<int> { 3, 33, 333, 3333, 33333 } };

​

            var MYOBJECT = new MYOBJECT_TYPE { Value = "2hello", Values = new List<int> { 2, 22, 222, 2222, 22222 } };

            string objectName = "second";

​

​

            doc.SetItem("first", test1);

            doc.SetItem(objectName, MYOBJECT);

            doc.SetItem("third", test3);

​

            var MYOBJECT2 = doc.GetItem<MYOBJECT_TYPE>("second");

​

            CheckEqual(MYOBJECT2, MYOBJECT);

​

            doc.SetItem("first", test1);

            doc.SetItem(objectName, MYOBJECT);

            doc.SetItem("third", test3);

​

            var MYOBJECT3 = doc.GetItem<MYOBJECT_TYPE>("second");

​

            CheckEqual(MYOBJECT3, MYOBJECT);

​

            doc.SetItem("first", test1);

            doc.SetItem(objectName, test1);

            doc.SetItem("third", test3);

​

            var test1back2 = doc.GetItem<MYOBJECT_TYPE>("second");

​

            CheckEqual(test1back2, test1);

            doc.SetItem("first", test1);

            doc.SetItem(objectName, test3);

            doc.SetItem("third", test3);

            var MYOBJECT5 = doc.GetItem<MYOBJECT_TYPE>("second");

​

            try

            {

                CheckEqual(MYOBJECT5, MYOBJECT);

            }

            catch (Exception)

            {

                Console.WriteLine("Caught expected exception");

            }

            doc.SetItem("first", test1);

            doc.SetItem(objectName, MYOBJECT);

            doc.SetItem("third", test3);

            var MYOBJECT4 = doc.GetItem<MYOBJECT_TYPE>("second");

​

            CheckEqual(MYOBJECT4, MYOBJECT);

            Console.WriteLine(doc);

        }

​

        static bool CheckEqual<T>(T first, T second)

        {

            if (object.ReferenceEquals(first, second))

                return true;

            if (first == null || second == null)

                throw new InvalidOperationException();

            if (!Newtonsoft.Json.Linq.JToken.DeepEquals(Newtonsoft.Json.Linq.JToken.FromObject(first), Newtonsoft.Json.Linq.JToken.FromObject(second)))

                throw new InvalidOperationException();

            return true;

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }