using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Xml.Linq;

using System.Xml.Schema;

using System.ComponentModel;

using System.Diagnostics;

​

​

    namespace System.Data.Services.Client

    {

        public enum EntityStates

        {

            State1,

            State2

        };

    }

​

    [XmlRoot("Entity")]

    public class StoreItem<TEntity>

        where TEntity : class, new()

    {

        /// <summary>

        /// Gets and sets the status of the entity when storing.

        /// </summary>

        [XmlAttribute]

        public System.Data.Services.Client.EntityStates Status { get; set; }

​

        /// <summary>

        /// Gets and sets the entity to be stored.

        /// </summary>

        [XmlIgnore]

        public TEntity Entity { get; set; }

​

        [XmlAnyElement]

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DebuggerBrowsable(DebuggerBrowsableState.Never)]

        public XElement XmlEntity

        {

            get

            {

                return (Entity == null ? null : XObjectExtensions.SerializeToXElement(Entity, null, true));

            }

            set

            {

                Entity = (value == null ? null : XObjectExtensions.Deserialize<TEntity>(value));

            }

        }

​

        public string AnAddedProperty { get; set; }

    }

​

    public static class XObjectExtensions

    {

        public static T Deserialize<T>(this XContainer element)

        {

            return element.Deserialize<T>(null);

        }

​

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

        {

            using (var reader = element.CreateReader())

            {

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

                object result = serializer.Deserialize(reader);

                if (result is T)

                    return (T)result;

            }

            return default(T);

        }

​

        public static XElement SerializeToXElement<T>(this T obj)

        {

            return obj.SerializeToXElement(null, true);

        }

​

        public static XElement SerializeToXElement<T>(this T obj, XmlSerializer serializer, bool omitStandardNamespaces)

        {

            var doc = new XDocument();

            using (var writer = doc.CreateWriter())

            {

                XmlSerializerNamespaces ns = null;

                if (omitStandardNamespaces)

                    (ns = new XmlSerializerNamespaces()).Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.

                serializer = serializer ?? new XmlSerializer(obj.GetType());

                serializer.Serialize(writer, obj, ns);

            }

            var element = doc.Root;

            if (element != null)

                element.Remove();

            return element;

        }

    }

​

    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)

        {

            return obj.GetXml(false);

        }

​

        public static string GetXml<T>(this T obj, bool omitStandardNamespaces)

        {

            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, IndentChars = "  " }; // For cosmetic purposes.

                using (var xmlWriter = XmlWriter.Create(textWriter, settings))

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

                return textWriter.ToString();

            }

        }

    }

​

    [XmlType("LandArea")]

    public class LandscapeArea

    {

        public double Area { get; set; }

    }

​

    public class SewageArea

    {

        public double Area { get; set; }

    }

​

    public class AreaWrapper<TEntity> where TEntity : class, new()

    {

        public TEntity Item { get; set; }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            Test(new SewageArea { Area = 10101 });

            Test(new LandscapeArea { Area = 202 });

            Test(new List<string> { "a", "b", "c" });

            Test(new AreaWrapper<SewageArea> { Item = new SewageArea { Area = 202 } });

            Test(new List<List<string>> { new List<string> { "a", "b", "c" }});

​

            // XmlSerializer does not support dictionaries.

            //Test(new Dictionary<string, List<string>> { { "a", new List<string> { "b", "c" } } });

        }

​

        static void Test<TEntity>(TEntity entity) where TEntity : class, new()

        {

            var test = new StoreItem<TEntity> { Entity = entity, AnAddedProperty = "some value of " + typeof(TEntity).Name, Status = System.Data.Services.Client.EntityStates.State1 };

​

            var xml = test.GetXml(true);

​

            Console.WriteLine("Serialized XML for " + typeof(TEntity).FullName + ": ");

            Console.WriteLine(xml);

​

            var test2 = xml.LoadFromXML<StoreItem<TEntity>>();

​

            var xml2 = test2.GetXml(true);

​

            Console.WriteLine(xml);

​

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

            Console.WriteLine(xml2);

​

            if (XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2)))

            {

                Console.WriteLine("Initial and re-serializd XML are equivalent.");

            }

            else

            {

                throw new InvalidOperationException("Initial and re-serializd XML are NOT equivalent.");

            }

            Console.WriteLine("");

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }