1. Para qué sirve la validación de XML
XML es un formato muy flexible, a veces incluso demasiado. A diferencia de datos fuertemente tipados, XML "tolera" errores, y si olvidas cerrar una etiqueta o alguien pone el nombre de atributo equivocado, el programa puede lanzar un error al parsear el fichero… o directamente no detectar el problema, que es peor.
La validación contra XSD (XML Schema Definition) es la forma de asegurarte de que tu archivo XML cumple con un contrato previamente definido: qué etiquetas se usan, en qué orden, qué tipos tienen, si son obligatorias y cuántas pueden aparecer. Es como el control de pasaporte para tus datos: el esquema dice "no pasas sin el campo requerido o si el campo no tiene la longitud correcta".
La validación es importante en sistemas corporativos, para intercambio de datos entre sistemas, APIs — en cualquier sitio donde no convenga aceptar "silenciosamente" estructuras mal formadas.
XSD (XML Schema Definition) es un XML independiente que formaliza la estructura de otro XML. En el XSD describes: qué etiquetas son válidas, cuáles son obligatorias, los tipos de atributos o elementos hijos, patrones para cadenas, restricciones para números, incluso valores posibles (mediante restricciones y enumeraciones).
| XML | XSD (descripción de la estructura) |
|---|---|
|
|
|
|
XSD es similar en concepto a JSON Schema en el mundo JSON.
2. Ejemplo de XSD y XML asociado
Ejemplo XML
<person age="23">
<name>Ivan</name>
<email>ivan@example.com</email>
</person>
Ejemplo XSD
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="email" type="xs:string" minOccurs="0"/>
</xs:sequence>
<xs:attribute name="age" type="xs:positiveInteger" use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Qué describe este esquema:
- Elemento raíz — <person>.
- Dentro de <person> deben aparecer los elementos <name> (obligatorio) y <email> (opcional).
- El elemento <person> debe tener el atributo age con un entero positivo.
3. Validación de XML con XSD en .NET
En .NET la forma clásica es usar los namespaces System.Xml y System.Xml.Schema.
Cómo funciona:
- Cargar el archivo XML
- Cargar el esquema XSD
- Vincular el esquema a la validación del XML
- Ejecutar la validación y manejar los posibles errores
Aquí tienes un ejemplo básico:
using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
// 1. Manejador de errores de validación
void ValidationCallBack(object? sender, ValidationEventArgs e)
{
Console.WriteLine($"Error de validación: {e.Message}");
}
string xmlPath = "person.xml";
string xsdPath = "person.xsd";
// 2. Cargamos el esquema
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("", xsdPath);
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas = schemas;
settings.ValidationType = ValidationType.Schema;
settings.ValidationEventHandler += ValidationCallBack;
// 3. Abrimos el XML con los ajustes
using XmlReader reader = XmlReader.Create(xmlPath, settings);
while (reader.Read())
{
// Solo recorremos el documento — la validación ocurre "sobre la marcha"
}
Console.WriteLine("¡Validación completada!");
Aclaraciones:
- Todos los errores de validación serán capturados en el callback ValidationCallBack.
- Si no hay errores — el documento cumple con el esquema (ValidationType.Schema).
- Si hay discrepancias (falta age, email no válido, se añadió un campo extra, etc.) — aparecerán en la consola.
Diferentes tipos de errores y retroalimentación
La validación por XSD puede "quejarse" por varios motivos. Aquí los escenarios más comunes y ejemplos de errores:
- Falta un elemento obligatorio (minOccurs="1" por defecto)
- Etiqueta extra no descrita en el XSD
- Atributo de tipo incorrecto (age="abc" en vez de un número)
- Cadenas que no cumplen el patrón (definido con <xs:pattern>)
Error típico:
Error de validación: El elemento 'age' con contenido de texto 'abc' no es válido. Se esperaba un valor del tipo 'xs:positiveInteger'.
4. Esquemas XSD más complejos: tipos, enumeraciones, patrones
XSD es prácticamente un lenguaje para describir datos válidos. Aquí tienes unos ejemplos avanzados:
Enumeración de valores permitidos
<xs:element name="gender">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="male"/>
<xs:enumeration value="female"/>
<xs:enumeration value="diverse"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Restricción de longitud de cadena
<xs:element name="code">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:length value="8"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Patrón para email (simplificado)
<xs:element name="email">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="\w+@\w+\.\w+"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Puedes crear tus propios tipos, derivarlos, usar elementos anidados — ¡casi como en OOP!
5. Validación de un documento complejo
Imagina que nuestra app educativa ahora exporta una lista de estudiantes en XML. ¡Añadamos código!
Ejemplo XML
<students>
<student id="1">
<name>Elena</name>
<grade>5</grade>
</student>
<student id="2">
<name>Alexey</name>
<grade>4</grade>
</student>
</students>
Esquema XSD
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="students">
<xs:complexType>
<xs:sequence>
<xs:element name="student" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="grade">
<xs:simpleType>
<xs:restriction base="xs:integer">
<xs:minInclusive value="1"/>
<xs:maxInclusive value="5"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
</xs:sequence>
<xs:attribute name="id" type="xs:integer" use="required"/>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Validación en código (con los mismos trucos):
// Rutas a los archivos
string xmlPath = "students.xml";
string xsdPath = "students.xsd";
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("", xsdPath);
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas = schemas;
settings.ValidationType = ValidationType.Schema;
settings.ValidationEventHandler += ValidationCallBack;
using XmlReader reader = XmlReader.Create(xmlPath, settings);
while (reader.Read()) { /* todo como antes */ }
6. Detalles útiles
Cómo indicar el esquema directamente en el XML (xsi:schemaLocation)
En la práctica a menudo verás XML donde en el elemento raíz hay atributos xsi:schemaLocation o xsi:noNamespaceSchemaLocation:
<students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="students.xsd">
...
</students>
Eso no valida el archivo "automáticamente", pero ayuda a algunos validadores y editores a localizar el esquema para comprobarlo. En la validación de .NET no es obligatorio, pero es formalmente correcto.
Validación "sobre la marcha" y en memoria — con XDocument
Si trabajas con LINQ to XML (XDocument), también puedes validar un documento XML en memoria, sin usar ficheros:
using System.Xml.Linq;
using System.Xml.Schema;
// Carga del esquema
XmlSchemaSet schema = new XmlSchemaSet();
schema.Add("", "students.xsd");
// Carga del XML en memoria
XDocument doc = XDocument.Load("students.xml");
// Validación
doc.Validate(schema,
(o, e) => Console.WriteLine($"Error: {e.Message}"),
true // Comprobar advertencias (a menudo excesivo)
);
Este enfoque es útil si creas o modificas XML programáticamente y quieres asegurarte de no haber generado un monstruo XML que incumpla el esquema.
7. Errores típicos al validar XML con XSD
Error nº1: olvidaste añadir el esquema o pusiste una ruta incorrecta al XSD.
Como resultado no se realiza ninguna validación y el XML pasa "por la guardia", aunque tenga errores. A menudo la ruta es relativa y la app busca el fichero en un sitio inesperado. Para pruebas mejor usar ruta absoluta o poner el esquema junto al ejecutable.
Error nº2: los namespaces no coinciden.
Si tu esquema usa un namespace, debes pasarlo como primer/segundo argumento al añadir el esquema en XmlSchemaSet.Add. Si no, la validación fallará aunque la estructura del XML sea correcta. Si no hay namespace — pasa una cadena vacía.
Error nº3: orden de elementos distinto.
Si en el esquema está definido <xs:sequence>, el orden de los elementos importa. Un XML con los elementos correctos pero en orden distinto se considerará inválido.
Error nº4: el XML declara varios namespaces.
Si el documento usa más de un namespace, puede provocar comportamientos inesperados en la validación. Soportar múltiples namespaces requiere atención y configurar bien los esquemas.
Error nº5: no coleccionar y guardar los errores.
Mostrar errores directamente en la consola puede servir para depuración, pero no para una app en producción. Mejor recoger los errores en una lista y mostrárselos al usuario de forma amigable — especialmente si validas muchos ficheros (p.ej. en un servidor web).
GO TO FULL VERSION