using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Diagnostics;

using System.Collections.ObjectModel;

using System.ComponentModel;

using System.Xml.Linq;

using System.Reflection;

using System.Data;

using System.Xml.Schema;

using System.Text.RegularExpressions;

using System.Net;

using System.Xml.XPath;

using System.Globalization;

using System.ComponentModel.DataAnnotations;

using System.Collections;

using System.Runtime.InteropServices;

using System.Runtime.Serialization;

using System.Threading.Tasks;

​

​

// https://stackoverflow.com/questions/45244717/how-to-check-if-another-node-exists-in-an-xml-without-reading-c-sharp

​

    public abstract class EntityBase

    {

        [XmlAttribute]

        public string AttributeValue { get; set; }

​

        [XmlElement]

        public string ElementValue { get; set; }

    }

​

    public class Entity : EntityBase

    {

    }

​

    public class UndesiredEntity : EntityBase

    {

    }

​

    public class RootObject

    {

        public RootObject() { this.Entities = new List<EntityBase>(); }

​

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

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

        public List<EntityBase> Entities { get; set; }

    }

​

    public class TAxEntity : Entity

    {

    }

​

    class TestClass

    {

        string EntityElementName { get { return "TAxEntity"; } }

        private Task<List<TAxEntity>> Deserialize(XmlReader reader)

        {

            var entities = reader.DeserializeSequence<TAxEntity>(EntityElementName, "" /* Pass the correct namespace here */).ToList();

            return Task.FromResult(entities);

        }       

        public static void Test()

        {

            Test(null, null);

            Test("a", "b");

        }

​

        public static void Test(string attributeValue, string elementValue)

        {

            var test = new RootObject

            {

                Entities = 

                {

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new UndesiredEntity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new UndesiredEntity { AttributeValue = attributeValue, ElementValue = elementValue },

                    new Entity { AttributeValue = attributeValue, ElementValue = elementValue },

                }

            };

​

            DoTest(test, new XmlWriterSettings { Indent = false });

            DoTest(test, new XmlWriterSettings { Indent = true });

        }

​

        static void DoTest(RootObject root, XmlWriterSettings settings)

        {

            var xml = GetXml(root, settings, null, null);

            Console.WriteLine("Testing sequential deserialization of entity nodes from XML: ");

            Console.WriteLine(xml);

​

            List<Entity> list;

​

            using (var reader = XmlReader.Create(new StringReader(xml)))

            {

                reader.ReadToDescendant("Entity", "");

​

                list = reader.DeserializeSequence<Entity>("Entity", "").ToList();

            }

​

            var count1 = root.Entities.OfType<Entity>().Count();

            var count2 = root.Entities.OfType<Entity>().Count();

            Assert.IsTrue(count1 == count2);

            Console.WriteLine("Count of {0} Entity nodes is correct after deserialization.\n", count1);

        }

​

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

        {

            serializer = serializer ?? new XmlSerializer(obj.GetType());

            using (var textWriter = new StringWriter())

            {

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

                    serializer.Serialize(xmlWriter, obj, ns);

                return textWriter.ToString();

            }

        }

    }

​

    public static class XmlReaderExtensions

    {

        public static IEnumerable<TElement> DeserializeSequence<TElement>(this XmlReader reader, string localEntityElementName, string namespaceURI)

        {

            if (reader == null)

                throw new ArgumentNullException();

            var deserializer = new XmlSerializer(typeof(TElement));

            while ((reader.NodeType == XmlNodeType.Element && reader.LocalName == localEntityElementName && reader.NamespaceURI == namespaceURI)

                || reader.ReadToNextSibling(localEntityElementName, namespaceURI))

            {

                // Using ReadSubtree instead of ReadOuterXml() avoids having do parse, reformat, then parse the formatted XML a second time

                // by reading directly from the current stream only once.

                TElement element;

                using (var subReader = reader.ReadSubtree())

                {

                    element = (TElement)deserializer.Deserialize(subReader);

                }

                // Consume the EndElement also (or move past the current element if reader.IsEmptyElement).

                reader.Read();

                yield return element;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            if (value == false)

                throw new AssertionFailedException("failed");

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }

​