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 |
|---|---|---|
|
Enlace a la versión del estándar de JSON Schema | |
|
Tipo de valor (object, array, string, number y otros) | |
|
Descripción de las propiedades del objeto | |
|
Array de campos obligatorios | |
|
Descripción del tipo de elementos de un array | |
|
Listado de valores permitidos | |
, |
Restricciones para números | |
, |
Restricciones de longitud para strings | |
|
Expresión regular para strings | |
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.
GO TO FULL VERSION