Vue d'ensemble des classes standard de serialization dans .NET

1. Introduction

Puisque nous avons décidé de « démonter la figurine LEGO en pièces », voyons quels outils .NET nous offre pour ça. Autrement dit — quelles classes standard aident à serializer et deserializer des objets vers différents formats et ce qui se cache derrière chacune d'elles.

Comment est organisée la famille de serialization .NET

À l'heure actuelle (2025) .NET propose plusieurs approches principales pour la serialization, chacune avec son propre ensemble de classes et d'outils. Les principales et les plus courantes :

• JSON-serialization — l'option principale et la plus moderne, utilisée dans la plupart des projets.
• XML-serialization — un peu plus rétro, mais toujours largement utilisé.
• Binary serialization — seulement pour des cas particuliers et généralement via des solutions tierces modernes.

Beaucoup d'exemples et la majorité du code en .NET 9 utilisent justement le JSON, et ce n'est pas une mode — c'est le standard industriel. Mais .NET supporte aussi d'autres méthodes — au cas où.

Les acteurs principaux de la serialization .NET

System.Text.Json

System.Xml.Serialization.XmlSerializer

Bref sur chacun

• System.Text.Json : Nouveau standard pour la serialization JSON dans .NET, apparu avec .NET Core 3.0, devenu principal dans .NET 5+. Rapide, léger, sûr, intégré « out of the box » dans .NET 9. Documentation
• XmlSerializer : Option ancienne et éprouvée pour la serialization en XML. Simple à utiliser, mais avec des limites (par exemple, il faut une classe public et des propriétés publiques). Bon pour la compatibilité et les contrats de données stricts. Documentation
• Newtonsoft.Json : Pendant longtemps c'était le standard de-facto pour la serialization JSON avant System.Text.Json. Souvent utilisé pour des scénarios complexes (dynamique, propriétés privées, etc.). Documentation

Que s'est-il passé avec BinaryFormatter ?

Si vous tombez sur des conseils d'utiliser BinaryFormatter — c'est sans doute un tutoriel ancien. N'utilisez pas BinaryFormatter : il a été retiré de .NET 9 pour des raisons de sécurité. Les solutions binaires modernes viennent de bibliothèques tierces — par exemple, Protobuf ou MessagePack.

2. Exemples simples

On va essayer la serialization et la deserialization avec notre classe connue Player de l'univers de jeu.

Préparons la classe pour la serialization

// Player.cs
public class Player
{
    public string Name { get; set; }
    public int Health { get; set; }
    public bool IsAlive { get; set; }
    public List<string> Inventory { get; set; }
    public Position Position { get; set; }
}

public class Position
{
    public int X { get; set; }
    public int Y { get; set; }
}

a) Serialization et deserialization en JSON avec System.Text.Json

using System.Text.Json;

Player aragorn = new Player
{
    Name = "Aragorn",
    Health = 100,
    IsAlive = true,
    Inventory = new List<string> { "sword", "bow", "healing potion" },
    Position = new Position { X = 10, Y = 25 }
};

// Serialization de l'objet Player en chaîne JSON
string json = JsonSerializer.Serialize(aragorn);
// Affichons le JSON à l'écran
Console.WriteLine(json);

// Deserialization de la chaîne JSON en objet Player
Player? aragornClone = JsonSerializer.Deserialize<Player>(json);
// Vérifions que le clone fonctionne :)
Console.WriteLine(aragornClone?.Name); // Doit afficher "Aragorn"

C'est tout simple — pas de « danses avec un tambour » ni d'attributs magiques. Et maintenant — comment ça ressemble en XML.

b) Serialization et deserialization en XML avec XmlSerializer

using System.Xml.Serialization;

// Configurons le serializer pour la classe Player
XmlSerializer serializer = new XmlSerializer(typeof(Player));

// Serialization dans un fichier
using FileStream fs = new FileStream("aragorn.xml", FileMode.Create);
serializer.Serialize(fs, aragorn); // On sauvegarde Aragorn dans un fichier XML

// Deserialization depuis le fichier
using FileStream fs = new FileStream("aragorn.xml", FileMode.Open);
Player aragornFromXml = (Player) serializer.Deserialize(fs)!;
Console.WriteLine(aragornFromXml.Name); // Doit afficher "Aragorn"

Notez bien ! XmlSerializer exige que les classes et leurs propriétés soient publiques et aient un constructeur par défaut sans paramètres (si vous redéfinissez le constructeur — rendez-le public et sans paramètres). Sinon la serialization échouera.

c) Serialization et deserialization en JSON avec Newtonsoft.Json

using Newtonsoft.Json; // N'oubliez pas d'ajouter le package Newtonsoft.Json via NuGet !

// Serialization
string json2 = JsonConvert.SerializeObject(aragorn);

// Deserialization
Player? aragornFromNewtonsoft = JsonConvert.DeserializeObject<Player>(json2);

Console.WriteLine(aragornFromNewtonsoft?.Name); // Encore "Aragorn"

Ça ressemble presque au même code, mais Newtonsoft.Json offre beaucoup d'options supplémentaires — par exemple, on peut serialiser des champs privés, configurer le formatage et gérer des scénarios non triviaux.

4. Nuances utiles

Serializers standards et leurs capacités

System.Text.Json

Newtonsoft.Json

XmlSerializer

Comment choisir quelle classe utiliser ?

Si vous ne savez pas pourquoi vous auriez besoin de XML — prenez presque toujours JSON et System.Text.Json. C'est plus rapide, plus simple et conforme aux pratiques modernes.

XML vaut le coup si :

• Vous vous intégrez avec des systèmes anciens qui exigent précisément du XML.
• Vous avez besoin d'un schéma strict et de validation de la structure des données.
• Les structures sont grosses, stables et la compatibilité formelle est importante (settings, configs, échange avec des systèmes enterprise).

JSON — si :

• Vous créez une appli moderne, interagissez avec le web et des appareils mobiles.
• Vous avez besoin de simplicité, lisibilité et compacité.
• Vous ne voulez pas tirer de dépendances inutiles.

Newtonsoft.Json — si :

• Vous avez besoin de serializer des champs privés, des customisations particulières, une flexibilité totale.
• Ou le projet utilise déjà cette bibliothèque et migrer n'est pas raisonnable maintenant.

5. Erreurs typiques et pièges

Encodage. Les serializers principaux (surtout quand on travaille avec des fichiers) utilisent UTF-8 par défaut. Si vous voyez des « caractères bizarres », vérifiez comment vous lisez/écrivez les fichiers et la configuration explicite de l'encodage. Documentation sur la configuration de l'encodage.

Types non supportés. Certains serializers standards (en particulier XML) ne savent pas serializer, par exemple, des dictionnaires (Dictionary), des champs privés/protected, des événements, des délégués et des interfaces. En général, sont supportées les propriétés publiques simples et les classes.

Versions des classes. Si vous changez la structure des classes (ajout/suppression/renommage de propriétés), les anciennes données sauvegardées peuvent ne pas se lire ou se désérialiser incorrectement. Planifiez le versioning des formats.

Valeurs null. Lors de la deserialization, si un champ manque dans les données, la propriété correspondante recevra la valeur par défaut (pour un type référence — null). N'oubliez pas les vérifications.

Attributs. Pour un contrôle fin on utilise souvent des attributs comme [JsonIgnore], [XmlElement] etc. Ils permettent d'exclure des propriétés, renommer des éléments et gérer le format — on verra les détails dans les prochaines leçons.

2

Mission

C# SELF, niveau 44, leçon 0

Bloqué

Sauvegarde et chargement d'un objet en XML

Sauvegarde et chargement d'un objet en XML

Ouvrir