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

​

    [ProtoContract]

    class StreamObject

    {

        public StreamObject() : this(new MemoryStream()) { }

​

        public StreamObject(Stream stream)

        {

            if (stream == null)

                throw new ArgumentNullException();

            this.StreamProperty = stream;

        }

​

        [ProtoIgnore]

        public Stream StreamProperty { get; set; }

​

        internal static event EventHandler OnDataReadBegin;

​

        internal static event EventHandler OnDataReadEnd;

​

        const int ChunkSize = 4096;

​

        [ProtoMember(1, IsPacked = false, OverwriteList = true)]

        IEnumerable<ByteBuffer> Data

        {

            get

            {

                if (OnDataReadBegin != null)

                    OnDataReadBegin(this, new EventArgs());

​

                while (true)

                {

                    byte[] buffer = new byte[ChunkSize];

                    int read = StreamProperty.Read(buffer, 0, buffer.Length);

                    if (read <= 0)

                    {

                        break;

                    }

                    else if (read == buffer.Length)

                    {

                        yield return new ByteBuffer { Data = buffer };

                    }

                    else

                    {

                        Array.Resize(ref buffer, read);

                        yield return new ByteBuffer { Data = buffer };

                        break;

                    }

                }

​

                if (OnDataReadEnd != null)

                    OnDataReadEnd(this, new EventArgs());

            }

            set

            {

                if (value == null)

                    return;

                foreach (var buffer in value)

                    StreamProperty.Write(buffer.Data, 0, buffer.Data.Length);

            }

        }

    }

​

    [ProtoContract]

    struct ByteBuffer

    {

        [ProtoMember(1, IsPacked = true)]

        public byte[] Data { get; set; }

    }

​

    internal class TestClass

    {

        public void Test()

        {

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

​

            StreamObject.OnDataReadBegin += begin;

            StreamObject.OnDataReadEnd += end;

​

            try

            {

                int length = 1000000;

​

                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();

​

                StreamObject newStreamObject;

                using (var s = new MemoryStream(data))

                {

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

                }

​

                if (beginLength >= endLength)

                {

                    throw new InvalidOperationException("inputStream was completely buffered before writing to writeStream");

                }

​

                inputStream.Position = 0;

                newStreamObject.StreamProperty.Position = 0;

​

                if (!inputStream.AsEnumerable().SequenceEqual(newStreamObject.StreamProperty.AsEnumerable()))

                {

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

                }

                else

                {

                    Console.WriteLine("Streams identical.");

                }

            }

            finally

            {

                StreamObject.OnDataReadBegin -= begin;

                StreamObject.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();

        }

    }

​