Tampons de protocole par rapport à JSON ou BSON
Quelqu'un a-t-il des informations sur les caractéristiques de performance des tampons de protocole par rapport à BSON (JSON binaire) ou à JSON en général?
- Taille de fil
- Vitesse de sérialisation
- Vitesse de désérialisation
Ceux-ci semblent être de bons protocoles binaires à utiliser sur HTTP. Je me demande simplement ce qui serait mieux à long terme pour un environnement C #.
Voici quelques informations que je lisais sur BSON et Protocol Buffers .
Thrift est également une autre alternative de type tampon de protocole.
Il existe de bons repères de la communauté Java sur la sérialisation/désérialisation et la taille des câbles de ces technologies: https://github.com/eishay/jvm-serializers/wiki
En général, JSON a une taille de fil légèrement plus grande et un DeSer légèrement pire, mais gagne en ubiquité et en capacité à l'interpréter facilement sans l'IDL source. Le dernier point est quelque chose que Apache Avro essaie de résoudre, et il bat les deux en termes de performances.
Microsoft a publié un package C # NuGet Microsoft.Hadoop.Avro .
Cet article compare les vitesses et tailles de sérialisation en .NET, y compris JSON, BSON et XML.
http://james.newtonking.com/archive/2010/01/01/net-serialization-performance-comparison.aspx
Voici quelques benchmarks récents montrant les performances des sérialiseurs .NET populaires.
Les benchmarks Burning Monks montrent les performances de sérialisation d'un POCO simple tandis que les benchmarks Northwind complets montrent les résultats combinés de la sérialisation d'une ligne dans chaque table du jeu de données Northwind de Microsoft .
Fondamentalement, les tampons de protocole ( protobuf-net ) sont environ 7x plus rapides que la bibliothèque de classe de base Serializer la plus rapide de .NET ( XML DataContractSerializer). Il est également plus petit que la concurrence car il est également 2,2x plus petit que le format de sérialisation le plus compact de Microsofts (JsonDataContractSerializer).
Les sérialiseurs Text de ServiceStack sont les plus proches de la correspondance des performances du protobuf-net binaire où son Json Serializer est seulement 2.58x plus lent que protobuf-net.
les tampons de protocole sont conçus pour le câble:
- très petite taille de message - un aspect est une représentation d'entier de taille variable très efficace.
- Décodage très rapide - c'est un protocole binaire.
- protobuf génère un C++ super efficace pour l'encodage et le décodage des messages - indice: si vous encodez tous les var-entiers ou éléments de taille statique, il les encodera et les décodera à une vitesse déterministe.
- Il offre un modèle de données TRÈS riche - encodant efficacement des structures de données très complexes.
JSON est juste du texte et doit être analysé. indice: encoder un "milliard" int en lui prendrait pas mal de caractères: Milliard = 12 chars (échelle longue), en binaire il tient dans un uint32_t Maintenant, qu'en est-il d'essayer d'encoder un double? ce serait LOIN LOIN pire.