Notions de syntaxe et structure JSON

1. Se rappeler JSON

JSON signifie JavaScript Object Notation. Malgré le mot un peu intimidant JavaScript dans le nom, ce format est totalement agnostique au langage et compatible avec tous (ou presque tous) les langages de programmation, y compris C#. Il a été inventé pour décrire de façon claire et pratique des données — objets, tableaux, listes et dictionnaires — sous forme de texte lisible.

Dans le monde moderne, où presque chaque application communique avec d'autres applications, JSON est devenu de facto le standard pour la sérialisation et l'échange de données structurées. Il est utilisé partout : des REST API au stockage des préférences utilisateur, et même pour l'interaction interne entre microservices. Et il y a une bonne raison — il est lisible par un humain (si ce dernier n'a pas peur des accolades), simple à parser et supporté par tous les langages et bibliothèques modernes.

Pourquoi pas XML ?

JSON est plus simple, plus court et plus lisible que XML. En plus, il n'a pas le bruit des balises superflues et s'aligne plus naturellement sur les structures de données de la plupart des langages. Et puis on évite de se battre avec les balises fermantes, les guillemets et toute la paperasse XML. Bref — JSON, c'est plus rapide, plus simple, plus pratique.

2. Éléments principaux de la syntaxe JSON

Imaginez JSON comme un arbre simple (ou une matriochka), composé d'objets, de tableaux et de données élémentaires. Voici les « briques » à notre disposition :

Objets (Objects)

Un objet JSON est un ensemble de paires « clé: valeur », entouré par des accolades { }.

Exemple :

{
  "name": "Alice",
  "age": 23
}

En C#, cette structure peut être représentée par une classe ou un dictionnaire.

Tableaux (Arrays)

Un tableau JSON est une liste ordonnée d'éléments (valeurs de n'importe quel type), entourée par des crochets [ ].

Exemple :

[1, 2, 3, 42]

Ou :

[
  {"name": "Ivan"},
  {"name": "Olga"}
]

En C# — c'est List<T>, T[] et des collections similaires.

Paires « clé-valeur »

Les clés sont toujours des chaînes (entre guillemets doubles !), et les valeurs peuvent être de n'importe quel type permis en JSON.

Exemple :

{
  "id": 123,
  "login": "student",
  "isActive": true
}

Types de données en JSON

10, -5, 3.14

"hello"

true, false

null

{"a":1}

[1,2,3]

Exemple — tout ensemble :

{
  "id": 1,
  "name": "Bob",
  "scores": [10, 20, 30],
  "profile": {
    "email": "bob@mail.com",
    "phone": null
  },
  "isAdmin": false
}

Vous voyez comme on peut décrire de façon compacte et logique un objet utilisateur.

3. Règles de mise en forme JSON

Les chaînes sont toujours en guillemets doubles

Même si l'envie de mettre des guillemets simples est forte, JSON ne le permettra pas. Correct :

{ "name": "Vera" }

Incorrect — erreur :

{ 'name': 'Vera' }

Les clés — seulement des chaînes

Contrairement à C#, où la clé d'un dictionnaire peut être un int ou un enum, en JSON la clé est toujours une chaîne :

{ "2025": "Year of C#", "favorite": true }

Pas de virgules terminales

Contrairement aux collections C#, une virgule supplémentaire avant la parenthèse fermante est une erreur syntaxique en JSON !

// ERREUR ! (la virgule finale n'est pas autorisée)
{
  "id": 10,
  "name": "Oleg",
}

Correct :

{
  "id": 10,
  "name": "Oleg"
}

Espaces et sauts de ligne

On peut les ajouter pour la lisibilité, les parsers les ignorent. En général on utilise du JSON pretty-printed (formaté) pour lecture humaine, et du JSON minified (en une seule ligne, sans espaces) pour le transport réseau.

4. Comment les objets C# se transforment en JSON

Si vous sérialisez un objet avec System.Text.Json.JsonSerializer.Serialize(), les champs et propriétés de l'objet deviennent des paires « clé-valeur ».

Exemple de classe C# et sérialisation

public class Book
{
    public string Title { get; set; }
    public int Pages { get; set; }
}
var book = new Book { Title = "CLR via C#", Pages = 900 };
string json = JsonSerializer.Serialize(book);
Console.WriteLine(json); // {"Title":"CLR via C#","Pages":900}

Collections

• List<int> devient [1,2,3]
• string[] devient ["hi", "wow"]
• List<Person> — en tableau d'objets

Dictionnaires

Un dictionnaire du type Dictionary<string, int> devient un objet :

var dict = new Dictionary<string, int>
{
    ["apples"] = 5, ["bananas"] = 10
};
string json = JsonSerializer.Serialize(dict);
// {"apples":5,"bananas":10}

5. Schéma visuel : comment JSON est construit

Imbrication — comme une matriochka

Objet
│
├── Paire: "name": "Alex"
├── Paire: "hobbies": tableau
│               │
│               ├── "skiing"
│               └── "programming"
└── Paire: "profile": objet
                 │
                 ├── "age": 42
                 └── "city": "Basel"

Résultat :

{
  "name": "Alex",
  "hobbies": ["skiing", "programming"],
  "profile": {
    "age": 42,
    "city": "Basel"
  }
}

6. Erreurs typiques et particularités de la syntaxe

En programmation il n'y a pas de monde parfait — même JSON a ses pièges ! Si vous essayez d'envoyer du JSON avec des guillemets incorrects, des virgules superflues ou des clés non entourées de guillemets — le parser signalera une erreur.

Un autre « piège » — les nombres avec des zéros en tête. En JSON c'est interdit (par exemple, 0123 — erreur).

Bon à savoir : Certains parsers (par exemple le JSON.parse de JavaScript) sont plus tolérants et peuvent « pardonner » de petites violations. Mais la plupart des parsers « stricts » (comme en C# et .NET) vont râler au moindre écart de syntaxe.

7. Exemples de conversion de données C# en JSON

Essayons de sérialiser une structure plus complexe en pratique. Notre application pédagogique évolue : supposons qu'on ait maintenant une liste d'étudiants, et qu'on veuille la sauvegarder dans un fichier JSON.

Définissons la classe :

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Remplissons la liste :

var students = new List<Student>
{
    new Student { Name = "Anna", Age = 20 },
    new Student { Name = "Nikita", Age = 22 }
};

Sérialisation :

using System.Text.Json;

// Sérialisons la liste d'étudiants en chaîne JSON
string json = JsonSerializer.Serialize(students, new JsonSerializerOptions { WriteIndented = true });
Console.WriteLine(json);

/*
[
  {
    "Name": "Anna",
    "Age": 20
  },
  {
    "Name": "Nikita",
    "Age": 22
  }
]
*/

Vous voyez comme c'est pratique ? Chaque étudiant est un objet distinct dans le tableau JSON.

8. Mini-générateur : comment écrire un JSON « à la main »

Parfois il faut écrire du JSON soi-même, par exemple pour créer des données de test à la main. Voici une checklist :

1. Accolades externes — pour un objet, crochets externes — pour un tableau.
2. La clé est toujours une chaîne entre guillemets doubles.
3. Les valeurs — chaînes (entre guillemets doubles), nombres, true, false, null, objet ({}), tableau ([]).
4. Virgules seulement entre éléments, pas après le dernier !
5. Indents et espaces pour la lisibilité (mais pas obligatoires).

2

Mission

C# SELF, niveau 47, leçon 0

Bloqué

Sérialisation d'une liste d'objets en JSON

Sérialisation d'une liste d'objets en JSON

Ouvrir