using System;

using System.Collections.Generic;

using System.Linq;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Diagnostics;

using System.ComponentModel;

using System.Xml.Linq;

​

​

    public interface IInput

    {

        string InputValue { get; set; }

    }

​

    public class Input1 : IInput

    {

        public string InputSource { get; set; }

​

        #region IInput Members

​

        public string InputValue { get; set; }

​

        #endregion

    }

​

    [XmlType(Namespace = "BarFoo")]

    public class Input2 : IInput

    {

        public string InputName { get; set; }

​

        #region IInput Members

​

        public string InputValue { get; set; }

​

        #endregion

    }

​

    [XmlRoot(Namespace = JobInput.XmlNamespace)]

    [XmlType(Namespace = JobInput.XmlNamespace)]

    public class JobInput

    {

        const string XmlNamespace = "";

​

        public int AgencyId { get; set; }

        public Guid ExternalId { get; set; }

        public string Requester { get; set; }

​

        [XmlIgnore]

        public IInput Input { get; set; }

​

        [XmlAnyElement]

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

        public XElement[] XmlCustomElements

        {

            get

            {

                var list = new List<XElement>();

                if (Input != null)

                    list.Add(Input.SerializePolymorphicToXElement(XName.Get("Input", XmlNamespace)));

                // Add others as needed.

                return list.ToArray();

            }

            set

            {

                if (value == null)

                    return;

                this.Input = value.DeserializePolymorphicEntry<IInput>(XName.Get("Input", XmlNamespace));

                // Add others as needed.

            }

        }

    }

​

    public static class XObjectExtensions

    {

        public static XmlSerializerNamespaces NoStandardXmlNamespaces()

        {

            var ns = new XmlSerializerNamespaces();

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

            return ns;

        }

​

        public static object Deserialize(this XContainer element, Type type, XmlSerializer serializer)

        {

            using (var reader = element.CreateReader())

            {

                return (serializer ?? new XmlSerializer(type)).Deserialize(reader);

            }

        }

​

        public static XElement SerializeToXElement<T>(this T obj, XmlSerializerNamespaces ns, XmlSerializer serializer)

        {

            var doc = new XDocument();

            using (var writer = doc.CreateWriter())

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

            var element = doc.Root;

            if (element != null)

                element.Remove();

            return element;

        }

​

        const string TypeAttributeName = "AssemblyQualifiedName";

​

        public static T DeserializePolymorphicEntry<T>(this XElement[] arrayValue, XName name)

        {

            var element = arrayValue.Where(e => e.Name == name).FirstOrDefault();

            return element.DeserializePolymorphic<T>(name);

        }

​

        public static T DeserializePolymorphic<T>(this XElement value, XName name)

        {

            if (value == null)

                return default(T);

            var typeName = (string)value.Attribute(TypeAttributeName);

            if (typeName == null)

                throw new InvalidOperationException(string.Format("Missing AssemblyQualifiedName for \"{0}\"", value.ToString()));

            var type = Type.GetType(typeName, true); // Throw on error

            return (T)value.Deserialize(type, XmlSerializerFactory.Create(type, name));

        }

​

        public static XElement SerializePolymorphicToXElement<T>(this T obj, XName name)

        {

            if (obj == null)

                return null;

            var element = obj.SerializeToXElement(XObjectExtensions.NoStandardXmlNamespaces(), XmlSerializerFactory.Create(obj.GetType(), name));

            // Remove namespace attributes (they will be added back by the XmlWriter if needed)

            foreach (var attr in element.Attributes().Where(a => a.IsNamespaceDeclaration).ToList())

                attr.Remove();

            element.Add(new XAttribute("AssemblyQualifiedName", obj.GetType().AssemblyQualifiedName));

            return element;

        }

    }

​

    public static class XmlSerializerFactory

    {

        static readonly object padlock;

        static readonly Dictionary<Tuple<Type, XName>, XmlSerializer> serializers;

​

        // An explicit static constructor enables fairly lazy initialization.

        static XmlSerializerFactory()

        {

            padlock = new object();

            serializers = new Dictionary<Tuple<Type, XName>, XmlSerializer>();

        }

​

        /// <summary>

        /// Return a cached XmlSerializer for the given type and root name.

        /// </summary>

        /// <param name="type"></param>

        /// <param name="name"></param>

        /// <returns>a cached XmlSerializer</returns>

        public static XmlSerializer Create(Type type, XName name)

        {

            // According to https://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlserializer%28v=vs.110%29.aspx

            // XmlSerializers created with new XmlSerializer(Type, XmlRootAttribute) must be cached in a hash table 

            // to avoid a severe memory leak & performance hit.

            if (type == null)

                throw new ArgumentNullException();

            if (name == null)

                return new XmlSerializer(type);

            lock (padlock)

            {

                XmlSerializer serializer;

                var key = Tuple.Create(type, name);

                if (!serializers.TryGetValue(key, out serializer))

                    serializers[key] = serializer = new XmlSerializer(type, new XmlRootAttribute { ElementName = name.LocalName, Namespace = name.NamespaceName });

                return serializer;

            }

        }

    }

​

    public static class XmlExtensions

    {

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

        {

            T returnValue = default(T);

​

            using (StringReader reader = new StringReader(xmlString))

            {

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

                if (result is T)

                {

                    returnValue = (T)result;

                }

            }

            return returnValue;

        }

​

        public static string GetXml(this object obj)

        {

            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);

                return textWriter.ToString();

            }

        }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var test1 = new JobInput { AgencyId = 101, ExternalId = Guid.NewGuid(), Requester = "Joe", Input = new Input1 { InputValue = "foo value", InputSource = "Foo source" } };

​

            try

            {

                Test(test1);

            }

            catch (Exception ex)

            {

                Debug.Assert(false, ex.ToString());

                throw;

            }

​

            var test2 = new JobInput { AgencyId = 101, ExternalId = Guid.NewGuid(), Requester = "Joe", Input = new Input2 { InputValue = "foo value", InputName = "input name" } };

​

            try

            {

                Test(test2);

            }

            catch (Exception ex)

            {

                Debug.Assert(false, ex.ToString());

                throw;

            }

        }

​

        private static void Test(JobInput test)

        {

            var xml = test.GetXml();

            Debug.WriteLine(xml);

            Console.WriteLine(xml);

​

            var test2 = xml.LoadFromXML<JobInput>();

            var xml2 = test2.GetXml();

            Debug.WriteLine(xml2);

            Console.WriteLine(xml2);

​

            if (!(xml == xml2))

                throw new InvalidOperationException("!(xml == xml2)");

​

            if (test.Input.GetType() != test2.Input.GetType())

                throw new InvalidOperationException("test.Input.GetType() != test2.Input.GetType()");

​

            if (Newtonsoft.Json.JsonConvert.SerializeObject(test.Input) != Newtonsoft.Json.JsonConvert.SerializeObject(test2.Input))

                throw new InvalidOperationException("Newtonsoft.Json.JsonConvert.SerializeObject(test.Input) != Newtonsoft.Json.JsonConvert.SerializeObject(test2.Input)");

        }

    }

​

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine(typeof(Newtonsoft.Json.Linq.JToken).Assembly.FullName);

            TestClass.Test();

        }

    }