using System;

using System.Collections;

using System.Collections.Generic;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

​

    namespace V1

    {

        // https://stackoverflow.com/questions/31552724/how-why-does-xmlserializer-treat-a-class-differently-when-it-implements-ilistt

        public class Vector2

        {

            public double X { get; set; }

​

            public double Y { get; set; }

​

            public Vector2() { }

​

            public Vector2(double x, double y)

                : this()

            {

                this.X = x;

                this.Y = y;

            }

​

            public double this[int coord]

            {

                get

                {

                    switch (coord)

                    {

                        case 0:

                            return X;

                        case 1:

                            return Y;

                        default:

                            throw new ArgumentOutOfRangeException();

                    }

                }

                set

                {

                    switch (coord)

                    {

                        case 0:

                            X = value;

                            break;

                        case 1:

                            Y = value;

                            break;

                        default:

                            throw new ArgumentOutOfRangeException();

                    }

                }

            }

        }

    }

​

    namespace V2

    {

        // https://stackoverflow.com/questions/31552724/how-why-does-xmlserializer-treat-a-class-differently-when-it-implements-ilistt

        public class Vector2 : V1.Vector2, IList<double>

        {

            public Vector2() : base() { }

​

            public Vector2(double x, double y) : base(x, y) { }

​

            #region IList<double> Members

​

            public int IndexOf(double item)

            {

                for (var i = 0; i < Count; i++)

                    if (this[i] == item)

                        return i;

                return -1;

            }

​

            public void Insert(int index, double item)

            {

                throw new NotImplementedException();

            }

​

            public void RemoveAt(int index)

            {

                throw new NotImplementedException();

            }

​

            #endregion

​

            #region ICollection<double> Members

​

            public void Add(double item)

            {

                throw new NotImplementedException();

            }

​

            public void Clear()

            {

                throw new NotImplementedException();

            }

​

            public bool Contains(double item)

            {

                return IndexOf(item) >= 0;

            }

​

            public void CopyTo(double[] array, int arrayIndex)

            {

                foreach (var item in this)

                    array[arrayIndex++] = item;

            }

​

            public int Count

            {

                get { return 2; }

            }

​

            public bool IsReadOnly

            {

                get { return true; }

            }

​

            public bool Remove(double item)

            {

                throw new NotImplementedException();

            }

​

            #endregion

​

            #region IEnumerable<double> Members

​

            public IEnumerator<double> GetEnumerator()

            {

                yield return X;

                yield return Y;

            }

​

            #endregion

​

            #region IEnumerable Members

​

            IEnumerator IEnumerable.GetEnumerator()

            {

                return GetEnumerator();

            }

​

            #endregion

        }

    }

​

    namespace V3

    {

        public class Vector2 : V1.Vector2, IReadOnlyList<double>

        {

            public Vector2() : base() { }

            public Vector2(double x, double y) : base(x, y) { }

            #region IList<double> Members

            public int IndexOf(double item)

            {

                for (var i = 0; i < Count; i++)

                    if (this[i] == item)

                        return i;

                return -1;

            }

            #endregion

            #region ICollection<double> Members

            public bool Contains(double item)

            {

                return IndexOf(item) >= 0;

            }

            public void CopyTo(double[] array, int arrayIndex)

            {

                foreach (var item in this)

                    array[arrayIndex++] = item;

            }

            public int Count

            {

                get { return 2; }

            }

            public bool IsReadOnly

            {

                get { return true; }

            }

            #endregion

            #region IEnumerable<double> Members

            public IEnumerator<double> GetEnumerator()

            {

                yield return X;

                yield return Y;

            }

            #endregion

            #region IEnumerable Members

            IEnumerator IEnumerable.GetEnumerator()

            {

                return GetEnumerator();

            }

            #endregion

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            var vec1 = new V1.Vector2(1, 2);

            Console.WriteLine(vec1.GetXml(true));

​

            var vec2 = new V2.Vector2(1, 2);

            Console.WriteLine(vec2.GetXml(true));

            var vec3 = new V3.Vector2(1, 2);

            Console.WriteLine(vec3.GetXml(true));

        }

    }

​

    public static class XmlSerializationHelper

    {

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

        {

            return xmlString.LoadFromXML<T>(new XmlSerializer(typeof(T)));

        }

​

        public static T LoadFromXML<T>(this string xmlString, XmlSerializer serial)

        {

            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)

        {

            return GetXml(obj, false);

        }

​

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

        {

            return GetXml(obj, new XmlSerializer(obj.GetType()), omitNamespace);

        }

​

        public static string GetXml<T>(this T obj, XmlSerializer serializer)

        {

            return GetXml(obj, serializer, false);

        }

​

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

        {

            XmlSerializerNamespaces ns = null;

            if (omitStandardNamespaces)

            {

                ns = new XmlSerializerNamespaces();

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

            }

            return GetXml(obj, serializer, ns);

        }

​

        public static string GetXml<T>(T obj, XmlSerializer serializer, XmlSerializerNamespaces ns)

        {

            using (var textWriter = new StringWriter())

            {

                var settings = new XmlWriterSettings() { Indent = true, IndentChars = "    " }; // For cosmetic purposes.

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

                    serializer.Serialize(xmlWriter, obj, ns);

                return textWriter.ToString();

            }

        }

​

        public static string GetXml<T>(this T obj, XmlSerializerNamespaces ns)

        {

            return GetXml(obj, new XmlSerializer(obj.GetType()), ns);

        }

    }

​

​