1. Para que serve a validação de XML
XML é um formato bem flexível, às vezes até demais. Ao contrário de dados fortemente tipados, XML "tolerará" erros, e se você esquecer de fechar uma tag, ou alguém escrever o nome errado de um atributo, o programa pode dar erro já na hora de parsear o arquivo… ou nem notar o problema, o que é pior.
Validação por XSD (XML Schema Definition) — é uma forma de garantir que seu arquivo XML obedece a um contrato pré-definido: quais são os nomes das tags, em que ordem aparecem, quais tipos têm, se são obrigatórias e quantas podem existir. É como um controle de passaporte pros seus dados — o esquema diz: "Você não entra aqui sem o campo necessário ou se o campo não tem o tamanho certo!"
A validação é importante em sistemas corporativos, no intercâmbio de dados entre sistemas, APIs — em tudo quanto é lugar onde não dá pra aceitar estruturas tortas sem avisar.
XSD (XML Schema Definition) — é um documento XML separado que formaliza a estrutura de outro XML. No XSD você descreve: quais tags são permitidas, quais são obrigatórias, os tipos de atributos ou elementos filhos, padrões pra strings, restrições pra números, até valores possíveis (através de restrições e enumerações).
| XML | XSD (descrição da estrutura) |
|---|---|
|
|
|
|
XSD é parecido no conceito com JSON Schema no mundo JSON.
2. Exemplo de XSD e XML relacionado
Exemplo de XML
<person age="23">
<name>Ivan</name>
<email>ivan@example.com</email>
</person>
Exemplo de 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>
O que esse esquema descreve:
- Elemento raiz — <person>.
- Dentro de <person> devem vir os elementos <name> (obrigatório) e <email> (opcional).
- O <person> deve ter o atributo age com valor inteiro positivo.
3. Validação de XML com XSD no .NET
No .NET o caminho clássico é usar os namespaces System.Xml e System.Xml.Schema.
Fluxo de trabalho:
- Carregar o arquivo XML
- Carregar o esquema XSD
- "Anexar" o esquema para validar o XML
- Executar a validação e tratar possíveis erros
Abaixo um exemplo básico:
using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
// 1. Handler de erros de validação
void ValidationCallBack(object? sender, ValidationEventArgs e)
{
Console.WriteLine($"Erro de validação: {e.Message}");
}
string xmlPath = "person.xml";
string xsdPath = "person.xsd";
// 2. Carregamos o esquema
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("", xsdPath);
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas = schemas;
settings.ValidationType = ValidationType.Schema;
settings.ValidationEventHandler += ValidationCallBack;
// 3. Abrimos o XML com as settings
using XmlReader reader = XmlReader.Create(xmlPath, settings);
while (reader.Read())
{
// Apenas percorre o documento - a validação acontece "on the fly"
}
Console.WriteLine("Validação concluída!");
Explicações:
- Todos os erros de validação serão capturados no callback ValidationCallBack.
- Se não houver erros — o documento está conforme o esquema (ValidationType.Schema).
- Se houver divergências (falta o age, email inválido, campo extra, etc.) — elas aparecerão no console.
Diversos tipos de erros e feedback
A validação por XSD pode "reclamar" por vários motivos. Aqui os cenários mais comuns e exemplos de erros:
- Falta um elemento obrigatório (minOccurs="1" por padrão)
- Tag extra que não está descrita no XSD
- Atributo com tipo errado (age="abc" em vez de número)
- Strings que não batem com o pattern (descritos via <xs:pattern>)
Erro típico:
Erro de validação: O elemento 'age' com conteúdo de texto 'abc' não é permitido. Era esperado um valor do tipo 'xs:positiveInteger'.
4. Esquemas XSD mais complexos: tipos, enumerações, patterns
XSD é praticamente uma linguagem pra descrever dados válidos. Aqui alguns exemplos avançados:
Enumeração 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>
Restrição de comprimento de string
<xs:element name="code">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:length value="8"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
Pattern 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>
Você pode criar seus próprios tipos, derivá-los, usar elementos aninhados — praticamente como em OOP!
5. Validação de um documento complexo
Imagina que nosso app de ensino agora exporta uma lista de estudantes em XML. Vamos adicionar código!
Exemplo de 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>
Validação no código (mesmos truques):
// Caminhos dos arquivos
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()) { /* tudo como antes */ }
6. Dicas úteis
Como indicar o esquema direto no XML (xsi:schemaLocation)
Na prática você vai ver XMLs onde no elemento raiz tem atributos xsi:schemaLocation ou xsi:noNamespaceSchemaLocation:
<students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="students.xsd">
...
</students>
Isso não valida o arquivo "automaticamente", mas ajuda algumas ferramentas e editores a encontrar o esquema pra checagem. Na validação .NET isso não é obrigatório, mas é formalmente correto.
Validação "on the fly" e em memória — com XDocument
Se você trabalha com LINQ to XML (XDocument), também dá pra validar o documento em memória, sem arquivos:
using System.Xml.Linq;
using System.Xml.Schema;
// Carrega o esquema
XmlSchemaSet schema = new XmlSchemaSet();
schema.Add("", "students.xsd");
// Carrega o XML na memória
XDocument doc = XDocument.Load("students.xml");
// Validação
doc.Validate(schema,
(o, e) => Console.WriteLine($"Erro: {e.Message}"),
true // Checar warnings (frequentemente redundante)
);
Esse jeito é prático se você cria ou modifica XML programaticamente e quer garantir que não gerou um monstro XML que quebra o esquema.
7. Erros típicos ao validar XML com XSD
Erro #1: esqueceu de anexar o esquema ou passou o caminho errado pro XSD.
Como resultado nenhuma validação é feita e o XML "passa pela guarda", mesmo tendo erros. Muitas vezes o caminho é relativo e a aplicação procura o arquivo em lugar inesperado. Pra testes é melhor usar caminho absoluto ou colocar o esquema junto do executável.
Erro #2: namespaces não coincidem.
Se seu esquema usa namespace, você precisa passar esse namespace como primeiro argumento ao adicionar o esquema no XmlSchemaSet.Add. Caso contrário a validação vai falhar mesmo que a estrutura XML esteja correta. Se não há namespace — passe string vazia.
Erro #3: ordem dos elementos não bate.
Se no esquema está definido <xs:sequence>, a ordem importa. XML onde os elementos corretos aparecem na ordem errada será considerado inválido.
Erro #4: o XML declara múltiplos namespaces.
Se o documento usa mais de um namespace, isso pode levar a falhas inesperadas na validação. Suporte a múltiplos namespaces exige cuidado especial e configuração precisa dos esquemas.
Erro #5: não coletar e armazenar erros.
Imprimir erros direto no console pode servir pra debug, mas não pra produção. Melhor juntar os erros numa lista e apresentar pro usuário de modo amigável — especialmente quando você valida muitos arquivos (por exemplo, num servidor web).
GO TO FULL VERSION