using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.Serialization.Formatters.Binary;

public class Program

{

    public static void Main()

    {

        var ListToSend = new List<List<string>>();

        var ListToReceive = new List<List<string>>();

        ListToSend = SimulateData().ToList();

        using (var stream = GetStream(ListToSend))

        {

            var formatter = new BinaryFormatter();

            while (stream.HasMore) 

            {

                List<string> row = formatter.Deserialize(stream) as List<string>;

                ListToReceive.Add(row);

            }

            Printer(ListToReceive);

            Console.WriteLine("Done");

        }

    }

    private static void Printer(List<List<string>> data)

    {

        Console.WriteLine("Printing");

        foreach (var row in data)

        {

            foreach (var cell in row)

            {

                Console.Write(cell + "\t");

            }

            Console.WriteLine("-------------------------------------------------------------------------------");

        }

    }

    private static EnumerableStream<T> GetStream<T>(IEnumerable<T> data)

    {

        return EnumerableStream<T>.Create(data, DeserializerCallback);

    }

​

    private static List<byte> DeserializerCallback<T>(T obj)

    {

        var binFormatter = new BinaryFormatter();

        var mStream = new MemoryStream();

        binFormatter.Serialize(mStream, obj);

        return mStream.ToArray().ToList();

    }

​

    private static IEnumerable<List<string>> SimulateData()

    {

        Random randomizer = new Random();

        for (var i = 0; i < 10; i++)

        {

            var row = new List<string>();

            for (var j = 0; j < 1000; j++)

            {

                row.Add((randomizer.Next(100)).ToString());

            }

            yield return row;

        }

    }

}

​

public class EnumerableStream<T> : Stream

{

    private readonly IEnumerator<T> _source;

    private readonly Func<T, IEnumerable<byte>> _serializer;

    private readonly Queue<byte> _buf = new Queue<byte>();

    public bool HasMore { get { return _buf.Any() || SerializeNext();} }

​

    public override bool CanRead { get {return true;} }

    public override bool CanSeek { get {return false;} }

    public override bool CanWrite { get {return false;} }

    public override long Length { get {return -1;} }

    /// <summary>

    /// Creates a new instance of <code>EnumerableStream</code>

    /// </summary>

    /// <param name="source">The source enumerable for the EnumerableStream</param>

    /// <param name="serializer">A function that converts an instance of <code>T</code> to IEnumerable<byte></param>

    public EnumerableStream(IEnumerable<T> source, Func<T, IEnumerable<byte>> serializer)

    {

        _source = source.GetEnumerator();

        _serializer = serializer;

    }

    public static EnumerableStream<T> Create(IEnumerable<T> source, Func<T, List<byte>> serializer)

    {

        return new EnumerableStream<T>(source, serializer);

    }

    private bool SerializeNext()

    {

        if (!_source.MoveNext())

            return false;

        foreach (var b in _serializer(_source.Current))

            _buf.Enqueue(b);

        return true;

    }

    private byte? NextByte()

    {

        if (_buf.Any() || SerializeNext())

        {

            return _buf.Dequeue();

        }

        return null;

    }

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

    {

        var read = 0;

        while (read < count)

        {

            var mayb = NextByte();

            if (mayb == null) break;

            buffer[offset + read] = (byte)mayb;

            read++;

        }

        return read;

    }

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

    {

        throw new NotSupportedException();

    }

    public override void Flush()

    {

        throw new NotSupportedException();

    }

    public override long Seek(long offset, SeekOrigin origin)

    {

        throw new NotSupportedException();

    }

    public override void SetLength(long value)

    {

        throw new NotSupportedException();

    }

    public override long Position

    {

        get { throw new NotSupportedException(); }

        set { throw new NotSupportedException(); }

    }

}