Validation de JSON et de JSON Schema

1. Introduction

Donc, vous savez déjà convertir des objets en JSON (et inversement). Mais que faire si quelque chose de… bizarre arrive en entrée de votre programme ? Par exemple, vous attendiez ce JSON :

{
  "id": 123,
  "name": "Alice",
  "email": "alice@example.com"
}

Et vous avez reçu :

{
  "name": 42,
  "id": "not a number"
}

Oui, les serializers C# vont essayer de désérialiser ce bazar, mais souvent ça conduit à des erreurs à l'exécution, à la perte de données ou même à des plantages qui affectent le business. Avant d'envoyer les données plus loin, de les sauvegarder ou de les transmettre sur le réseau, vérifiez que les données sont valides — sinon votre code ressemble à un acrobate sans filet.

C'est là qu'intervient la validation : c'est une vérification automatique pour s'assurer que le JSON respecte des règles — types des valeurs, champs obligatoires, plages, structure, etc.

2. Quels sont les moyens de valider du JSON ?

En C# et .NET il y a trois approches principales :

• Validation par code personnalisé : on parse manuellement l'objet, on écrit des contrôles et on lance des exceptions en cas d'erreur.
• Attributs de validation sur les modèles : par exemple, [Required], [Range], [EmailAddress] depuis l'espace de noms System.ComponentModel.DataAnnotations.
• Validation via JSON Schema — notre héros du jour !

JSON Schema est une norme qui permet de décrire formellement à quoi doit ressembler un document valide. Le schema est lui aussi du JSON. Vous spécifiez quels champs sont nécessaires, leurs types, quelles valeurs sont acceptables, etc.

Avec les schémas vous décrivez :

• Quels champs doivent être présents.
• Quels types sont attendus (string, array, number, object…).
• Quels champs sont obligatoires et lesquels sont optionnels.
• Plages de valeurs (par exemple, âge de 0 à 150).
• Patterns, longueurs, listes de valeurs, etc.

Exemple du schema le plus simple

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "id":    { "type": "integer" },
    "name":  { "type": "string" }
  },
  "required": ["id", "name"]
}

3. Éléments principaux de JSON Schema

Voyons avec des exemples ce que signifient les clefs principales dans un JSON Schema.

$schema

"https://json-schema.org/draft/2020-12/schema"

type

"type": "object"

properties

"properties": { ... }

required

"required": ["id"]

items

"items": { ... }

enum

"enum": ["A", "B"]

minimum

maximum

"minimum": 0

minLength

maxLength

"minLength": 3

pattern

"pattern": "^[a-zA-Z]+$"

Visuel : exemple de schema pour un tableau de personnes

{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "id":    { "type": "integer" },
      "name":  { "type": "string", "minLength": 2, "maxLength": 50 },
      "email": { "type": "string", "format": "email" }
    },
    "required": ["id", "name"]
  }
}

4. Comment valider du JSON contre un schema en C#

Dans .NET il n'y a pas de support natif pour JSON Schema (à la date de .NET 9). En pratique on utilise des bibliothèques externes : NJsonSchema ou Newtonsoft.Json.Schema (Json.NET Schema).

Installation du package Newtonsoft.Json.Schema (Json.NET Schema)

Exécutez dans le terminal (dans le dossier du projet) :

dotnet add package Newtonsoft.Json.Schema

Important : Newtonsoft.Json.Schema est une bibliothèque commerciale (gratuitement disponible pour un usage non commercial). Pour les projets perso c'est parfait.

Exemple de vérification du JSON par rapport au schema

using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Schema;

string schemaJson = @"{
  'type': 'object',
  'properties': {
    'id':    { 'type': 'integer' },
    'name':  { 'type': 'string' },
    'email': { 'type': 'string', 'format': 'email' }
  },
  'required': ['id', 'name']
}";

// Imaginons qu'on ait ce JSON
string json = @"{
  'id': 123,
  'name': 'Alice',
  'email': 'alice@example.com'
}";

// D'abord on parse le schema
JSchema schema = JSchema.Parse(schemaJson);

// On parse le JSON en JToken
JToken jsonObj = JToken.Parse(json);

// On vérifie si le JSON respecte le schema
bool valid = jsonObj.IsValid(schema, out IList<string> errors);

if (valid)
{
    Console.WriteLine("JSON est valide !");
}
else
{
    Console.WriteLine("JSON N'EST PAS valide !");
    foreach (var error in errors)
        Console.WriteLine(error);
}

Comment utiliser la vérification JSON dans une application ?

Généralement : d'abord la validation (IsValid), puis la désérialisation (JsonConvert.DeserializeObject<T>) et seulement après — la logique métier. Ça permet d'éliminer les données pourries dès le départ.

if (jsonObj.IsValid(schema))
{
    // Tout va bien, on peut désérialiser
    var person = JsonConvert.DeserializeObject<Person>(json);
}
else
{
    // Arrêter le traitement ! Les données sont incorrectes.
}

5. Usage de JSON Schema dans la vraie vie

Quand faut-il valider ?

• Lors de la réception de données via une API (surtout depuis des systèmes externes et différents clients).
• Lors de migrations de données entre microservices et bases.
• Lors de la génération de formulaires UI et d'auto-complétion, si le formulaire est construit à partir du schema.
• Aux entretiens : la question « que faire si un JSON incorrect arrive ? » revient souvent.

Point intéressant pour les curieux

• Vérification des formats : "format" : "email", "date-time".
• Règles composées : anyOf, oneOf, allOf.
• Validation d'objets et de tableaux imbriqués.
• Extensions des schémas pour des besoins spécifiques.

6. Exemple pratique complet

Données en entrée (liste d'utilisateurs) :

[
  { "id": 1, "name": "Alice", "email": "alice@example.com" },
  { "id": 2, "name": "Bob" },
  { "id": "what is this?", "name": 123, "email": "not-an-email" }
]

Schema :

{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "id":    { "type": "integer" },
      "name":  { "type": "string", "minLength": 2, "maxLength": 50 },
      "email": { "type": "string", "format": "email" }
    },
    "required": ["id", "name"]
  }
}

Vérification en .NET :

string jsonArray = @"[ ... ]"; // voir ci-dessus
string schemaJson = @"{ ... }"; // voir ci-dessus

JSchema schema = JSchema.Parse(schemaJson);
JToken arrayToken = JToken.Parse(jsonArray);

bool isValid = arrayToken.IsValid(schema, out IList<string> errs);
if (!isValid)
{
    foreach (var error in errs)
        Console.WriteLine(error);
    // Exemples de messages :
    // "String 'what is this?' is not a valid integer."
    // "Integer 123 is not a valid string."
    // "String 'not-an-email' is not a valid email address."
}

7. Erreurs typiques en travaillant avec des JSON Schema

Erreur n°1 : le schema ne correspond pas aux données actuelles. Après une modification du modèle on oublie de mettre à jour le schema. La validation peut alors soit laisser passer des erreurs, soit bloquer des données correctes.

Erreur n°2 : mismatch de types entre le schema et le modèle. Un champ du modèle a changé de type (par exemple, id est devenu une chaîne), mais dans le schema il reste integer — le validateur commencera à râler.

Erreur n°3 : absence de champs business critiques. Même si un champ n'est pas marqué obligatoire, la logique métier peut en dépendre — son absence provoquera des fautes.

Erreur n°4 : format de données incorrect. Un champ de type string qui contient un email ou une date ressemble à une chaîne, mais peut être invalide. Utilisez format et/ou des contrôles supplémentaires.

Erreur n°5 : la bibliothèque n'implémente pas le dernier standard. La norme évolue, et les bibliothèques ne suivent pas toujours. Certaines vérifications peuvent manquer ou se comporter différemment.

1

Étude/Quiz

Travailler avec des données JSON, niveau 47, leçon 4

Indisponible

Travailler avec des données JSON

Bases de la syntaxe et de la structure JSON

Ouvrir