Inferindo esquemas de documentos XML
Este tópico descreve como usar a XmlSchemaInference classe para inferir um esquema XSD (XML Schema Definition Language) a partir 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 (XML Schema Definition Language) a partir da estrutura de um documento XML. Os esquemas gerados podem ser usados para validar o documento XML original.
Como um documento XML é processado XmlSchemaInference pela classe, a XmlSchemaInference classe faz suposições sobre os componentes do 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 pela inferência de tipos menos restritivos. O tipo menos restritivo que se pode inferir é xs:string.
Tome, 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, presume-se que 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 attribute1 valor do atributo é agora A. Da mesma forma, o minOccurs atributo para todos os child elementos inferidos no esquema são afrouxados para minOccurs="0" porque o segundo elemento pai não tem elementos filho.
Inferindo esquemas 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 baseado 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 descreva 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 procura um XmlSchemaSet objeto para 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 são baseadas na nova estrutura encontrada no documento XML. Por exemplo, à medida que um documento XML é percorrido, são feitas suposições 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 = gcnew XmlSchemaSet();
XmlSchemaInference^ inference = gcnew XmlSchemaInference();
schemaSet = inference->InferSchema(reader);
// Display the inferred schema.
Console::WriteLine("Original schema:\n");
for each (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");
for each (XmlSchema^ schema in schemaSet->Schemas("http://www.contoso.com/items"))
{
schema->Write(Console::Out);
}
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 toma o seguinte arquivo, item1.xml, como 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>
O exemplo então toma 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 productID atributo é encontrado no primeiro documento XML, o valor de é assumido 123456789 como um xs:unsignedInt tipo. No entanto, quando o segundo documento XML é lido e o valor de A53-246 é encontrado, o xs:unsignedInt tipo não pode mais ser assumido. O esquema é refinado e o tipo de productID é alterado para xs:string. Além disso, o minOccurs atributo para o supplierID elemento é definido como 0, porque o segundo documento XML não contém nenhum supplierID elemento .
A seguir está 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>
A seguir está 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á lançado. Por exemplo, o esquema embutido a seguir lança um XmlSchemaInferenceExceptionarquivo .
<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 do esquema XML do W3C que o processo de esquema XmlSchemaInference XSD (XML Schema Definition Language) não pode manipular se for dado um tipo para refinar e fazer com que uma exceção seja lançada. Como um tipo complexo cujo compositor de nível superior é qualquer coisa diferente de uma sequência. No Schema Object Model (SOM), isso corresponde a uma XmlSchemaComplexType cuja Particle propriedade não é uma instância de XmlSchemaSequence.
