CodeGym /Cursos /C# SELF /Validação XML usando esquemas XSD

Validação XML usando esquemas XSD

C# SELF
Nível 48, Lição 4
Disponível

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)
<person age="23">Ivan</person>
<element name="person" ... />
<item price="1000"/>
<element name="item" type="..." />

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:

  1. Carregar o arquivo XML
  2. Carregar o esquema XSD
  3. "Anexar" o esquema para validar o XML
  4. 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).

2
Tarefa
C# SELF, nível 48, lição 4
Bloqueado
Extensão da estrutura XML e validação com múltiplas regras
Extensão da estrutura XML e validação com múltiplas regras
1
Pesquisa/teste
Trabalhando com dados XML, nível 48, lição 4
Indisponível
Trabalhando com dados XML
Configurando serialização XML
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION