Moyen le plus rapide de sérialiser et désérialiser les objets .NET

Question

Je cherche le moyen le plus rapide de sérialiser et désérialiser des objets .NET. Voici ce que j'ai jusqu'à présent:

public class TD
{
    public List CTs { get; set; }
    public List TEs { get; set; }
    public string Code { get; set; }
    public string Message { get; set; }
    public DateTime StartDate { get; set; }
    public DateTime EndDate { get; set; }

    public static string Serialize(List tData)
    {
        var serializer = new XmlSerializer(typeof(List));

        TextWriter writer = new StringWriter();
        serializer.Serialize(writer, tData);

        return writer.ToString();
    }

    public static List Deserialize(string tData)
    {
        var serializer = new XmlSerializer(typeof(List));

        TextReader reader = new StringReader(tData);

        return (List)serializer.Deserialize(reader);
    }        
}

Answer 1

Voici votre modèle (avec CT et TE inventés) utilisant protobuf-net (tout en conservant la capacité d'utiliser XmlSerializer, ce qui peut être utile - en particulier pour la migration); je soumets humblement (avec beaucoup de preuves si vous en avez besoin) que c'est le plus rapide (ou certainement l'un des plus rapides) sérialiseurs à usage général dans .NET.

Si vous avez besoin de chaînes, encodez simplement en base 64 le binaire.

[XmlType]
public class CT {
    [XmlElement(Order = 1)]
    public int Foo { get; set; }
}
[XmlType]
public class TE {
    [XmlElement(Order = 1)]
    public int Bar { get; set; }
}
[XmlType]
public class TD {
    [XmlElement(Order=1)]
    public List CTs { get; set; }
    [XmlElement(Order=2)]
    public List TEs { get; set; }
    [XmlElement(Order = 3)]
    public string Code { get; set; }
    [XmlElement(Order = 4)]
    public string Message { get; set; }
    [XmlElement(Order = 5)]
    public DateTime StartDate { get; set; }
    [XmlElement(Order = 6)]
    public DateTime EndDate { get; set; }

    public static byte[] Serialize(List tData) {
        using (var ms = new MemoryStream()) {
            ProtoBuf.Serializer.Serialize(ms, tData);
            return ms.ToArray();
        }            
    }

    public static List Deserialize(byte[] tData) {
        using (var ms = new MemoryStream(tData)) {
            return ProtoBuf.Serializer.Deserialize>(ms);
        }
    }
}

Answer 2

Une comparaison complète entre différents formats faite par moi dans ce post- https://medium.com/@maximn/serialization-performance-comparison-xml-binary-json-p-ad737545d227

Juste un exemple du post-

Answer 3

Ayant un intérêt pour cela, j'ai décidé de tester les méthodes suggérées avec le test "apples to apples" le plus proche que je pouvais. J'ai écrit une application Console, avec le code suivant :

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace SerializationTests
{
    class Program
    {
        static void Main(string[] args)
        {
            var count = 100000;
            var rnd = new Random(DateTime.UtcNow.GetHashCode());
            Console.WriteLine("Génération de {0} tableaux de données...", count);
            var arrays = new List();
            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("Données de test générées.");
            var stopWatch = new Stopwatch();

            Console.WriteLine("Test du BinarySerializer...");
            var binarySerializer = new BinarySerializer();
            var binarySerialized = new List();
            var binaryDeserialized = new List();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                binarySerialized.Add(binarySerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("BinaryFormatteur: La sérialisation a pris {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in binarySerialized)
            {
                binaryDeserialized.Add(binarySerializer.Deserialize(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("BinaryFormatteur: La désérialisation a pris {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine();
            Console.WriteLine("Test du sérialiseur ProtoBuf...");
            var protobufSerializer = new ProtoBufSerializer();
            var protobufSerialized = new List();
            var protobufDeserialized = new List();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                protobufSerialized.Add(protobufSerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("ProtoBuf: La sérialisation a pris {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in protobufSerialized)
            {
                protobufDeserialized.Add(protobufSerializer.Deserialize(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("ProtoBuf: La désérialisation a pris {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine();
            Console.WriteLine("Test du sérialiseur NetSerializer...");
            var netSerializerSerializer = new ProtoBufSerializer();
            var netSerializerSerialized = new List();
            var netSerializerDeserialized = new List();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                netSerializerSerialized.Add(netSerializerSerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("NetSerializer: La sérialisation a pris {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in netSerializerSerialized)
            {
                netSerializerDeserialized.Add(netSerializerSerializer.Deserialize(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("NetSerializer: La désérialisation a pris {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine("Appuyez sur n'importe quelle touche pour terminer.");
            Console.ReadKey();
        }

        public class BinarySerializer
        {
            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(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    var result = (T)Formatter.Deserialize(stream);
                    return result;
                }
            }
        }

        public class ProtoBufSerializer
        {
            public byte[] Serialize(object toSerialize)
            {
                using (var stream = new MemoryStream())
                {
                    ProtoBuf.Serializer.Serialize(stream, toSerialize);
                    return stream.ToArray();
                }
            }

            public T Deserialize(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    var result = ProtoBuf.Serializer.Deserialize(stream);
                    return result;
                }
            }
        }

        public class NetSerializer
        {
            private static readonly NetSerializer Serializer = new NetSerializer();
            public byte[] Serialize(object toSerialize)
            {
                return Serializer.Serialize(toSerialize);
            }

            public T Deserialize(byte[] serialized)
            {
                return Serializer.Deserialize(serialized);
            }
        }
    }
}

Les résultats m'ont surpris ; ils étaient cohérents lorsqu'ils étaient exécutés plusieurs fois :

Génération de 100000 tableaux de données...
Données de test générées.
Test du BinarySerializer...
BinaryFormatteur: La sérialisation a pris 336.8392ms.
BinaryFormatteur: La désérialisation a pris 208.7527ms.

Test du sérialiseur ProtoBuf...
ProtoBuf: La sérialisation a pris 2284.3827ms.
ProtoBuf: La désérialisation a pris 2201.8072ms.

Test du sérialiseur NetSerializer...
NetSerializer: La sérialisation a pris 2139.5424ms.
NetSerializer: La désérialisation a pris 2113.7296ms.
Appuyez sur n'importe quelle touche pour terminer.

En rassemblant ces résultats, j'ai décidé de voir si ProtoBuf ou NetSerializer se comportaient mieux avec des objets plus volumineux. J'ai changé le compte de collection à 10 000 objets, mais j'ai augmenté la taille des tableaux de 1 à 10 000 au lieu de 1 à 100. Les résultats semblaient encore plus définitifs:

Génération de 10000 tableaux de données...
Données de test générées.
Test du BinarySerializer...
BinaryFormatter: La sérialisation a pris 285.8356ms.
BinaryFormatter: La désérialisation a pris 206.0906ms.

Test du sérialiseur ProtoBuf...
ProtoBuf: La sérialisation a pris 10693.3848ms.
ProtoBuf: La désérialisation a pris 5988.5993ms.

Test du sérialiseur NetSerializer...
NetSerializer: La sérialisation a pris 9017.5785ms.
NetSerializer: La désérialisation a pris 5978.7203ms.
Appuyez sur n'importe quelle touche pour terminer.

Ma conclusion, par conséquent, est que : il peut y avoir des cas où ProtoBuf et NetSerializer sont bien adaptés, mais en termes de performances brutes pour au moins des objets relativement simples... BinaryFormatter est nettement plus performant, au moins d'un ordre de grandeur.

YMMV.

Answer 4

Protobuf est très très rapide.

Voir http://code.google.com/p/protobuf-net/wiki/Performance pour des informations approfondies concernant les performances de ce système et une mise en œuvre.

Answer 5

Un autre sérialiseur prétendant être super rapide est netserializer.

Les données fournies sur leur site montrent des performances de 2x - 4x supérieures à celles de protobuf, je ne l'ai pas testé moi-même, mais si vous évaluez différentes options, essayez celui-ci aussi