Validierung von JSON und JSON Schema

1. Einführung

Also, ihr könnt bereits Objekte in JSON umwandeln (und zurück). Aber was, wenn in eurer Anwendung etwas... seltsames reinkommt? Zum Beispiel habt ihr so ein JSON erwartet:

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

Und bekommen:

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

Ja, die C#-Serializer versuchen ehrlicherweise, das zu deserialisieren, aber oft führt das zu Laufzeitfehlern, Datenverlust oder sogar kaputtem Business-Logic. Bevor ihr Daten weiterreicht, in die DB schreibt oder über das Netzwerk schickt, prüft, dass die Daten valide sind — sonst ist euer Code wie ein Akrobat ohne Netz.

Deshalb braucht man Validierung: automatische Kontrolle, dass das JSON den Regeln entspricht — Typen der Werte, verpflichtende Felder, Bereiche, Struktur usw.

2. Welche Methoden zur JSON-Validierung gibt es?

In C# und .NET gibt es drei Hauptansätze:

• Validierung per eigenem Code: wir parsen das Objekt manuell, schreiben Checks und werfen Exceptions bei Fehlern.
• Validierungs-Attribute auf Modellen: z.B. [Required], [Range], [EmailAddress] aus dem Namespace System.ComponentModel.DataAnnotations.
• Validierung mit JSON Schema — unser heutiger Held!

JSON Schema ist ein Standard, mit dem man formell beschreiben kann, wie ein gültiges Dokument aussehen muss. Eine Schema-Datei ist ebenfalls JSON. Du definierst, welche Felder nötig sind, welche Typen sie haben müssen, welche Werte erlaubt sind usw.

Mit Schemata beschreibst du:

• Welche Felder vorhanden sein müssen.
• Welche Typen erwartet werden (string, array, number, object …).
• Welche Felder verpflichtend sind und welche optional.
• Wertebereiche (z. B. Alter von 0 bis 150).
• Masken, Längen, Listen erlaubter Werte usw.

Beispiel eines einfachen Schemas

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

3. Grundlegende Elemente von JSON Schema

Schauen wir uns anhand von Beispielen an, was die wichtigsten Schlüssel in JSON Schema bedeuten.

$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]+$"

Anschaulich: Schema-Beispiel für ein Array von Personen

{
  "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. Wie validiert man JSON gegen ein Schema in C#

In .NET gibt es keine eingebaute Standardunterstützung für JSON Schema (Stand: .NET 9). In der Praxis nutzt man externe Bibliotheken: NJsonSchema oder Newtonsoft.Json.Schema (Json.NET Schema).

Installation des Pakets Newtonsoft.Json.Schema (Json.NET Schema)

Führe im Terminal im Projektordner aus:

dotnet add package Newtonsoft.Json.Schema

Wichtig: Newtonsoft.Json.Schema ist eine kommerzielle Bibliothek (für nicht-kommerzielle Nutzung kostenlos). Für Hobby-Projekte ideal.

Beispiel: JSON gegen Schema prüfen

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']
}";

// Nehmen wir an, wir haben dieses JSON
string json = @"{
  'id': 123,
  'name': 'Alice',
  'email': 'alice@example.com'
}";

// Zuerst das Schema parsen
JSchema schema = JSchema.Parse(schemaJson);

// Dann das JSON in ein JToken parsen
JToken jsonObj = JToken.Parse(json);

// Prüfen, ob das JSON dem Schema entspricht
bool valid = jsonObj.IsValid(schema, out IList
  
    errors); if (valid) { Console.WriteLine("JSON ist valid!"); } else { Console.WriteLine("JSON ist NICHT valid!"); foreach (var error in errors) Console.WriteLine(error); } 
  

Wie verwendet man die Validierung in einer Anwendung?

Typischer Ablauf: zuerst Validierung (IsValid), dann Deserialisierung (JsonConvert.DeserializeObject<T>) und erst danach Business-Logic. So wird „Müll“ früh aussortiert.

if (jsonObj.IsValid(schema))
{
    // Alles gut, kann deserialisiert werden
    var person = JsonConvert.DeserializeObject
  
   (json); } else { // Verarbeitung abbrechen! Daten sind inkorrekt. } 
  

5. Einsatz von JSON Schema im echten Leben

Wann braucht man Validierung?

• Beim Empfangen von Daten via API (vor allem von externen Systemen und verschiedenen Clients).
• Bei Datenmigration zwischen Microservices und Datenbanken.
• Beim Generieren von UI-Formularen und Auto-Fill, wenn das Formular auf dem Schema basiert.
• Bei Vorstellungsgesprächen: die Frage «was, wenn falsches JSON reinkommt?» kommt oft vor.

Interessanter Punkt für Neugierige

• Prüfung von Formaten: "format": "email", "date-time".
• Zusammengesetzte Regeln: anyOf, oneOf, allOf.
• Validierung verschachtelter Objekte und Arrays.
• Erweiterung von Schemata für eigene Bedürfnisse.

6. Großes praktisches Beispiel

Eingabedaten (Liste von Benutzern):

[
  { "id": 1, "name": "Alice", "email": "alice@example.com" },
  { "id": 2, "name": "Bob" },
  { "id": "chto eto?", "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"]
  }
}

Prüfung in .NET:

string jsonArray = @"[ ... ]"; // siehe oben
string schemaJson = @"{ ... }"; // siehe oben

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

bool isValid = arrayToken.IsValid(schema, out IList
  
    errs); if (!isValid) { foreach (var error in errs) Console.WriteLine(error); // Beispiel-Meldungen: // "String 'chto eto?' is not a valid integer." // "Integer 123 is not a valid string." // "String 'not-an-email' is not a valid email address." } 
  

7. Typische Fehler beim Arbeiten mit JSON-Schemata

Fehler Nr.1: Schema passt nicht zu aktuellen Daten. Nach Änderung des Models vergisst man, das Schema zu aktualisieren. Die Validierung lässt Fehler durch oder blockiert gültige Daten.

Fehler Nr.2: Typen in Schema und Model stimmen nicht überein. Ein Feld im Model hat den Typ gewechselt (z. B. wurde id zu string), im Schema steht aber noch integer — der Validator meckert.

Fehler Nr.3: Fehlende für das Business notwendige Felder. Auch wenn ein Feld nicht als required markiert ist, kann die Logik davon abhängen — dessen Fehlen führt zu Fehlern.

Fehler Nr.4: Falsches Datenformat. Ein Feld vom Typ string mit Email oder Datum sieht zwar wie ein String aus, kann aber invalid sein. Nutzt format und/oder zusätzliche Prüfungen.

Fehler Nr.5: Bibliotheksimplementierung hinkt dem Standard hinterher. Der Standard entwickelt sich, Bibliotheken nicht immer. Manche Prüfungen fehlen oder verhalten sich anders.

1

Umfrage/Quiz

Arbeiten mit JSON-Daten, Level 47, Lektion 4

Nicht verfügbar

Arbeiten mit JSON-Daten

Grundlagen von Syntax und Struktur von JSON

Öffnen