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/33429468/how-do-i-change-my-previously-saved-list-type-to-serilialize-into-an-array-type

​

    [ProtoContract]

    internal class ArrayHolder

    {

        private ArrayHolder()

        {

            CollectionOfBytes = new byte[0] { };

        }

​

        internal ArrayHolder(IEnumerable<byte> bytesToUse)

        {

            CollectionOfBytes = bytesToUse.ToArray();

        }

​

        [ProtoIgnore]

        public byte[] CollectionOfBytes { get; set; }

​

        [ProtoMember(1, OverwriteList = true)]

        List<byte> ListOfBytes

        {

            get

            {

                if (CollectionOfBytes == null)

                    return null;

                return new List<byte>(CollectionOfBytes);

            }

            set

            {

                if (value == null)

                    return;

                CollectionOfBytes = value.ToArray();

            }

        }

    }

​

    [ProtoContract]

    internal class ListHolder

    {

        private ListHolder()

        {

            CollectionOfBytes = new List<byte>();

        }

​

        internal ListHolder(IEnumerable<byte> bytesToUse)

        {

            CollectionOfBytes = bytesToUse.ToList();

        }

​

        [ProtoMember(1)]

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

    }

​

    public class TestClass

    {

        public static void Test()

        {

            try

            {

                Test(Enumerable.Range(0, 3 * byte.MaxValue).Select(i => unchecked((byte)i)).ToArray());

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failure: ");

                Console.WriteLine(ex);

                throw;

            }

            Console.WriteLine("Successfully round-tripped all possible byte values.");

        }

​

        private static void Test(byte [] values)

        {

            var test = new TestClass();

​

            test.TestChangeListToArray(values);

            test.TestChangeArrayToList(values);

            test.TestListRoundTrip(values);

            test.TestArrayRoundTrip(values);

        }

​

        public void TestListRoundTrip(IEnumerable<byte> values)

        {

            var a = new ListHolder(values);

​

            var aCopy = Deserialize<ListHolder>(Serialize(a));

​

            //Passes

            Assert.That(aCopy.CollectionOfBytes.SequenceEqual(a.CollectionOfBytes));

        }

​

        public void TestArrayRoundTrip(IEnumerable<byte> values)

        {

            var a = new ArrayHolder(values);

​

            var aCopy = Deserialize<ArrayHolder>(Serialize(a));

​

            //Passes

            Assert.That(aCopy.CollectionOfBytes.SequenceEqual(a.CollectionOfBytes));

        }

​

        public void TestChangeArrayToList(IEnumerable<byte> values)

        {

            var a = new ArrayHolder(values);

​

            var aCopy = Deserialize<ListHolder>(Serialize(a));

​

            //Passes

            Assert.That(aCopy.CollectionOfBytes.SequenceEqual(a.CollectionOfBytes));

        }

​

        public void TestChangeListToArray(IEnumerable<byte> values)

        {

            var a = new ListHolder(values);

​

            var aCopy = Deserialize<ArrayHolder>(Serialize(a));

​

            Assert.That(aCopy.CollectionOfBytes.SequenceEqual(a.CollectionOfBytes));

        }

​

        public static byte[] Serialize<T>(T obj)

        {

            using (var stream = new MemoryStream())

            {

                Serializer.Serialize(stream, obj);

                return stream.ToArray();

            }

        }

​

        public static T Deserialize<T>(byte[] buffer)

        {

            using (var stream = new MemoryStream(buffer))

            {

                return Serializer.Deserialize<T>(stream);

            }

        }

    }

​

    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

​

            TestClass.Test();

        }

    }

​

    public static class Assert

    {

        public static void That(bool val)

        {

            if (!val)

            {

                throw new InvalidOperationException();

            }

        }

    }

​