binaryformatter vs binaron serializer

CSharp · Console

/Program.cs

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