Principaux formats de sérialisation : XML, JSON, CSV, Protobuf

1. Pourquoi choisir un format ? Petit rappel

Tout objet .NET en mémoire — c'est un ensemble d'adresses, de références, de champs, de structures internes et d'autres "mécanismes machine". Mais on ne peut pas simplement l'enregistrer dans un fichier tel quel : les fichiers doivent être structurés dans un format que d'autres programmes savent lire (et de préférence écrire). C'est là qu'intervient le choix du format de sérialisation.

Objectifs principaux d'un format de sérialisation :

• Compacticité : place sur le disque ou vitesse de transmission sur le réseau.
• Lisibilité (humaine !) : peut-on ouvrir le fichier dans un éditeur de texte et comprendre ce qu'il contient.
• Universalité : convient-il pour l'intégration avec d'autres systèmes et langages.
• Support des structures complexes : imbrications, collections, références, types.
• Sécurité et compatibilité.

2. Sérialisation binaire (Binary Serialization)

Sérialisation binaire représente les données sous forme d'un flux "brut" d'octets. Imaginez que vous n'ayez pas seulement emballé des choses dans une boîte, mais que vous les ayez cimentées — rapide, compact, mais ensuite vous ne retrouverez pas vos chaussettes sans un marteau-piqueur.

// Exemple uniquement à titre historique :
using System.Runtime.Serialization.Formatters.Binary;

// ... création d'objet
var user = new User { Name = "Ivan", Age = 42 };

// Sérialisation
using var fs = new FileStream("user.bin", FileMode.Create);
var formatter = new BinaryFormatter();
formatter.Serialize(fs, user);

Avantages :

• Compacticité : utilise très peu d'espace disque, grande vitesse.
• Support intégré des types "natifs" .NET.

Inconvénients :

• Format totalement illisible — essayez d'ouvrir le fichier avec le Bloc-notes, vous tomberez dans la Matrice (en clair : un ramassis de caractères incompréhensibles).
• Absolument non universel : seulement pour .NET (et encore, pour la même version !).
• Sensible aux problèmes de compatibilité entre versions.

Où ça a été utilisé ?

À l'intérieur de .NET, quand il fallait rapidement "dump" des objets entre processus sur une même machine. Aujourd'hui c'est fortement NON recommandé, surtout si vous vous souciez de la sécurité et de la maintenance à long terme de l'application. L'utilisation de BinaryFormatter dans des projets modernes est une mauvaise pratique.

3. Format XML (Extensible Markup Language)

XML — format lisible par l'humain et la machine, basé sur des balises, comme le HTML, mais sans les blagues sur <body>.

<User>
  <Name>Ivan</Name>
  <Age>42</Age>
</User>

Exemple de sérialisation :

using System.Xml.Serialization;

var user = new User { Name = "Ivan", Age = 42 };

var serializer = new XmlSerializer(typeof(User));
using var fs = new FileStream("user.xml", FileMode.Create);
serializer.Serialize(fs, user);

Avantages :

• Lisibilité : on peut ouvrir et voir la structure à l'œil nu.
• Universalité : XML peut être lu par de nombreux langages et outils.
• Flexibilité (support des schémas, validation, namespaces, etc.).
• Bien adapté aux structures complexes et aux objets imbriqués.

Inconvénients :

• "Bruit" et lourdeur : occupe beaucoup d'espace et de bande passante.
• Parsing plus lent que pour les formats binaires.
• Imprécision lors de la sérialisation de certains types (par exemple dates et heures).
• Nécessite des réglages supplémentaires pour supporter certaines collections ou objets non standards.

Où s'applique-t-il ?

Échange de données entre systèmes d'entreprise, configs, intégration avec des systèmes où une structure stricte est requise.

4. Format JSON (JavaScript Object Notation)

JSON — format compact, léger, facile à lire, venu du monde JavaScript et ayant conquis presque tout l'écosystème d'échange de données grâce à sa concision et sa simplicité.

{
  "Name": "Ivan",
  "Age": 42
}

Exemple de sérialisation :

using System.Text.Json;

var user = new User { Name = "Ivan", Age = 42 };

string json = JsonSerializer.Serialize(user);
File.WriteAllText("user.json", json);

Avantages :

• Très lisible pour l'humain et la machine.
• Intégration facile avec les technologies web (API, JavaScript, etc.).
• Plus compact que XML.
• Sérialisation/désérialisation rapide avec des bibliothèques modernes (System.Text.Json, Newtonsoft.Json).

Inconvénients :

• Pas de support pour les commentaires (votre JSON ne pourra pas plaisanter sur lui-même).
• Limitations structurelles : ne sait pas sérialiser, par exemple, des références entre objets ou des types complexes (par ex. dictionnaires avec des clés non-strings).
• Différences d'interprétation des formats date/heure entre différentes implémentations.

Où s'applique-t-il ?

Pratiquement partout où un échange d'information entre plateformes est nécessaire : services web, applications mobiles, REST API, etc.

5. CSV (Comma-Separated Values)

CSV — format texte simple représentant des données en table (lignes et colonnes), où les champs sont séparés par des virgules ou un autre séparateur.

Name,Age
Ivan,42
Olga,27

Exemple d'écriture CSV manuelle :

// Pour la simplicité, on écrit avec un StreamWriter basique
var lines = new List<string>
{
    "Name,Age",
    "Ivan,42",
    "Olga,27"
};
File.WriteAllLines("users.csv", lines);

Avantages :

• Supporté par un grand nombre de programmes (Excel, Google Docs, DBs, etc.).
• Concise et pratique pour des données tabulaires.

Inconvénients :

• Ne convient pas aux objets imbriqués ou complexes (seulement structures "plates").
• Ne conserve pas les types de données (tout est string).
• Problèmes d'échappement si les données contiennent des virgules, des guillemets, ou des sauts de ligne.

Où s'applique-t-il ?

Export/import de données entre DBs, échange d'ensembles d'enregistrements simples, extractions depuis des applications.

6. Protocoles et formats d'échange à typage strict

Protocol Buffers (protobuf) et MessagePack — formats de sérialisation binaire avec contrats (schémas) qui rendent la sérialisation encore plus compacte et rapide. Ils requièrent une description préalable du schéma des données.

Exemple en protobuf (simplifié) :

Non inclus dans .NET standard, nécessite le package Google.Protobuf.

message User {
  string name = 1;
  int32 age = 2;
}

Avantages :

• Vitesse et compacticité maximales.
• Cross-platform (beaucoup de langages supportent protobuf).

Inconvénients :

• Plus compliqué à apprendre et configurer.
• Requiert génération de code à partir du schéma.
• Pas toujours nécessaire si votre projet ne traite pas des millions de messages par seconde.

Où s'applique-t-il ?

Systèmes à haute charge, échange entre microservices, jeux, IoT.

7. Détails utiles

Tableau comparatif des formats

Comment choisir le format de sérialisation pour votre application ?

Vous sauvegardez une structure de données complexe et la lisibilité humaine est importante — utilisez XML ou JSON.

Vous devez rapidement transmettre un grand volume de données entre des services que vous contrôlez — envisagez protobuf ou MessagePack.

Vous exportez des rapports pour analyse dans Excel ou une DB — utilisez CSV.

Vous écrivez une config pour des services ou CI/CD — YAML vous dépannera très bien.

Compacticité, vitesse et support des références entre objets — c'est critique ? Il faudra opter pour des formats binaires, mais gardez en tête les inconvénients en matière de sécurité et de compatibilité.

8. Astuces et erreurs fréquentes

Si vous décidez de stocker des données en binaire pour la "confidentialité", souvenez-vous : un dump binaire n'est pas synonyme de sécurité. Un attaquant peut toujours "décortiquer" ce flux. Utilisez du chiffrement si nécessaire.

Problème fréquent : oublier l'encodage quand vous travaillez avec des formats texte (XML/JSON/CSV) — utilisez UTF-8. Tous les éditeurs et systèmes n'aiment pas le BOM.

XML, même s'il paraît "vieux", est excellent pour les protocoles contractuels où une description de structure stricte est importante (par ex. schémas XSD), tandis que JSON sert bien les échanges rapides et flexibles.

Lors de la sérialisation de collections d'objets complexes, tous les formats ne supportent pas correctement les structures imbriquées ou récursives. JSON et XML sont amis avec les arrays et lists, CSV ne l'est pas.