using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

using System.Xml.Serialization;

using System.Xml;

using System.Xml.Linq;

using System.IO;

using System.Data;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO.Compression;

using System.Reflection;

​

using NUnit.Framework; //NUnit.Framework.AssertionException

​

    // https://stackoverflow.com/questions/54476647/how-to-solve-you-need-to-add-xmlchoiceidentifierattribute-to-the-member-when?noredirect=1#comment95765973_54476647

    public static partial class ReportingManipulation

    {

        public static XmlAttributeOverrides GetXMLAttributeOverrides(Type theType, IList<string> propertiesToInlcudeInOrder)

        {

            var allProperties = theType.GetProperties(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance).Select(p => p.Name);

            return GetXMLAttributeOverrides(theType, propertiesToInlcudeInOrder, allProperties);

        }

​

        // XML Attribute Overrrides

        public static XmlAttributeOverrides GetXMLAttributeOverrides(Type theType, IList<string> propertiesToInlcudeInOrder, IEnumerable<string> allProperties)

        {

            if (propertiesToInlcudeInOrder == null || propertiesToInlcudeInOrder.Count == 0)

                return null;

​

            var theXMLAttributeOverrides = new XmlAttributeOverrides();

​

            // To Add In Order

            int counter = 1;

            foreach (var propertyNameToIncludeInOrder in propertiesToInlcudeInOrder)

            {

                // Allocate a fresh instance of XmlAttributes for each property, because we are defining a different

                // XmlElementAttribute for each

                var mainNewXMLAttributes = new XmlAttributes { XmlIgnore = false };

​

                // Specify the element order XmlElementAttribute and attach to the XmlAttributes

                var theXMLElementAttributeToAdd = new XmlElementAttribute { Order = counter };

                mainNewXMLAttributes.XmlElements.Add(theXMLElementAttributeToAdd);

​

                // Attach the override XmlElementAttribute to the property propertyNameToIncludeInOrder

                theXMLAttributeOverrides.Add(theType, propertyNameToIncludeInOrder, mainNewXMLAttributes);

​

                counter++;

            }

​

            // To Ignore

            // Using System.Linq.Enumerable.Except()

            var propertiesToNotInclude = allProperties.Except(propertiesToInlcudeInOrder);

​

            var ignoreXMLAttributes = new XmlAttributes { XmlIgnore = true };

            foreach (var propertyNameToNotInlcude in propertiesToNotInclude)

            {

                // Attach the override XmlElementAttribute to the property propertyNameToIncludeInOrder

                // No need to allocate a fresh instance of ignoreXMLAttributes for each, because the instances would all be identical

                theXMLAttributeOverrides.Add(theType, propertyNameToNotInlcude, ignoreXMLAttributes);

            }

​

            return theXMLAttributeOverrides;

        }

    }

​

    public class TestMain

    {

        #region Properties

​

        // Properties

​

        [XmlIgnore]

        public int? ID { get; set; }

        [XmlIgnore]

        public bool Select { get; set; }

​

        public string TextColumn { get; set; }

        public int NumberColumn { get; set; }

        public decimal CurrencyColumn { get; set; }

        public decimal DecimalColumn { get; set; }

        public DateTime DateColumn { get; set; }

        public string TimeColumn { get; set; }

        public DateTime DateAndTimeColumn { get; set; }

        public bool YesNoColumn { get; set; }

        public string PasswordColumn { get; set; }

        public string ColorColumn { get; set; }

        public byte[] ImageColumn { get; set; }

        public byte[] DocumentColumn { get; set; }

        public byte[] OtherColumn { get; set; }

​

        #endregion

​

        #region Constructors

​

        // Constructors

        public TestMain()

        {

            try

            {

​

            }

            catch (Exception ex)

            {

                Console.WriteLine("Error at Constructor: 'TestMain'" + Environment.NewLine + Environment.NewLine + ex.Message, "Error");

            }

        }

        public TestMain(int? theID, string theTextColumn, int theNumberColumn, decimal theCurrencyColumn, decimal theDecimalColumn, DateTime theDateColumn, string theTimeColumn, DateTime theDateAndTimeColumn, bool theYesNoColumn, string thePasswordColumn, string theColorColumn, byte[] theImageColumn, byte[] theDocumentColumn, byte[] theOtherColumn)

        {

            try

            {

                this.ID = theID;

​

                this.TextColumn = theTextColumn;

                this.NumberColumn = theNumberColumn;

                this.CurrencyColumn = theCurrencyColumn;

                this.DecimalColumn = theDecimalColumn;

                this.DateColumn = theDateColumn;

                this.TimeColumn = theTimeColumn;

                this.DateAndTimeColumn = theDateAndTimeColumn;

                this.YesNoColumn = theYesNoColumn;

                this.PasswordColumn = thePasswordColumn;

                this.ColorColumn = theColorColumn;

                this.ImageColumn = theImageColumn;

                this.DocumentColumn = theDocumentColumn;

                this.OtherColumn = theOtherColumn;

            }

            catch (Exception ex)

            {

                Console.WriteLine("Error at Constructor: 'TestMain'" + Environment.NewLine + Environment.NewLine + ex.Message, "Error");

            }

        }

​

        #endregion

    }

​

    class TestClass

    {

        public static void Test()

        {

            var xml = TestSerialize();

​

            Console.WriteLine(xml);

        }

​

        static string TestSerialize()

        {

            TestMain testItem = new TestMain(null, "TextColumnTEST", 5, Convert.ToDecimal(0.333), Convert.ToDecimal(0.777), DateTime.Now, "12:00:00", DateTime.Now, true, "Password", "#FFFFFF", null, null, null);

            List<TestMain> dataToSerialize = new List<TestMain>();

            dataToSerialize.Add(testItem);

​

            List<string> propertiesToInlcudeInOrder = new List<string>();

            propertiesToInlcudeInOrder.Add("CurrencyColumn");

            propertiesToInlcudeInOrder.Add("NumberColumn");

            propertiesToInlcudeInOrder.Add("TextColumn");

​

            XmlAttributeOverrides allXMLAttribueOverrides = ReportingManipulation.GetXMLAttributeOverrides(dataToSerialize[0].GetType(), propertiesToInlcudeInOrder);

​

            using (StringWriter mainStringWriter = new StringWriter())

            {

                XmlSerializer mainXMLSerializer = new XmlSerializer(dataToSerialize.GetType(), allXMLAttribueOverrides);

                mainXMLSerializer.Serialize(mainStringWriter, dataToSerialize);

                return mainStringWriter.ToString();

            }

        }

    }

​

    public static class XmlSerializationHelper

    {

        public static T LoadFromXml<T>(this string xmlString, XmlSerializer serial = null)

        {

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

            using (var reader = new StringReader(xmlString))

            {

                return (T)serial.Deserialize(reader);

            }

        }

​

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

        {

            return obj.GetXml(null, omitStandardNamespaces);

        }

        public static string GetXml<T>(this T obj, XmlSerializer serializer = null, 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 }; // For cosmetic purposes.

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

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

                return textWriter.ToString();

            }

        }

        public static string GetOuterXml(this XmlNode node, bool indent = true)

        {

            if (node == null)

                return null;

            using (var textWriter = new StringWriter())

            {

                var settings = new XmlWriterSettings

                {

                    Indent = indent,

                    OmitXmlDeclaration = true,

                };

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

                {

                    node.WriteTo(xmlWriter);

                }

                return textWriter.ToString();

            }

        }

    }

    public static class XmlAssert

    {

        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality

        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects

        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson

        public static void AreEqual(

            XElement expected,

            XElement actual)

        {

            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));

        }

​

        private static XElement Normalize(XElement element)

        {

            if (element.HasElements)

            {

                return new XElement(

                    element.Name,

                    element.Attributes()

                           .OrderBy(a => a.Name.ToString()),

                    element.Elements()

                           .OrderBy(a => a.Name.ToString())

                           .Select(e => Normalize(e)));

​

            }

​

            if (element.IsEmpty)

            {

                return new XElement(

                    element.Name,

                    element.Attributes()

                           .OrderBy(a => a.Name.ToString()));

            }

​

            return new XElement(element.Name, element.Attributes()

                .OrderBy(a => a.Name.ToString()), element.Value);

        }

    }

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Roslyn 2.0 Compiler; Environment version: " + Environment.Version);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Uncaught exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​