How to C#: Validating a JSON to a JSON Schema

Validating JSON against a JSON schema is crucial when ensuring the data your application consumes meets the expected structure. Here's how you can quickly set this up in a C# console application.

1. Set Up Your Project

Start by creating a new C# Console Application:

dotnet new console -n JsonValidationDemo
cd JsonValidationDemo

2. Install Required Packages

To validate JSON against a schema, you'll need to install the Newtonsoft.Json and Newtonsoft.Json.Schema packages. Use the following commands:

dotnet add package Newtonsoft.Json
dotnet add package Newtonsoft.Json.Schema

3. Add Your JSON and Schema

For this example, let's assume you have a sample.json and schema.json files.

sample.json:

{
  "name": "John Doe",
  "age": 30
}

schema.json:

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" }
  },
  "required": [ "name", "age" ]
}

4. Write the Validation Code

In Program.cs, add the following code to read the JSON and schema, then validate:

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Schema;
using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        string jsonData = File.ReadAllText("sample.json");
        string schemaData = File.ReadAllText("schema.json");

        JSchema schema = JSchema.Parse(schemaData);
        JObject json = JObject.Parse(jsonData);

        if (json.IsValid(schema, out IList<string> errors))
        {
            Console.WriteLine("JSON is valid.");
        }
        else
        {
            Console.WriteLine("JSON is invalid. Errors:");
            foreach (var error in errors)
            {
                Console.WriteLine($"- {error}");
            }
        }
    }
}

5. Run the Application

Execute the program using:

dotnet run

This will tell you if your JSON matches the schema, providing detailed errors if not.

Extras: Advanced Tips for JSON Schema Validation

1. Strict Validation with additionalProperties

To ensure that your JSON object does not contain any properties not defined in the schema, use the additionalProperties keyword in your schema:

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" }
  },
  "required": [ "name", "age" ],
  "additionalProperties": false
}

With additionalProperties: false, any extra properties in your JSON will cause validation to fail, enforcing a strict schema.

2. Best Practice: Validate Required Fields

Always specify the required fields in the required array to prevent accidental omission. For example:

Updated schema.json:

{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" },
    "email": { "type": "string" }
  },
  "required": [ "name", "age" ]
}

In this example, the email field is optional, but name and age are required. If the JSON does not include name or age, validation will fail.

3. Best Practice: Use Version Control for Schemas

Keep your JSON schemas in version control, just like your code. This allows you to track changes over time and ensures consistency. Here’s a basic example of how you might organize your schemas:

Project Structure:

/JsonValidationDemo
  /Schemas
    - v1.schema.json
    - v2.schema.json
  Program.cs

In this setup, you might start with v1.schema.json and evolve to v2.schema.json as your application grows, ensuring that you can always refer back to or validate against older schemas if needed.

Conclusion

Validating JSON against a schema is a straightforward process with C#. By leveraging Newtonsoft.Json and Newtonsoft.Json.Schema, you can easily ensure your data adheres to the expected format. Implementing strict validation with additionalProperties, carefully managing required fields, and versioning your schemas are key practices to make your application more robust and reliable.