Compartilhar via

Infira esquemas a partir de documentos XML

Este tópico descreve como usar a XmlSchemaInference classe para inferir um esquema XSD (linguagem de definição de esquema XML) da estrutura de um documento XML.

O processo de inferência de esquema

A XmlSchemaInference classe do System.Xml.Schema namespace é usada para gerar um ou mais esquemas XSD (linguagem de definição de esquema XML) da estrutura de um documento XML. Os esquemas gerados podem ser usados para validar o documento XML original.

Como um documento XML é processado pela XmlSchemaInference classe, a XmlSchemaInference classe faz suposições sobre os componentes de esquema que descrevem os elementos e atributos no documento XML. A XmlSchemaInference classe também infere componentes de esquema de forma restrita inferindo o tipo mais restritivo para um determinado elemento ou atributo. À medida que mais informações sobre o documento XML são coletadas, essas restrições são afrouxadas inferindo tipos menos restritivos. O tipo menos restritivo que pode ser inferido é xs:string.

Veja, por exemplo, a seguinte parte de um documento XML.

<parent attribute1="6">
    <child>One</child>
    <child>Two</child>
</parent>
<parent attribute1="A" />

No exemplo acima, quando o attribute1 atributo é encontrado com um valor de 6 pelo XmlSchemaInference processo, supõe-se que ele seja do tipo xs:unsignedByte. Quando o segundo parent elemento é encontrado pelo XmlSchemaInference processo, a restrição é afrouxada modificando o tipo para xs:string porque o valor do attribute1 atributo é agora A. Da mesma forma, o minOccurs atributo de todos os child elementos inferidos no esquema é afrouxado para minOccurs="0", pois o segundo elemento pai não tem elementos filhos.

Inferindo esquemas a partir de documentos XML

A XmlSchemaInference classe usa dois métodos sobrecarregados InferSchema para inferir um esquema de um documento XML.

O primeiro XmlSchemaInference.InferSchema método é usado para criar um esquema com base em um documento XML. O segundo XmlSchemaInference.InferSchema método é usado para inferir um esquema que descreve vários documentos XML. Por exemplo, você pode alimentar vários documentos XML para o XmlSchemaInference.InferSchema método um de cada vez para produzir um esquema que descreve todo o conjunto de documentos XML.

O primeiro XmlSchemaInference.InferSchema método infere um esquema de um documento XML contido em um XmlReader objeto e retorna um XmlSchemaSet objeto que contém o esquema inferido. O segundo XmlSchemaInference.InferSchema método pesquisa um XmlSchemaSet objeto em busca de um esquema com o mesmo namespace de destino que o documento XML contido no XmlReader objeto, refina o esquema existente e retorna um XmlSchemaSet objeto que contém o esquema inferido.

As alterações feitas no esquema refinado baseiam-se na nova estrutura encontrada no documento XML. Por exemplo, à medida que um documento XML é percorrido, suposições são feitas sobre os tipos de dados encontrados e o esquema é criado com base nessas suposições. No entanto, se os dados forem encontrados em uma segunda passagem de inferência que difere da suposição original, o esquema será refinado. O exemplo a seguir ilustra o processo de refinamento.

XmlReader reader = XmlReader.Create("item1.xml");
XmlReader reader1 = XmlReader.Create("item2.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference inference = new XmlSchemaInference();
schemaSet = inference.InferSchema(reader);

// Display the inferred schema.
Console.WriteLine("Original schema:\n");
foreach (XmlSchema schema in schemaSet.Schemas("http://www.contoso.com/items"))
{
    schema.Write(Console.Out);
}

// Use the additional data in item2.xml to refine the original schema.
schemaSet = inference.InferSchema(reader1, schemaSet);

// Display the refined schema.
Console.WriteLine("\n\nRefined schema:\n");
foreach (XmlSchema schema in schemaSet.Schemas("http://www.contoso.com/items"))
{
    schema.Write(Console.Out);
}

Dim reader As XmlReader = XmlReader.Create("item1.xml")
Dim reader1 As XmlReader = XmlReader.Create("item2.xml")
Dim schemaSet As XmlSchemaSet = New XmlSchemaSet()
Dim inference As XmlSchemaInference = New XmlSchemaInference()
schemaSet = inference.InferSchema(reader)

' Display the inferred schema.
Console.WriteLine("Original schema:\n")
For Each schema As XmlSchema In schemaSet.Schemas("http://www.contoso.com/items")
    schema.Write(Console.Out)
Next

' Use the additional data in item2.xml to refine the original schema.
schemaSet = inference.InferSchema(reader1, schemaSet)

' Display the refined schema.
Console.WriteLine("\n\nRefined schema:\n")
For Each schema As XmlSchema In schemaSet.Schemas("http://www.contoso.com/items")
    schema.Write(Console.Out)
Next

O exemplo usa o arquivo a seguir, item1.xmlcomo sua primeira entrada.

<?xml version="1.0" encoding="utf-8"?>
<item xmlns="http://www.contoso.com/items" productID="123456789">
    <name>Hammer</name>
    <price>9.95</price>
    <supplierID>1929</supplierID>
</item>

Em seguida, o exemplo usa o item2.xml arquivo como sua segunda entrada:

<?xml version="1.0" encoding="utf-8"?>
<item xmlns="http://www.contoso.com/items" productID="A53-246">
    <name>Paint</name>
    <price>12.50</price>
</item>

Quando o atributo productID é encontrado no primeiro documento XML, o valor 123456789 é considerado um tipo xs:unsignedInt. No entanto, quando o segundo documento XML é lido e o valor de A53-246 é encontrado, o tipo xs:unsignedInt não pode mais ser assumido. O esquema é refinado e o tipo de productID é alterado para xs:string. Além disso, o atributo minOccurs para o elemento supplierID é definido como 0, porque o segundo documento XML não contém o elemento supplierID.

Veja a seguir o esquema inferido do primeiro documento XML.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="http://www.contoso.com/items" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="item">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="name" type="xs:string" />
        <xs:element name="price" type="xs:decimal" />
        <xs:element name="supplierID" type="xs:unsignedShort" />
      </xs:sequence>
      <xs:attribute name="productID" type="xs:unsignedInt" use="required" />
    </xs:complexType>
  </xs:element>
</xs:schema>

Veja a seguir o esquema inferido do primeiro documento XML, refinado pelo segundo documento XML.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="http://www.contoso.com/items" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="item">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="name" type="xs:string" />
        <xs:element name="price" type="xs:decimal" />
        <xs:element minOccurs="0" name="supplierID" type="xs:unsignedShort" />
      </xs:sequence>
      <xs:attribute name="productID" type="xs:string" use="required" />
    </xs:complexType>
  </xs:element>
</xs:schema>

Esquemas embutidos

Se um esquema XSD (linguagem de definição de esquema XML) embutido for encontrado durante o XmlSchemaInference processo, um XmlSchemaInferenceException será gerado. Por exemplo, o esquema embutido a seguir gera um XmlSchemaInferenceException.

<root xmlns:ex="http://www.contoso.com" xmlns="http://www.tempuri.org">
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.contoso.com">
        <xs:element name="Contoso" type="xs:normalizedString" />
    </xs:schema>
    <ex:Contoso>Test</ex:Contoso>
</root>

Esquemas que não podem ser refinados

Há construções de esquema XML W3C que o processo de esquema XSD (linguagem de definição de esquema XML) não pode manipular quando é dado um tipo para refinar e isso causa a geração de uma exceção. Como um tipo complexo cujo compositor de nível superior é algo diferente de uma sequência. No Modelo de Objeto de Esquema (SOM), isso corresponde a um XmlSchemaComplexType cuja propriedade Particle não é uma instância de XmlSchemaSequence.

Consulte também

  • Last updated on