https://stackoverflow.com/questions/53527040/ixmlserializable-readxml-implementation?noredirect=1#comment94103552_53527040

CSharp · Console

/Program.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Schema;
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 NUnit.Framework; //NUnit.Framework.AssertionException

//https://stackoverflow.com/questions/53527040/ixmlserializable-readxml-implementation?noredirect=1#comment94103552_53527040

	public class ItemProperty : IXmlSerializable
	{
		public static ItemProperty Empty { get; } = new ItemProperty();

		public ItemProperty()
		{
			this.Name = string.Empty;
			this.Value = string.Empty;
			this.Id = 0;
			this.Order = 0;
		}

		public string Name { get; set; }

		[XmlText] // no effect while using IXmlSerializable
		public string Value { get; set; }

		[XmlAttribute("id")] // no effect while using IXmlSerializable
		public int Id { get; set; }

		[XmlAttribute("itemOrder")] // no effect while using IXmlSerializable
		public int Order { get; set; }

		public XmlSchema GetSchema()
		{
			return null;
		}

		public void ReadXml(XmlReader reader)
		{
			reader.MoveToContent();
			
			this.Name = reader.LocalName; // Do not include the prefix (if present) in the Name.
			
			if (reader.HasAttributes)
			{
				var id = reader.GetAttribute("id");
				if (id != null)
					// Since id is missing from some elements you might want to make it nullable
					this.Id = XmlConvert.ToInt32(id);

				var order = reader.GetAttribute("itemOrder");
				if (order != null)
					// Since itemOrder is missing from some elements you might want to make it nullable
					this.Order = XmlConvert.ToInt32(order);

				string sequence = reader.GetAttribute("seq");
				//There is no Sequence property?
				//this.Sequence = Convert.ToInt32(sequence);
			}

			// Read element value.
			// This method reads the start tag, the contents of the element, and moves the reader past the end element tag.
			// thus there is no need for an additional Read()
			this.Value = reader.ReadElementContentAsString();
		}

		public void WriteXml(XmlWriter writer)
		{
			throw new NotImplementedException();
		}
	}

	[Serializable]
	public class ItemBase
	{
		[XmlElement("Value")]
		public virtual ItemProperty ItemNumber { get; set; } = ItemProperty.Empty;

		[XmlElement("Category")] // FIXED renamed to Category
		public virtual ItemProperty Category { get; set; } = ItemProperty.Empty;

		[XmlElement("EmptyElement")] // ADDED for testing purposes
		public virtual ItemProperty EmptyElement { get; set; } = ItemProperty.Empty;

		[XmlElement("NonEmptyElement")] // ADDED for testing purposes
		public virtual ItemProperty NonEmptyElement { get; set; } = ItemProperty.Empty;

		//...  like 100 other properties
	}

	[Serializable]
	[XmlRoot("Data")]
	public class ItemData
	{
		[XmlAttribute("totalExecutionTime")]
		public string ExecutionTime { get; set; }

		[XmlElement("ItemNumber", Type = typeof(ItemBase))]
		public List<ItemBase> Items { get; set; }
	}

    public class TestClass
    {
        public static void Test()
        {
			var xml = GetXml();
			
			Console.WriteLine("Input XML: ");
			Console.WriteLine(XElement.Parse(xml));
			
			var data = xml.LoadFromXml<ItemData>();
			
			data.Dump();
			
			Assert.IsTrue(data.Items.Count == 1);
			Assert.IsTrue(data.Items[0].ItemNumber.Name == "Value");
			Assert.IsTrue(data.Items[0].Category.Name == "Category");
			Assert.IsTrue(data.Items[0].EmptyElement.Name == "EmptyElement");
			Assert.IsTrue(data.Items[0].NonEmptyElement.Name == "NonEmptyElement");
        }
		
		static string GetXml()
		{
			var xml = @"<Data totalExecutionTime=""00:00:00.0467241"">
    <ItemNumber id=""1234"" order=""0"" createdDate=""2017-03-24T12:07:09.07"" modifiedDate=""2018-08-29T16:59:19.127"">
        <!-- Comment --><Value modifiedDate=""2017-03-24T12:07:12.77"">ABC1234</Value>
        <NonEmptyElement id=""3"" parentID=""9876"" itemOrder=""3"" modifiedDate=""2017-03-24T12:16:23.687"">AA<![CDATA[ <&&> some cdata <&&> ]]>BB</NonEmptyElement>
        <EmptyElement id=""2"" parentID=""9876"" itemOrder=""2"" modifiedDate=""2017-03-24T12:16:23.687"" />
        <Category id=""5432"" parentID=""9876"" itemOrder=""1"" modifiedDate=""2017-03-24T12:16:23.687"">The best category</Category>
        ... <!-- like 100 other elements -->
    </ItemNumber>
</Data>";
			return xml;
		}
    }

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