1. Introduction
Nous avons déjà travaillé avec les collections. Impossible d’en faire l’économie en programmation, comme dans la vie. Imaginez que vous faites une to-do list pour la journée : acheter des courses, appeler le médecin, récupérer une commande. Vous n’allez pas créer un carnet pour chaque tâche. C’est beaucoup plus simple et logique de tout mettre dans une seule liste.
C’est la même chose en programmation : quand il y a beaucoup d’objets — utilisateurs, commandes, messages — on ne crée pas une variable séparée pour chacun. On utilise des collections : listes, dictionnaires (dictionaries), ensembles (sets). Ça permet de stocker, parcourir et traiter des groupes de données facilement.
Scénarios de la vraie vie :
- Stockage et échange de données entre applications : votre collection de livres peut migrer d’un programme à un autre.
- Mise en cache de jeux de données sur le disque.
- Transmission de données sur le réseau (frontend ↔ backend).
- Import/export d’information (par exemple, vous décidez d’exporter vos livres en JSON !).
En entretien : «Comment sérialiseriez-vous et sauvegarderiez-vous une liste de commandes ?» — c’est top si vous mentionnez non seulement un objet unique, mais aussi la sérialisation des collections !
2. Comment les collections fonctionnent lors de la sérialisation
JSON et collections : une courte histoire d’amour
Quand vous sérialisez un objet ordinaire, il devient un objet JSON du type { "field": value }. Mais si vous sérialisez une liste ou un tableau, vous obtenez un tableau JSON [ ... ].
Visuellement :
| C# | JSON |
|---|---|
|
|
|
|
|
|
La magie principale : On appelle JsonSerializer.Serialize() sur la collection — et il la transforme automatiquement en tableau ! Dans l’autre sens, Deserialize<List<T>>() — et le tour est joué.
Correspondance entre collections C# et tableaux JSON
| Type de collection en C# | Exemple | JSON |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
3. Exemple : sérialisation et désérialisation d’un tableau de livres
Commençons par un exemple minimal. Prenons notre classe Book qu’on a déjà utilisée dans les leçons précédentes :
public class Book
{
public string Title { get; set; }
public string Author { get; set; }
}
Maintenant, créons un tableau de livres, sérialisons-le, sauvegardons-le dans un fichier et rechargeons-le.
using System;
using System.IO;
using System.Text.Json;
namespace LibraryApp
{
public class Book
{
public string Title { get; set; }
public string Author { get; set; }
}
class Program
{
static void Main()
{
// Créons un tableau de livres
Book[] books = new Book[]
{
new Book { Title = "Three Comrades", Author = "Erich Maria Remarque" },
new Book { Title = "The Master and Margarita", Author = "Mikhail Bulgakov" },
new Book { Title = "1984", Author = "George Orwell" }
};
// Sérialisation du tableau de livres en chaîne
var options = new JsonSerializerOptions { WriteIndented = true };
string json = JsonSerializer.Serialize(books, options);
Console.WriteLine("JSON du tableau de livres:\n" + json);
// Écriture dans un fichier (synchrone)
File.WriteAllText("books.json", json);
// Lecture depuis le fichier (synchrone)
string jsonFromFile = File.ReadAllText("books.json");
// Désérialisation de nouveau en tableau
Book[]? booksFromFile = JsonSerializer.Deserialize<Book[]>(jsonFromFile);
// Affichage du résultat dans la console
Console.WriteLine("\nLivres désérialisés:");
if (booksFromFile != null)
{
foreach (var book in booksFromFile)
{
Console.WriteLine($"- {book.Title} (auteur : {book.Author})");
}
}
}
}
}
Que se passe-t-il ici ?
- On crée un tableau Book[] et on le remplit avec trois livres.
- Avec JsonSerializer.Serialize on transforme le tableau en une jolie chaîne JSON (l’option WriteIndented rend le format lisible).
- On l’écrit dans un fichier, on le lit et on le désérialise — et voilà, on a à nouveau un tableau de livres !
- On vérifie que toutes les données ont été correctement restaurées.
Vérifiez que le fichier "books.json" apparaît dans le dossier du programme. Ouvrez-le, vous verrez un JSON ressemblant à ceci :
[
{
"Title": "Three Comrades",
"Author": "Erich Maria Remarque"
},
{
"Title": "The Master and Margarita",
"Author": "Mikhail Bulgakov"
},
{
"Title": "1984",
"Author": "George Orwell"
}
]
4. Exemple : sérialisation d’une collection List<T>
Travailler avec List<Book> ne change rien. Le sérialiseur voit une collection et la transforme en tableau JSON.
List<Book> myBooks = new List<Book>
{
new Book { Title = "Crime and Punishment", Author = "Fyodor Dostoevsky" },
new Book { Title = "War and Peace", Author = "Lev Tolstoy" }
};
string jsonList = JsonSerializer.Serialize(myBooks, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(jsonList);
// Et on désérialise comme ça :
List<Book>? loadedBooks = JsonSerializer.Deserialize<List<Book>>(jsonList);
// On vérifie que tout est revenu !
foreach (var book in loadedBooks!)
{
Console.WriteLine($"{book.Title} ({book.Author})");
}
Peut-on sérialiser simplement une liste d’entiers ?
Bien sûr ! La sérialisation fonctionne non seulement pour vos classes, mais aussi pour les types simples :
List<int> numbers = new List<int> { 10, 20, 30, 40 };
string jsonNums = JsonSerializer.Serialize(numbers); // résultat : [10,20,30,40]
List<int>? loadedNums = JsonSerializer.Deserialize<List<int>>(jsonNums);
// loadedNums : List<int> avec les mêmes valeurs
5. Schéma et analogies : comment le sérialiseur voit les collections ?
Pour mieux comprendre comment fonctionne la sérialisation des collections, regardons un schéma simple :
graph TD;
A[List[Book] en C#] -->|Serialize| B[Tableau JSON en chaîne]
B -->|Write| C[Fichier books.json]
C -->|Read| D[Chaîne JSON depuis le fichier]
D -->|Deserialize| E[List[Book] en C#]
En bref :
- Une collection ou un tableau est sérialisé comme un tableau en JSON ([ ... ]).
- L’ordre des éléments est préservé (sauf si vous modifiez ça avec des options spéciales).
- Chaque élément de la collection est sérialisé comme son propre objet.
6. Particularités de la sérialisation des collections : à quoi faire attention
1. null et collections vides
Si la collection est null, le sérialiseur écrira simplement null dans le JSON par défaut. Faites attention si dans votre logique métier une collection vide et null ne signifient pas la même chose !
Si la collection est vide (new List<Book>()), le JSON sera [] — un tableau vide. C’est pratique pour montrer explicitement l’absence d’éléments.
2. La désérialisation — l’ordre compte
L’ordre des éléments dans le tableau est toujours conservé. Donc si vous avez sérialisé trois livres dans un certain ordre, le même ordre sera restauré.
3. Collection avec des objets de types différents ?
System.Text.Json ne supporte pas le polymorphisme «out of the box». Autrement dit, si vous avez une List<Animal> avec des chiens et des chats (chacun étant une classe dérivée), par défaut vous ne pouvez pas restaurer «quel type exactement» c’était. On verra la sérialisation polymorphe plus tard ; pour les listes simples, c’est direct.
7. Erreurs typiques et malentendus courants
Erreur n°1 : On sérialise une collection mais on oublie que certains objets ont des champs privés
JsonSerializer sérialise seulement les propriétés publiques (et uniquement avec getters/setters). Si votre classe est comme ceci :
public class User
{
public string Login { get; set; }
private string Password { get; set; } // Ne sera pas sérialisé !
}
Le mot de passe n’apparaîtra pas dans le JSON, et c’est souvent souhaitable pour la sécurité. Mais si vous vouliez le sauvegarder, pensez à rendre la propriété publique.
Erreur n°2 : Sérialisation de collections avec des éléments null
Si la collection contient null, par exemple : new List<Book> { null, book2 }, alors après sérialisation le premier élément sera null. À la désérialisation — pareil ! Exemple de JSON :
[null, { "Title": "War and Peace", "Author": "Lev Tolstoy" }]En pratique c’est rare, mais si vous sérialisez une collection qui peut contenir des «trous», gérez-le dans la logique.
Erreur n°3 : Mauvais type lors de la désérialisation
Erreur fréquente : on sérialise une liste, puis on désérialise dans un tableau (ou l’inverse). Ça marche si les types sont compatibles (Book[] ↔ List<Book>), mais il peut y avoir des subtilités si, par exemple, vous essayez de désérialiser un tableau de chaînes en un objet non-collection.
GO TO FULL VERSION