using System;

using System.IO;

using System.Text;

using System.Xml;

using System.Xml.Serialization;

​

public class Program

{

    public static void Main(string[] args)

    {

        XmlSerializer serializer = new XmlSerializer(typeof (ExampleClass));

        //      

        var amountOfElements = 100;

        //      

        //

        using (var dataStream = new XmlExampleStream(amountOfElements))

        {

            using (var reader = new XmlTextReader(dataStream))

            {

                // Buffer for the element contents

                StringBuilder sb = new StringBuilder(1000);

                // Read till next node

                while (reader.Read())

                {

                    switch (reader.NodeType)

                    {

                        case XmlNodeType.Element: 

                            // Clear the stringbuilder when we start with our element 

                            if (string.Equals(reader.Name, "specialelement"))

                            {

                                sb.Clear();

                            }

                            // Append current element without namespace

                            sb.Append("<").Append(reader.Name).Append(">");

                            break;

                        //

                        case XmlNodeType.Text: //Display the text in each element.

                            sb.Append(reader.Value);

                            break;

                        //

                        case XmlNodeType.EndElement: 

                            // Append the closure element

                            sb.Append("</").Append(reader.Name).Append(">");

                            //

                            // Check if we have finished reading our element

                            if (string.Equals(reader.Name, "specialelement"))

                            {

                                // The strinbuilder now contains the entire 'SpecialElement' part

                                using (TextReader textReader = new StringReader(sb.ToString()))

                                {

                                    // Deserialize

                                    var deserializedElement = (ExampleClass)serializer.Deserialize(textReader);

                                    // Send to handler

                                    HandleElement(deserializedElement);

                                }

                            }

​

                            break;

                    }

                }

            }

        }

​

        Console.WriteLine("[done]");

    }

​

    public static void HandleElement(ExampleClass item)

    {

        // Do something with item

        Console.WriteLine("Handling element: {0}", item == null ? "NULL" : item.ToString());

    }

}

​

[XmlRoot("specialelement")]

public class ExampleClass

{

    [XmlElement(ElementName = "value1")]

    public string Value1

    {

        get;

        set;

    }

​

    [XmlElement(ElementName = "value2")]

    public string Value2

    {

        get;

        set;

    }

}

​

// Simple read that prints out a dataset with a configurable count of (the same) elements

public class XmlExampleStream : Stream

{

    private readonly int _printElements;

    private readonly int _length;

    private const string Data = "<specialelement><value1>test</value1><value2>test3</value2></specialelement>";

    private byte[] _streamBuffer = null;

    private int _buffIdx;

    private bool _rootStartPrinted = false;

    private bool _rootEndPrinted = false;

    private int _elementsPrinted = 0;

    //

    public XmlExampleStream(int printElements)

    {

        _printElements = printElements;

        _length = (Encoding.Default.GetBytes(Data).Length * _printElements) + Encoding.Default.GetBytes("<root></root>").Length;

    }

​

    /// <inheritdoc/>

    public override int Read(byte[] buffer, int offset, int count)

    {

        int bytesWritten = 0;

        if (_elementsPrinted < _printElements)

        {

            // Print root.

            if (!_rootStartPrinted)

            {

                var rootBytes = Encoding.Default.GetBytes("<root>");

                if (rootBytes.Length > count)

                    throw new InvalidProgramException("Buffer too small");

                Array.Copy(rootBytes, 0, buffer, offset, rootBytes.Length);

                bytesWritten += rootBytes.Length;

                offset += bytesWritten;

                _rootStartPrinted = true;

            }

​

            // Print elements

            while (bytesWritten < count)

            {

                // Start new buffer

                if (_streamBuffer == null)

                {

                    _streamBuffer = Encoding.Default.GetBytes(Data);

                    _buffIdx = 0;

                }

​

                // Previous buffer finished

                if (_streamBuffer.Length == _buffIdx)

                {

                    _elementsPrinted++;

                    // We are done

                    if (_elementsPrinted >= _printElements)

                        break;

                    _streamBuffer = Encoding.Default.GetBytes(Data);

                    _buffIdx = 0;

                }

​

                var bytesToCopy = Math.Min(_streamBuffer.Length - _buffIdx, count - offset);

                // Copy the next segment

                Array.Copy(_streamBuffer, _buffIdx, buffer, offset, bytesToCopy);

                _buffIdx += bytesToCopy;

                bytesWritten += bytesToCopy;

                offset += bytesToCopy;

            }

        }

​

        if (_elementsPrinted >= _printElements)

        {

            // Print final.

            if (!_rootEndPrinted)

            {

                _streamBuffer = Encoding.Default.GetBytes("</root>");

                _buffIdx = 0;

                _rootEndPrinted = true;

            }

​

            var bytesToCopy = Math.Min(_streamBuffer.Length - _buffIdx, count - offset);

            // Copy the next segment

            Array.Copy(_streamBuffer, _buffIdx, buffer, offset, bytesToCopy);

            bytesWritten += bytesToCopy;

            _buffIdx += bytesToCopy;

        }

​

        return bytesWritten;

    }

​

    /// <inheritdoc/>

    public override void Flush()

    {

        throw new NotImplementedException();

    }

​

    /// <inheritdoc/>

    public override long Seek(long offset, SeekOrigin origin)

    {

        throw new NotImplementedException();

    }

​

    /// <inheritdoc/>

    public override void SetLength(long value)

    {

        throw new NotImplementedException();

    }

​

    /// <inheritdoc/>

    public override void Write(byte[] buffer, int offset, int count)

    {

        throw new NotImplementedException();

    }

​

    /// <inheritdoc/>

    public override bool CanRead

    {

        get

        {

            return true;

        }

    }

​

    /// <inheritdoc/>

    public override bool CanSeek

    {

        get

        {

            return false;

        }

    }

​

    /// <inheritdoc/>

    public override bool CanWrite

    {

        get

        {

            return false;

        }

    }

​

    /// <inheritdoc/>

    public override long Length

    {

        get

        {

            return _length;

        }

    }

​

    /// <inheritdoc/>

    public override long Position

    {

        get;

        set;

    }

}