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;

using System.Diagnostics;

​

    namespace Option1

    {

        public abstract class Parameter

        {

            [XmlText]

            public string Value { get; set; }

        }

​

        public class Parameter1 : Parameter

        {

        }

​

        public class Parameter2 : Parameter

        {

        }

​

        [XmlType("Root")]

        public class RootObject

        {

            [XmlElement("Parameter1", typeof(Parameter1))]

            [XmlElement("Parameter2", typeof(Parameter2))]

            public Parameter[] Parameters { get; set; }

        }

    }

​

    namespace Option2

    {

        public class Parameter

        {

            [XmlText]

            public string Value { get; set; }

        }

​

        [XmlType("Root")]

        public class RootObject

        {

            [XmlElement("Parameter1", typeof(Parameter))]

            [XmlElement("Parameter2", typeof(Parameter))]

            [XmlChoiceIdentifier("ParametersElementName")]

            public Parameter[] Parameters { get; set; }

​

            [XmlIgnore]

            public ParametersChoiceType[] ParametersElementName { get; set; }

        }

​

        [XmlType(IncludeInSchema = false)]

        public enum ParametersChoiceType

        {

            Parameter1,

            Parameter2,

        }

    }

​

    namespace Option3

    {

        public class Parameter

        {

            [XmlText]

            public string Value { get; set; }

        }

​

        [XmlType(IncludeInSchema = false)]

        public enum ParametersChoiceType

        {

            Parameter1,

            Parameter2,

        }

​

        [XmlType("Root")]

        public class RootObject

        {

            [XmlElement("Parameter1", typeof(Parameter))]

            [XmlElement("Parameter2", typeof(Parameter))]

            [XmlChoiceIdentifier("ParametersElementName")]

            public Parameter[] Parameters { get; set; }

​

            [XmlIgnore]

            public ParametersChoiceType[] ParametersElementName

            {

                get

                {

                    if (Parameters == null)

                        return null;

                    return Parameters.Select(p => ParametersChoiceType.Parameter1).ToArray();// Arbitrarily return ItemsChoiceType.Parameter1

                }

                set

                {

                    // Do nothing - don't care.

                }

            }

        }

    }

​

    public class TestClass

    {

        static string GetXml()

        {

            var xml = @"<Root>

<Parameter1>3</Parameter1>

<Parameter2>4</Parameter2>

</Root>";

            return xml;

        }

​

        public static void Test()

        {

            var xml = GetXml();

            ConsoleAndDebug.WriteLine("Original XML:" );

            ConsoleAndDebug.WriteLine(xml);

            ConsoleAndDebug.WriteLine("" );

            Test<Option1.RootObject>(xml, true);

            Test<Option2.RootObject>(xml, true);

            Test<Option3.RootObject>(xml, false);

        }

​

        static void Test<TRootObject>(string xml, bool shouldBeEqual) where TRootObject : class, new()

        {

            ConsoleAndDebug.WriteLine("Deserializing " + typeof(TRootObject).FullName + ": " );

            var root = xml.LoadFromXML<TRootObject>();

​

            var xml2 = root.GetXml(true);

​

            ConsoleAndDebug.WriteLine("Re-serialized XML:" );

            ConsoleAndDebug.WriteLine(xml2);

            if (shouldBeEqual)

            {

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

                {

                    throw new InvalidOperationException("!XNode.DeepEquals(XElement.Parse(xml), XElement.Parse(xml2))");

                }

                else

                {

                    ConsoleAndDebug.WriteLine("Original and re-serialized XML are identical." );

                }

            }

            ConsoleAndDebug.WriteLine("" );

        }

    }

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

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

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

                return textWriter.ToString();

            }

        }

    }

​

    public static class ConsoleAndDebug

    {

        public static void WriteLine(object s)

        {

            Console.WriteLine(s);

            Debug.WriteLine(s);

        }

    }

​