using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Diagnostics;

using System.Collections.ObjectModel;

using System.Runtime.Serialization;

using System.Xml;

​

using ProtoBuf.Meta;

using ProtoBuf;

​

using System.Globalization;

using System.Threading;

​

using System.ComponentModel;

​

// https://stackoverflow.com/questions/41023794/protobuf-net-serialize-a-property-of-type-system-io-stream-without-loading-the

​

    public class SeekableStreamByteList : IList<byte>

    {

        readonly Stream stream;

​

        public SeekableStreamByteList(Stream stream)

        {

            if (stream == null)

                throw new ArgumentNullException();

            if (!stream.CanSeek)

                throw new ArgumentException("!stream.CanSeek");

            this.stream = stream;

​

        }

​

        #region IList<byte> Members

​

        public int IndexOf(byte item) { throw new NotImplementedException(); }

​

        public void Insert(int index, byte item) { throw new NotImplementedException(); }

​

        public void RemoveAt(int index) { throw new NotImplementedException(); }

​

        public byte this[int index]

        {

            get

            {

                if (index < 0 || index >= stream.Length)

                    throw new ArgumentOutOfRangeException();

                stream.Position = index;

                return checked((byte)stream.ReadByte());

​

            }

            set

            {

                throw new NotImplementedException();

            }

        }

​

        #endregion

​

        #region ICollection<byte> Members

​

        public void Add(byte item) { throw new NotImplementedException(); }

​

        public void Clear() { throw new NotImplementedException(); }

​

        public bool Contains(byte item) { throw new NotImplementedException(); }

​

        public void CopyTo(byte[] array, int arrayIndex)

        {

            foreach (var item in this)

                array[arrayIndex++] = item;

        }

​

        public int Count { get { return checked((int)stream.Length); } }

​

        public bool IsReadOnly { get { return true; } }

​

        public bool Remove(byte item) { throw new NotImplementedException(); }

​

        #endregion

​

        #region IEnumerable<byte> Members

​

        const int ChunkSize = 4096;

​

        internal static event EventHandler OnDataReadBegin;

​

        internal static event EventHandler OnDataReadEnd;

​

        public IEnumerator<byte> GetEnumerator()

        {

            var oldPosition = stream.Position;

​

            if (OnDataReadBegin != null)

                OnDataReadBegin(this, new EventArgs());

​

            try

            {

                stream.Position = 0;

                byte[] buffer = new byte[ChunkSize];

                int read;

                do

                {

                    read = stream.Read(buffer, 0, buffer.Length);

                    for (int i = 0; i < read; i++)

                    {

                        yield return buffer[i];

                    }

                }

                while (read == buffer.Length);

​

                if (OnDataReadEnd != null)

                    OnDataReadEnd(this, new EventArgs());

            }

            finally

            {

                stream.Position = oldPosition;

            }

        }

​

        #endregion

​

        #region IEnumerable Members

​

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }

​

        #endregion

    }

​

    [ProtoContract]

    class StreamObject

    {

        public StreamObject(Stream stream)

        {

            if (stream == null)

                throw new ArgumentNullException();

            this.StreamProperty = stream;

        }

​

        [ProtoIgnore]

        public Stream StreamProperty { get; set; }

​

        [ProtoMember(1, IsPacked = true)]

        SeekableStreamByteList StreamBytes

        {

            get

            {

                return new SeekableStreamByteList(StreamProperty);

            }

        }

    }

​

    [ProtoContract]

    class ByteListObject

    {

        [ProtoMember(1, IsPacked = true)]

        public List<byte> StreamBytes { get; set; }

    }

​

    internal class TestClass

    {

        public void Test()

        {

            Console.WriteLine(string.Format("Contract for {0}: ", typeof(StreamObject)));

            Console.WriteLine(RuntimeTypeModel.Default.GetSchema(typeof(StreamObject)));

            Console.WriteLine(string.Format("Contract for {0}: ", typeof(ByteListObject)));

            Console.WriteLine(RuntimeTypeModel.Default.GetSchema(typeof(ByteListObject)));

​

            var writeStream = new MemoryStream();

​

            long beginLength = 0;

            long endLength = 0;

​

            EventHandler begin = (o, e) => { beginLength = writeStream.Length; Console.WriteLine(string.Format("Begin serialization of Data, writeStream.Length = {0}", writeStream.Length)); };

            EventHandler end = (o, e) => { endLength = writeStream.Length; Console.WriteLine(string.Format("End serialization of Data, writeStream.Length = {0}", writeStream.Length)); };

​

            SeekableStreamByteList.OnDataReadBegin += begin;

            SeekableStreamByteList.OnDataReadEnd += end;

​

            try

            {

                int length = 100000;

​

                var inputStream = new MemoryStream();

                for (int i = 0; i < length; i++)

                {

                    inputStream.WriteByte(unchecked((byte)i));

                }

                inputStream.Position = 0;

​

                var streamObject = new StreamObject(inputStream);

​

                Serializer.Serialize(writeStream, streamObject);

                var data = writeStream.ToArray();

​

                ByteListObject newStreamObject;

                using (var s = new MemoryStream(data))

                {

                    newStreamObject = Serializer.Deserialize<ByteListObject>(s);

                }

​

                if (!inputStream.ToArray().SequenceEqual(newStreamObject.StreamBytes))

                {

                    throw new InvalidOperationException("!inputStream.AsEnumerable().SequenceEqual(newStreamObject.StreamProperty.AsEnumerable())");

                }

                else

                {

                    Console.WriteLine("Streams round-tripped successfully.");

                }

​

                if (beginLength >= endLength)

                {

                    throw new InvalidOperationException("inputStream was completely loaded into memory before writing to writeStream!");

                }

                else

                {

                    Console.WriteLine("inputStream was successfully streamed to writeStream.");

                }

            }

            finally

            {

                SeekableStreamByteList.OnDataReadBegin -= begin;

                SeekableStreamByteList.OnDataReadEnd -= end;

            }

        }

    }

​

    public static class StreamExtensions

    {

        public static IEnumerable<byte> AsEnumerable(this Stream stream)

        {

            if (stream == null)

                throw new ArgumentNullException();

            int b;

            while ((b = stream.ReadByte()) != -1)

                yield return checked((byte)b);

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("protobuf-net version: " + typeof(ProtoBuf.Serializer).Assembly.FullName);

            Console.WriteLine("");

            ProtoBuf.Meta.RuntimeTypeModel.Default.AutoCompile = false; // Required for security on dotnetfiddle

​

            new TestClass().Test();

        }

    }

​