using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

using Binaron.Serializer;

​

namespace SerializationTests

{

    class Program

    {

        static void Main(string[] args)

        {

            var count = 25000;

            var rnd = new Random(DateTime.UtcNow.GetHashCode());

            Console.WriteLine("Generating {0} arrays of data...", count);

            var arrays = new List<int[]>();

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

            {

                var elements = rnd.Next(1, 100);

                var array = new int[elements];

                for (int j = 0; j < elements; j++)

                {

                    array[j] = rnd.Next();

                }   

                arrays.Add(array);

            }

            Console.WriteLine("Test data generated.");

            var watch = new Stopwatch();

            watch.Start();

​

            var serializers = new ISerializer[] {new BinarySerializer(), new BinaronSerializer(), new ProtoBufSerializer()};

            foreach (var serializer in serializers)

            {

                var serializerName = serializer.GetType().Name;

                Console.WriteLine($"Testing {serializerName}...");

​

                var serializedBytes = new List<byte[]>(count);

                var deserializedItems = new List<int[]>(count);

                foreach (var array in arrays)

                {

                    serializer.Serialize(array);

                }

​

                watch.Restart();

                foreach (var array in arrays)

                {

                    serializedBytes.Add(serializer.Serialize(array));

                }

                Console.WriteLine($"{serializerName}: Serializing took {watch.Elapsed.TotalMilliseconds}ms.");

​

                foreach (var serialized in serializedBytes)

                {

                    serializer.Deserialize<int[]>(serialized);

                }

                watch.Restart();

                foreach (var serialized in serializedBytes)

                {

                    deserializedItems.Add(serializer.Deserialize<int[]>(serialized));

                }

                Console.WriteLine($"{serializerName}: Deserializing took {watch.Elapsed.TotalMilliseconds}ms.");

            }

        }

​

        public interface ISerializer

        {

            byte[] Serialize(object toSerialize);

            T Deserialize<T>(byte[] serialized);

        }

​

        public class BinarySerializer : ISerializer

        {

            private static readonly BinaryFormatter Formatter = new BinaryFormatter();

​

            public byte[] Serialize(object toSerialize)

            {

                using (var stream = new MemoryStream())

                {

                    Formatter.Serialize(stream, toSerialize);

                    return stream.ToArray();

                }

            }

            public T Deserialize<T>(byte[] serialized)

            {

                using (var stream = new MemoryStream(serialized))

                {

                    var result = (T)Formatter.Deserialize(stream);

                    return result;

                }

            }

        }

​

        public class ProtoBufSerializer : ISerializer

        {

            public byte[] Serialize(object toSerialize)

            {

                using (var stream = new MemoryStream())

                {

                    ProtoBuf.Serializer.Serialize(stream, toSerialize);

                    return stream.ToArray();

                }

            }

​

            public T Deserialize<T>(byte[] serialized)

            {

                using (var stream = new MemoryStream(serialized))

                {

                    var result = ProtoBuf.Serializer.Deserialize<T>(stream);

                    return result;

                }

            }

        }

​

        public class BinaronSerializer : ISerializer

        {

            private readonly SerializerOptions options = new SerializerOptions {SkipNullValues = true};

            public byte[] Serialize(object toSerialize)

            {

                using (var stream = new MemoryStream())

                {

                    BinaronConvert.Serialize(toSerialize, stream, options);

                    return stream.ToArray();

                }

            }

​

            public T Deserialize<T>(byte[] serialized)

            {

                using (var stream = new MemoryStream(serialized))

                {

                    var result = BinaronConvert.Deserialize<T>(stream);

                    return result;

                }

            }

        }

    }

}