CodeGym /Cursos /C# SELF /Validación de JSON y JSON Schema

Validación de JSON y JSON Schema

C# SELF
Nivel 47, Lección 4
Disponible

1. Introducción

Vale, ya sabes convertir objetos a JSON (y viceversa). ¿Pero qué hacer si a la entrada de tu programa llega algo… raro? Por ejemplo, esperabas este JSON:

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

Y recibiste:

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

Sí, los serializers de C# intentarán deserializar este desorden, pero normalmente eso provoca errores en tiempo de ejecución, pérdida de datos o incluso quebrar el negocio. Antes de pasar los datos más adelante, guardarlos en la base o enviarlos por la red, comprueba que los datos son válidos — si no, tu código se parece a un acróbata sin red de seguridad.

Para eso sirve la validación: es la comprobación automática de que el JSON cumple las reglas — tipos de valores, obligatoriedad de campos, rangos, estructura, etc.

2. ¿Qué métodos hay para validar JSON?

En C# y .NET hay tres enfoques principales:

  • Validación con código propio: parseas manualmente el objeto, escribes comprobaciones y lanzas excepciones cuando hay errores.
  • Atributos de validación en los modelos: por ejemplo, [Required], [Range], [EmailAddress] del namespace System.ComponentModel.DataAnnotations.
  • Validación mediante JSON Schema — ¡nuestro protagonista de hoy!

JSON Schema es un estándar que permite describir formalmente cómo debe ser un documento válido. La schema también es JSON. Defines qué campos se necesitan, de qué tipos son, qué valores son permitidos, etc.

Con las schemas describes:

  • Qué campos deben estar presentes.
  • Qué tipos se esperan (string, array, number, object…).
  • Qué campos son obligatorios y cuáles no.
  • Rangos de valores (por ejemplo, edad desde 0 hasta 150).
  • Patrones, longitudes, listas de valores y más.

Ejemplo de la schema más simple

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

3. Elementos principales de JSON Schema

Veamos con ejemplos qué significan las claves principales en JSON Schema.

Clave Descripción Ejemplo
$schema
Enlace a la versión del estándar de JSON Schema
"https://json-schema.org/draft/2020-12/schema"
type
Tipo de valor (object, array, string, number y otros)
"type": "object"
properties
Descripción de las propiedades del objeto
"properties": { ... }
required
Array de campos obligatorios
"required": ["id"]
items
Descripción del tipo de elementos de un array
"items": { ... }
enum
Listado de valores permitidos
"enum": ["A", "B"]
minimum
,
maximum
Restricciones para números
"minimum": 0
minLength
,
maxLength
Restricciones de longitud para strings
"minLength": 3
pattern
Expresión regular para strings
"pattern": "^[a-zA-Z]+$"

Visualmente: ejemplo de schema para un array de personas

{
  "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. Cómo validar JSON contra una schema en C#

En .NET no hay soporte estándar para JSON Schema (al menos hasta .NET 9). En la práctica se usan librerías externas: NJsonSchema o Newtonsoft.Json.Schema (Json.NET Schema).

Instalación del paquete Newtonsoft.Json.Schema (Json.NET Schema)

Ejecuta en la terminal (en la carpeta del proyecto):

dotnet add package Newtonsoft.Json.Schema

Importante: Newtonsoft.Json.Schema es una librería comercial (para uso no comercial está disponible gratis). Para proyectos personales viene perfecta.

Ejemplo de comprobación de JSON contra una 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']
}";

// Imaginemos que tenemos este JSON
string json = @"{
  'id': 123,
  'name': 'Alice',
  'email': 'alice@example.com'
}";

// Primero parseamos la schema
JSchema schema = JSchema.Parse(schemaJson);

// Parseamos el propio JSON a JToken
JToken jsonObj = JToken.Parse(json);

// Comprobamos si el JSON cumple la schema
bool valid = jsonObj.IsValid(schema, out IList<string> errors);

if (valid)
{
    Console.WriteLine("¡JSON válido!");
}
else
{
    Console.WriteLine("¡JSON NO válido!");
    foreach (var error in errors)
        Console.WriteLine(error);
}

¿Cómo usar la verificación de JSON en la aplicación?

Normalmente: primero validación (IsValid), luego deserialización (JsonConvert.DeserializeObject<T>) y solo después — la lógica de negocio. Así descartas datos basura desde el principio.

if (jsonObj.IsValid(schema))
{
    // Todo bien, se puede deserializar
    var person = JsonConvert.DeserializeObject<Person>(json);
}
else
{
    // ¡Detener el procesamiento! Los datos no son correctos.
}

5. Uso de JSON Schema en la vida real

¿Cuándo hace falta validar?

  • Al recibir datos por API (especialmente de sistemas externos y clientes diversos).
  • Al migrar datos entre microservicios y bases.
  • Al generar formularios UI y autocompletar, si el formulario se construye a partir de la schema.
  • En entrevistas: la pregunta "¿y si llega un JSON incorrecto?" aparece a menudo.

Un punto interesante para curiosos

  • Comprobación de formatos: "format": "email", "date-time".
  • Reglas compuestas: anyOf, oneOf, allOf.
  • Validación de objetos anidados y arrays.
  • Extender schemas para tus necesidades.

6. Ejemplo práctico grande

Datos de entrada (lista de usuarios):

[
  { "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"]
  }
}

Comprobación en .NET:

string jsonArray = @"[ ... ]"; // ver arriba
string schemaJson = @"{ ... }"; // ver arriba

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);
    // Ejemplos de mensajes:
    // "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. Errores típicos al trabajar con JSON schemas

Error nº1: la schema no coincide con los datos actuales. Tras cambiar el modelo se olvida actualizar la schema. La validación o bien deja pasar errores o bien bloquea datos correctos.

Error nº2: desajuste de tipos entre la schema y el modelo. Un campo en el modelo cambió de tipo (por ejemplo, id pasó a ser string), pero en la schema sigue siendo integer — el validador empezará a quejarse.

Error nº3: ausencia de campos obligatorios para la lógica del negocio. Aunque un campo no esté marcado como obligatorio, la lógica puede depender de él — su ausencia causará fallos.

Error nº4: formato de datos incorrecto. Un campo de tipo string con email o fecha luce "como string", pero puede no ser válido. Usa format y/o comprobaciones adicionales.

Error nº5: la implementación de la librería va por detrás del estándar. El estándar evoluciona y las librerías no siempre siguen el ritmo. Algunas comprobaciones pueden faltar o comportarse de forma distinta.

1
Cuestionario/control
Trabajo con datos JSON, nivel 47, lección 4
No disponible
Trabajo con datos JSON
Fundamentos de la sintaxis y estructura de JSON
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION