XmlSchemaValidator Validação baseada em push
A XmlSchemaValidator classe fornece um mecanismo eficiente e de alto desempenho para validar dados XML em esquemas XML de uma maneira baseada em push. Por exemplo, a XmlSchemaValidator classe permite validar um infoset XML in-loco sem ter que serializá-lo como um documento XML e, em seguida, analisar o documento usando um leitor XML de validação.
A XmlSchemaValidator classe pode ser usada em cenários avançados, como a criação de mecanismos de validação sobre fontes de dados XML personalizadas ou como uma maneira de criar um gravador XML de validação.
A seguir está um exemplo de uso da XmlSchemaValidator classe para validar o arquivo em relação ao contosoBooks.xml contosoBooks.xsd esquema. O exemplo usa a XmlSerializer classe para desserializar o contosoBooks.xml arquivo e passar o valor dos nós para os métodos da XmlSchemaValidator classe.
Nota
Este exemplo é usado ao longo das seções deste tópico.
using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Collections;
namespace Microsoft.Samples.Xml.Schema
{
class XmlSchemaValidatorExamples
{
static void Main()
{
// The XML document to deserialize into the XmlSerializer object.
XmlReader reader = XmlReader.Create("contosoBooks.xml");
// The XmlSerializer object.
XmlSerializer serializer = new XmlSerializer(typeof(ContosoBooks));
ContosoBooks books = (ContosoBooks)serializer.Deserialize(reader);
// The XmlSchemaSet object containing the schema used to validate the XML document.
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add("http://www.contoso.com/books", "contosoBooks.xsd");
// The XmlNamespaceManager object used to handle namespaces.
XmlNamespaceManager manager = new XmlNamespaceManager(reader.NameTable);
// Assign a ValidationEventHandler to handle schema validation warnings and errors.
XmlSchemaValidator validator = new XmlSchemaValidator(reader.NameTable, schemaSet, manager, XmlSchemaValidationFlags.None);
validator.ValidationEventHandler += new ValidationEventHandler(SchemaValidationEventHandler);
// Initialize the XmlSchemaValidator object.
validator.Initialize();
// Validate the bookstore element, verify that all required attributes are present
// and prepare to validate child content.
validator.ValidateElement("bookstore", "http://www.contoso.com/books", null);
validator.GetUnspecifiedDefaultAttributes(new ArrayList());
validator.ValidateEndOfAttributes(null);
// Get the next expected element in the bookstore context.
XmlSchemaParticle[] particles = validator.GetExpectedParticles();
XmlSchemaElement nextElement = particles[0] as XmlSchemaElement;
Console.WriteLine("Expected Element: '{0}'", nextElement.Name);
foreach (BookType book in books.Book)
{
// Validate the book element.
validator.ValidateElement("book", "http://www.contoso.com/books", null);
// Get the expected attributes for the book element.
Console.Write("\nExpected attributes: ");
XmlSchemaAttribute[] attributes = validator.GetExpectedAttributes();
foreach (XmlSchemaAttribute attribute in attributes)
{
Console.Write("'{0}' ", attribute.Name);
}
Console.WriteLine();
// Validate the genre attribute and display its post schema validation information.
if (book.Genre != null)
{
validator.ValidateAttribute("genre", "", book.Genre, schemaInfo);
}
DisplaySchemaInfo();
// Validate the publicationdate attribute and display its post schema validation information.
if (book.PublicationDate != null)
{
validator.ValidateAttribute("publicationdate", "", dateTimeGetter(book.PublicationDate), schemaInfo);
}
DisplaySchemaInfo();
// Validate the ISBN attribute and display its post schema validation information.
if (book.Isbn != null)
{
validator.ValidateAttribute("ISBN", "", book.Isbn, schemaInfo);
}
DisplaySchemaInfo();
// After validating all the attributes for the current element with ValidateAttribute method,
// you must call GetUnspecifiedDefaultAttributes to validate the default attributes.
validator.GetUnspecifiedDefaultAttributes(new ArrayList());
// Verify that all required attributes of the book element are present
// and prepare to validate child content.
validator.ValidateEndOfAttributes(null);
// Validate the title element and its content.
validator.ValidateElement("title", "http://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Title);
// Validate the author element, verify that all required attributes are present
// and prepare to validate child content.
validator.ValidateElement("author", "http://www.contoso.com/books", null);
validator.GetUnspecifiedDefaultAttributes(new ArrayList());
validator.ValidateEndOfAttributes(null);
if (book.Author.Name != null)
{
// Validate the name element and its content.
validator.ValidateElement("name", "http://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Author.Name);
}
if (book.Author.FirstName != null)
{
// Validate the first-name element and its content.
validator.ValidateElement("first-name", "http://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Author.FirstName);
}
if (book.Author.LastName != null)
{
// Validate the last-name element and its content.
validator.ValidateElement("last-name", "http://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Author.LastName);
}
// Validate the content of the author element.
validator.ValidateEndElement(null);
// Validate the price element and its content.
validator.ValidateElement("price", "http://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Price);
// Validate the content of the book element.
validator.ValidateEndElement(null);
}
// Validate the content of the bookstore element.
validator.ValidateEndElement(null);
// Close the XmlReader object.
reader.Close();
}
static XmlSchemaInfo schemaInfo = new XmlSchemaInfo();
static object dateTimeGetterContent;
static object dateTimeGetterHandle()
{
return dateTimeGetterContent;
}
static XmlValueGetter dateTimeGetter(DateTime dateTime)
{
dateTimeGetterContent = dateTime;
return new XmlValueGetter(dateTimeGetterHandle);
}
static void DisplaySchemaInfo()
{
if (schemaInfo.SchemaElement != null)
{
Console.WriteLine("Element '{0}' with type '{1}' is '{2}'",
schemaInfo.SchemaElement.Name, schemaInfo.SchemaType, schemaInfo.Validity);
}
else if (schemaInfo.SchemaAttribute != null)
{
Console.WriteLine("Attribute '{0}' with type '{1}' is '{2}'",
schemaInfo.SchemaAttribute.Name, schemaInfo.SchemaType, schemaInfo.Validity);
}
}
static void SchemaValidationEventHandler(object sender, ValidationEventArgs e)
{
switch (e.Severity)
{
case XmlSeverityType.Error:
Console.WriteLine("\nError: {0}", e.Message);
break;
case XmlSeverityType.Warning:
Console.WriteLine("\nWarning: {0}", e.Message);
break;
}
}
}
[XmlRootAttribute("bookstore", Namespace = "http://www.contoso.com/books", IsNullable = false)]
public class ContosoBooks
{
[XmlElementAttribute("book")]
public BookType[] Book;
}
public class BookType
{
[XmlAttributeAttribute("genre")]
public string Genre;
[XmlAttributeAttribute("publicationdate", DataType = "date")]
public DateTime PublicationDate;
[XmlAttributeAttribute("ISBN")]
public string Isbn;
[XmlElementAttribute("title")]
public string Title;
[XmlElementAttribute("author")]
public BookAuthor Author;
[XmlElementAttribute("price")]
public Decimal Price;
}
public class BookAuthor
{
[XmlElementAttribute("name")]
public string Name;
[XmlElementAttribute("first-name")]
public string FirstName;
[XmlElementAttribute("last-name")]
public string LastName;
}
}
Imports System.Xml
Imports System.Xml.Schema
Imports System.Xml.Serialization
Imports System.Collections
Namespace Microsoft.Samples.Xml.Schema
Class XmlSchemaValidatorExamples
Shared Sub Main()
' The XML document to deserialize into the XmlSerializer object.
Dim reader As XmlReader = XmlReader.Create("contosoBooks.xml")
' The XmlSerializer object.
Dim serializer As XmlSerializer = New XmlSerializer(GetType(ContosoBooks))
Dim books As ContosoBooks = CType(serializer.Deserialize(reader), ContosoBooks)
' The XmlSchemaSet object containing the schema used to validate the XML document.
Dim schemaSet As XmlSchemaSet = New XmlSchemaSet()
schemaSet.Add("http://www.contoso.com/books", "contosoBooks.xsd")
' The XmlNamespaceManager object used to handle namespaces.
Dim manager As XmlNamespaceManager = New XmlNamespaceManager(reader.NameTable)
' Assign a ValidationEventHandler to handle schema validation warnings and errors.
Dim validator As XmlSchemaValidator = New XmlSchemaValidator(reader.NameTable, schemaSet, manager, XmlSchemaValidationFlags.None)
'validator.ValidationEventHandler += New ValidationEventHandler(SchemaValidationEventHandler)
AddHandler validator.ValidationEventHandler, AddressOf SchemaValidationEventHandler
' Initialize the XmlSchemaValidator object.
validator.Initialize()
' Validate the bookstore element, verify that all required attributes are present
' and prepare to validate child content.
validator.ValidateElement("bookstore", "http://www.contoso.com/books", Nothing)
validator.GetUnspecifiedDefaultAttributes(New ArrayList())
validator.ValidateEndOfAttributes(Nothing)
' Get the next expected element in the bookstore context.
Dim particles() As XmlSchemaParticle = validator.GetExpectedParticles()
Dim nextElement As XmlSchemaElement = particles(0)
Console.WriteLine("Expected Element: '{0}'", nextElement.Name)
For Each book As BookType In books.book
' Validate the book element.
validator.ValidateElement("book", "http://www.contoso.com/books", Nothing)
' Get the expected attributes for the book element.
Console.Write(vbCrLf & "Expected attributes: ")
Dim attributes() As XmlSchemaAttribute = validator.GetExpectedAttributes()
For Each attribute As XmlSchemaAttribute In attributes
Console.Write("'{0}' ", attribute.Name)
Next
Console.WriteLine()
' Validate the genre attribute and display its post schema validation information.
If Not book.Genre Is Nothing Then
validator.ValidateAttribute("genre", "", book.Genre, schemaInfo)
End If
DisplaySchemaInfo()
' Validate the publicationdate attribute and display its post schema validation information.
If Not book.PublicationDate = Nothing Then
validator.ValidateAttribute("publicationdate", "", dateTimeGetter(book.PublicationDate), schemaInfo)
End If
DisplaySchemaInfo()
' Validate the ISBN attribute and display its post schema validation information.
If Not book.Isbn Is Nothing Then
validator.ValidateAttribute("ISBN", "", book.Isbn, schemaInfo)
End If
DisplaySchemaInfo()
' After validating all the attributes for the current element with ValidateAttribute method,
' you must call GetUnspecifiedDefaultAttributes to validate the default attributes.
validator.GetUnspecifiedDefaultAttributes(New ArrayList())
' Verify that all required attributes of the book element are present
' and prepare to validate child content.
validator.ValidateEndOfAttributes(Nothing)
' Validate the title element and its content.
validator.ValidateElement("title", "http://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Title)
' Validate the author element, verify that all required attributes are present
' and prepare to validate child content.
validator.ValidateElement("author", "http://www.contoso.com/books", Nothing)
validator.GetUnspecifiedDefaultAttributes(New ArrayList())
validator.ValidateEndOfAttributes(Nothing)
If Not book.Author.Name Is Nothing Then
' Validate the name element and its content.
validator.ValidateElement("name", "http://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Author.Name)
End If
If Not book.Author.FirstName Is Nothing Then
' Validate the first-name element and its content.
validator.ValidateElement("first-name", "http://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Author.FirstName)
End If
If Not book.Author.LastName Is Nothing Then
' Validate the last-name element and its content.
validator.ValidateElement("last-name", "http://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Author.LastName)
End If
' Validate the content of the author element.
validator.ValidateEndElement(Nothing)
' Validate the price element and its content.
validator.ValidateElement("price", "http://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Price)
' Validate the content of the book element.
validator.ValidateEndElement(Nothing)
Next
' Validate the content of the bookstore element.
validator.ValidateEndElement(Nothing)
' Close the XmlReader object.
reader.Close()
End Sub
Shared schemaInfo As XmlSchemaInfo = New XmlSchemaInfo()
Shared dateTimeGetterContent As Object
Shared Function dateTimeGetterHandle() As Object
Return dateTimeGetterContent
End Function
Shared Function dateTimeGetter(ByVal dateTime As DateTime) As XmlValueGetter
dateTimeGetterContent = dateTime
Return New XmlValueGetter(AddressOf dateTimeGetterHandle)
End Function
Shared Sub DisplaySchemaInfo()
If Not schemaInfo.SchemaElement Is Nothing Then
Console.WriteLine("Element '{0}' with type '{1}' is '{2}'", schemaInfo.SchemaElement.Name, schemaInfo.SchemaType, schemaInfo.Validity)
ElseIf Not schemaInfo.SchemaAttribute Is Nothing Then
Console.WriteLine("Attribute '{0}' with type '{1}' is '{2}'", schemaInfo.SchemaAttribute.Name, schemaInfo.SchemaType, schemaInfo.Validity)
End If
End Sub
Shared Sub SchemaValidationEventHandler(ByVal sender As Object, ByVal e As ValidationEventArgs)
Select Case e.Severity
Case XmlSeverityType.Error
Console.WriteLine(vbCrLf & "Error: {0}", e.Message)
Exit Sub
Case XmlSeverityType.Warning
Console.WriteLine(vbCrLf & "Warning: {0}", e.Message)
Exit Sub
End Select
End Sub
End Class
<XmlRootAttribute("bookstore", Namespace:="http://www.contoso.com/books", IsNullable:=False)> _
Public Class ContosoBooks
<XmlElementAttribute("book")> _
Public book() As BookType
End Class
Public Class BookType
<XmlAttributeAttribute("genre")> _
Public Genre As String
<XmlAttributeAttribute("publicationdate", DataType:="date")> _
Public PublicationDate As DateTime
<XmlAttributeAttribute("ISBN")> _
Public Isbn As String
<XmlElementAttribute("title")> _
Public Title As String
<XmlElementAttribute("author")> _
Public Author As BookAuthor
<XmlElementAttribute("price")> _
Public Price As Decimal
End Class
Public Class BookAuthor
<XmlElementAttribute("name")> _
Public Name As String
<XmlElementAttribute("first-name")> _
Public FirstName As String
<XmlElementAttribute("last-name")> _
Public LastName As String
End Class
End Namespace
O exemplo usa o contosoBooks.xml arquivo como entrada.
<?xml version="1.0" encoding="utf-8" ?>
<bookstore xmlns="http://www.contoso.com/books">
<book genre="autobiography" publicationdate="1981-03-22" ISBN="1-861003-11-0">
<title>The Autobiography of Benjamin Franklin</title>
<author>
<first-name>Benjamin</first-name>
<last-name>Franklin</last-name>
</author>
<price>8.99</price>
</book>
<book genre="novel" publicationdate="1967-11-17" ISBN="0-201-63361-2">
<title>The Confidence Man</title>
<author>
<first-name>Herman</first-name>
<last-name>Melville</last-name>
</author>
<price>11.99</price>
</book>
<book genre="philosophy" publicationdate="1991-02-15" ISBN="1-861001-57-6">
<title>The Gorgias</title>
<author>
<name>Plato</name>
</author>
<price>9.99</price>
</book>
</bookstore>
O exemplo também toma o contosoBooks.xsd como uma entrada.
<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="http://www.contoso.com/books" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="bookstore">
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs="unbounded" name="book">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string" />
<xs:element name="author">
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="0" name="name" type="xs:string" />
<xs:element minOccurs="0" name="first-name" type="xs:string" />
<xs:element minOccurs="0" name="last-name" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="price" type="xs:decimal" />
</xs:sequence>
<xs:attribute name="genre" type="xs:string" use="required" />
<xs:attribute name="publicationdate" type="xs:date" use="required" />
<xs:attribute name="ISBN" type="xs:string" use="required" />
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Validando dados XML usando XmlSchemaValidator
Para começar a validar um infoset XML, você deve primeiro inicializar uma nova instância da XmlSchemaValidator classe usando o XmlSchemaValidator construtor.
O XmlSchemaValidator construtor toma XmlNameTable, XmlSchemaSet, e XmlNamespaceManager objetos como parâmetros, bem como um XmlSchemaValidationFlags valor como um parâmetro. O XmlNameTable objeto é usado para atomizar cadeias de caracteres de namespace bem conhecidas, como o namespace de esquema, o namespace XML e assim por diante, e é passado para o método durante a ParseValue validação de conteúdo simples. O XmlSchemaSet objeto contém os esquemas XML usados para validar o infoset XML. O XmlNamespaceManager objeto é usado para resolver namespaces encontrados durante a validação. O XmlSchemaValidationFlags valor é usado para desativar determinados recursos de validação.
Para obter mais informações sobre o XmlSchemaValidator construtor, consulte a documentação de referência de XmlSchemaValidator classe.
Inicializando a validação
Depois que um XmlSchemaValidator objeto foi construído, há dois métodos sobrecarregados Initialize usados para inicializar o estado do XmlSchemaValidator objeto. A seguir estão os dois Initialize métodos.
O método padrão XmlSchemaValidator.Initialize inicializa um XmlSchemaValidator objeto para seu estado inicial, e o método sobrecarregado XmlSchemaValidator.Initialize que toma um XmlSchemaObject como parâmetro inicializa um XmlSchemaValidator objeto para seu estado inicial para validação parcial.
Ambos os Initialize métodos só podem ser chamados imediatamente após um XmlSchemaValidator objeto ter sido construído ou após uma chamada para EndValidation.
Para obter um exemplo do XmlSchemaValidator.Initialize método, consulte o exemplo na introdução. Para obter mais informações sobre o Initialize método, consulte a documentação de referência de XmlSchemaValidator classe.
Validação parcial
O XmlSchemaValidator.Initialize método que toma um XmlSchemaObject como parâmetro inicializa um XmlSchemaValidator objeto ao seu estado inicial para validação parcial.
No exemplo a seguir, um XmlSchemaObject é inicializado para validação parcial usando o XmlSchemaValidator.Initialize método. O orderNumber elemento schema é passado selecionando o elemento schema by XmlQualifiedName na XmlSchemaObjectTable coleção retornada pela GlobalElements propriedade do XmlSchemaSet objeto. Em seguida, o XmlSchemaValidator objeto valida esse elemento específico.
Dim schemaSet As XmlSchemaSet = New XmlSchemaSet()
schemaSet.Add(Nothing, "schema.xsd")
schemaSet.Compile()
Dim nameTable As NameTable = New NameTable()
Dim manager As XmlNamespaceManager = New XmlNamespaceManager(nameTable)
Dim validator As XmlSchemaValidator = New XmlSchemaValidator(nameTable, schemaSet, manager, XmlSchemaValidationFlags.None)
validator.Initialize(schemaSet.GlobalElements.Item(New XmlQualifiedName("orderNumber")))
validator.ValidateElement("orderNumber", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
validator.ValidateText("123")
validator.ValidateEndElement(Nothing)
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "schema.xsd");
schemaSet.Compile();
NameTable nameTable = new NameTable();
XmlNamespaceManager manager = new XmlNamespaceManager(nameTable);
XmlSchemaValidator validator = new XmlSchemaValidator(nameTable, schemaSet, manager, XmlSchemaValidationFlags.None);
validator.Initialize(schemaSet.GlobalElements[new XmlQualifiedName("orderNumber")]);
validator.ValidateElement("orderNumber", "", null);
validator.ValidateEndOfAttributes(null);
validator.ValidateText("123");
validator.ValidateEndElement(null);
O exemplo usa o seguinte esquema XML como entrada.
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="orderNumber" type="xs:int" />
</xs:schema>
Para obter mais informações sobre o Initialize método, consulte a documentação de referência de XmlSchemaValidator classe.
Adicionando esquemas adicionais
O AddSchema método da XmlSchemaValidator classe é usado para adicionar um esquema XML ao conjunto de esquemas usados durante a validação. O AddSchema método pode ser usado para simular o efeito de encontrar um esquema XML embutido no infoset XML que está sendo validado.
Nota
O namespace de destino do parâmetro não pode corresponder ao XmlSchema de qualquer elemento ou atributo já encontrado pelo XmlSchemaValidator objeto.
Se o XmlSchemaValidationFlags.ProcessInlineSchema valor não foi passado como um parâmetro para o XmlSchemaValidator construtor, o AddSchema método não faz nada.
O resultado do método depende do AddSchema contexto atual do nó XML que está sendo validado. Para obter mais informações sobre contextos de validação, consulte a seção "Contexto de validação" deste tópico.
Para obter mais informações sobre o AddSchema método, consulte a documentação de referência de XmlSchemaValidator classe.
Validando elementos, atributos e conteúdo
A XmlSchemaValidator classe fornece vários métodos usados para validar elementos, atributos e conteúdo em um infoset XML em relação a esquemas XML. A tabela a seguir descreve cada um desses métodos.
| Método | Description |
|---|---|
| ValidateElement | Valida o nome do elemento no contexto atual. |
| ValidateAttribute | Valida o atributo no contexto do elemento atual ou em relação ao XmlSchemaAttribute objeto passado como um parâmetro para o Initialize método. |
| ValidateEndOfAttributes | Verifica se todos os atributos necessários no contexto do elemento estão presentes e prepara o XmlSchemaValidator objeto para validar o conteúdo filho do elemento. |
| ValidateText | Valida se o texto é permitido no contexto do elemento atual e acumula o texto para validação se o elemento atual tiver conteúdo simples. |
| ValidateWhitespace | Valida se o espaço em branco é permitido no contexto do elemento atual e acumula o espaço em branco para validação se o elemento atual tem conteúdo simples. |
| ValidateEndElement | Verifica se o conteúdo de texto do elemento é válido de acordo com seu tipo de dados para elementos com conteúdo simples e verifica se o conteúdo do elemento atual está completo para elementos com conteúdo complexo. |
| SkipToEndElement | Ignora a validação do conteúdo do elemento atual e prepara o objeto para validar o XmlSchemaValidator conteúdo no contexto do elemento pai. |
| EndValidation | Termina a validação e verifica as restrições de identidade para todo o documento XML se a ProcessIdentityConstraints opção de validação estiver definida. |
Nota
A XmlSchemaValidator classe tem uma transição de estado definida que impõe a sequência e a ocorrência de chamadas feitas para cada um dos métodos descritos na tabela anterior. A transição de estado específica da XmlSchemaValidator classe é descrita na seção "XmlSchemaValidator State Transition" deste tópico.
Para obter um exemplo dos métodos usados para validar elementos, atributos e conteúdo em um infoset XML, consulte o exemplo na seção anterior. Para obter mais informações sobre esses métodos, consulte a documentação de referência de XmlSchemaValidator classe.
Validando conteúdo usando um XmlValueGetter
O XmlValueGetterdelegate pode ser usado para passar o valor de atributo, texto ou nós de espaço em branco como um Common Language Runtime (CLR) tipos compatíveis com o tipo XSD (XML Schema Definition Language) do atributo, texto ou nó de espaço em branco. Um XmlValueGetterdelegate é útil se o valor CLR de um atributo, texto ou nó de espaço em branco já estiver disponível e evita o custo de convertê-lo em um string e, em seguida, repará-lo novamente para validação.
Os ValidateAttributemétodos , ValidateText, e estão sobrecarregados e aceitam o valor de atributo, texto ou ValidateWhitespace nós de espaço em branco como um string ou XmlValueGetterdelegate.
Os seguintes métodos da XmlSchemaValidator classe aceitam um XmlValueGetterdelegate como um parâmetro.
A seguir está um exemplo XmlValueGetterdelegate retirado do XmlSchemaValidator exemplo de classe na introdução. O XmlValueGetterdelegate retorna o valor de um atributo como um DateTime objeto. Para validar esse DateTime objeto retornado pelo XmlValueGetter, o XmlSchemaValidator objeto primeiro o converte para o ValueType (ValueType é o mapeamento CLR padrão para o tipo XSD) para o tipo de dados do atributo e, em seguida, verifica facetas no valor convertido.
Shared dateTimeGetterContent As Object
Shared Function DateTimeGetterHandle() As Object
Return dateTimeGetterContent
End Function
Shared Function DateTimeGetter(dateTime As DateTime) As XmlValueGetter
dateTimeGetterContent = dateTime
Return New XmlValueGetter(AddressOf DateTimeGetterHandle)
End Function
static object dateTimeGetterContent;
static object DateTimeGetterHandle()
{
return dateTimeGetterContent;
}
static XmlValueGetter DateTimeGetter(DateTime dateTime)
{
dateTimeGetterContent = dateTime;
return new XmlValueGetter(dateTimeGetterHandle);
}
Para obter um exemplo completo do XmlValueGetterdelegate, veja o exemplo na introdução. Para obter mais informações sobre o XmlValueGetterdelegate, consulte a documentação de referência de XmlValueGetterclasse e XmlSchemaValidator , .
Pós-esquema-validação-informações
A XmlSchemaInfo classe representa algumas das Post-Schema-Validation-Information de um nó XML validado pela XmlSchemaValidator classe. Vários métodos da XmlSchemaValidator classe aceitam um XmlSchemaInfo objeto como um parâmetro opcional, (null). out
Após a validação bem-sucedida, as XmlSchemaInfo propriedades do objeto são definidas com os resultados da validação. Por exemplo, após a validação bem-sucedida de um atributo usando o ValidateAttribute método, as XmlSchemaInfo propriedades do objeto (se especificado) SchemaAttribute, SchemaType, MemberType, e Validity são definidas com os resultados da validação.
XmlSchemaValidator Os seguintes métodos de classe aceitam um XmlSchemaInfo objeto como um parâmetro out.
Para obter um exemplo completo da XmlSchemaInfo classe, consulte o exemplo na introdução. Para obter mais informações sobre a XmlSchemaInfo classe, consulte a documentação de referência da XmlSchemaInfo classe.
Recuperando partículas esperadas, atributos e atributos padrão não especificados
A XmlSchemaValidator classe fornece os GetExpectedAttributesmétodos , GetExpectedParticlese para recuperar as partículas, atributos e GetUnspecifiedDefaultAttributes atributos padrão não especificados esperados no contexto de validação atual.
Recuperando partículas esperadas
O GetExpectedParticles método retorna uma matriz de objetos contendo as partículas esperadas XmlSchemaParticle no contexto do elemento atual. As partículas válidas que podem ser retornadas pelo GetExpectedParticles método são instâncias das XmlSchemaElement classes e XmlSchemaAny .
Quando o compositor para o modelo de conteúdo é um xs:sequence, apenas a próxima partícula na sequência é retornada. Se o compositor para o modelo de conteúdo for um xs:all ou um xs:choice, todas as partículas válidas que poderiam seguir no contexto do elemento atual serão retornadas.
Nota
Se o GetExpectedParticles método é chamado imediatamente após chamar o Initialize método, o GetExpectedParticles método retorna todos os elementos globais.
Por exemplo, no esquema XSD (XML Schema Definition Language) e no documento XML que se seguem, depois de validar o book elemento, o book elemento é o contexto do elemento atual. O GetExpectedParticles método retorna uma matriz contendo um único XmlSchemaElement objeto que representa o title elemento. Quando o contexto de validação é o title elemento , o GetExpectedParticles método retorna uma matriz vazia. Se o GetExpectedParticles método for chamado depois que o title elemento tiver sido validado, mas antes que o description elemento tenha sido validado, ele retornará uma matriz contendo um único XmlSchemaElement objeto que representa o description elemento. Se o GetExpectedParticles método for chamado depois que o description elemento tiver sido validado, ele retornará uma matriz contendo um único XmlSchemaAny objeto que representa o curinga.
Dim reader As XmlReader = XmlReader.Create("input.xml")
Dim schemaSet As New XmlSchemaSet()
schemaSet.Add(Nothing, "schema.xsd")
Dim manager As New XmlNamespaceManager(reader.NameTable)
Dim validator As New XmlSchemaValidator(reader.NameTable,schemaSet,manager,XmlSchemaValidationFlags.None)
validator.Initialize()
validator.ValidateElement("book", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
For Each element As XmlSchemaElement In validator.GetExpectedParticles()
Console.WriteLine(element.Name)
Next
validator.ValidateElement("title", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
For Each element As XmlSchemaElement In validator.GetExpectedParticles()
Console.WriteLine(element.Name)
Next
validator.ValidateEndElement(Nothing)
For Each element As XmlSchemaElement In validator.GetExpectedParticles()
Console.WriteLine(element.Name)
Next
validator.ValidateElement("description", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
validator.ValidateEndElement(Nothing)
For Each particle As XmlSchemaParticle In validator.GetExpectedParticles()
Console.WriteLine(particle.GetType())
Next
validator.ValidateElement("namespace", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
validator.ValidateEndElement(Nothing)
validator.ValidateEndElement(Nothing)
XmlReader reader = XmlReader.Create("input.xml");
var schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "schema.xsd");
var manager = new XmlNamespaceManager(reader.NameTable);
var validator = new XmlSchemaValidator(reader.NameTable, schemaSet, manager, XmlSchemaValidationFlags.None);
validator.Initialize();
validator.ValidateElement("book", "", null);
validator.ValidateEndOfAttributes(null);
foreach (XmlSchemaElement element in validator.GetExpectedParticles())
{
Console.WriteLine(element.Name);
}
validator.ValidateElement("title", "", null);
validator.ValidateEndOfAttributes(null);
foreach (XmlSchemaElement element in validator.GetExpectedParticles())
{
Console.WriteLine(element.Name);
}
validator.ValidateEndElement(null);
foreach (XmlSchemaElement element in validator.GetExpectedParticles())
{
Console.WriteLine(element.Name);
}
validator.ValidateElement("description", "", null);
validator.ValidateEndOfAttributes(null);
validator.ValidateEndElement(null);
foreach (XmlSchemaParticle particle in validator.GetExpectedParticles())
{
Console.WriteLine(particle.GetType());
}
validator.ValidateElement("namespace", "", null);
validator.ValidateEndOfAttributes(null);
validator.ValidateEndElement(null);
validator.ValidateEndElement(null);
O exemplo usa o seguinte XML como entrada:
<xs:schema xmlns:xs="http://www.w3c.org/2001/XMLSchema">
<xs:element name="book">
<xs:sequence>
<xs:element name="title" type="xs:string" />
<xs:element name="description" type="xs:string" />
<xs:any processContent="lax" maxOccurs="unbounded" />
</xs:sequence>
</xs:element>
</xs:schema>
O exemplo usa o seguinte esquema XSD como entrada:
<book>
<title>My Book</title>
<description>My Book's Description</description>
<namespace>System.Xml.Schema</namespace>
</book>
Nota
Os resultados do GetExpectedParticles, GetExpectedAttributese AddSchema os métodos da XmlSchemaValidator classe dependem do contexto atual que está sendo validado. Para obter mais informações, consulte a seção "Contexto de validação" deste tópico.
Para obter um exemplo do GetExpectedParticles método, consulte o exemplo na introdução. Para obter mais informações sobre o GetExpectedParticles método, consulte a documentação de referência de XmlSchemaValidator classe.
Recuperando atributos esperados
O GetExpectedAttributes método retorna uma matriz de XmlSchemaAttribute objetos contendo os atributos esperados no contexto do elemento atual.
Por exemplo, no exemplo na introdução, o GetExpectedAttributes método é usado para recuperar todos os atributos do book elemento .
Se você chamar o GetExpectedAttributes método imediatamente após o ValidateElement método, todos os atributos que podem aparecer no documento XML são retornados. No entanto, se você chamar o GetExpectedAttributes método após uma ou mais chamadas para o ValidateAttribute método, os atributos que ainda não foram validados para o elemento atual serão retornados.
Nota
Os resultados do GetExpectedParticles, GetExpectedAttributese AddSchema os métodos da XmlSchemaValidator classe dependem do contexto atual que está sendo validado. Para obter mais informações, consulte a seção "Contexto de validação" deste tópico.
Para obter um exemplo do GetExpectedAttributes método, consulte o exemplo na introdução. Para obter mais informações sobre o GetExpectedAttributes método, consulte a documentação de referência de XmlSchemaValidator classe.
Recuperando atributos padrão não especificados
O GetUnspecifiedDefaultAttributes método preenche o ArrayList especificado com XmlSchemaAttribute objetos para quaisquer atributos com valores padrão que não foram validados anteriormente usando o ValidateAttribute método no contexto do elemento. O GetUnspecifiedDefaultAttributes método deve ser chamado depois de chamar o ValidateAttribute método em cada atributo no contexto do elemento. O GetUnspecifiedDefaultAttributes método deve ser usado para determinar quais atributos padrão devem ser inseridos no documento XML que está sendo validado.
Para obter mais informações sobre o GetUnspecifiedDefaultAttributes método, consulte a documentação de referência de XmlSchemaValidator classe.
Manipulando eventos de validação de esquema
Os avisos de validação de esquema e os erros encontrados durante a ValidationEventHandler validação são manipulados pelo evento da XmlSchemaValidator classe.
Os avisos de validação de esquema têm um XmlSeverityType valor de e os erros de validação de Warning esquema têm um XmlSeverityType valor de Error. Se nenhum ValidationEventHandler tiver sido atribuído, um XmlSchemaValidationException será lançado para todos os erros de validação de esquema com um XmlSeverityType valor de Error. No entanto, um XmlSchemaValidationException não é lançado para avisos de validação de esquema com um XmlSeverityType valor de Warning.
A seguir está um exemplo de um ValidationEventHandler que recebe avisos de validação de esquema e erros encontrados durante a validação de esquema retirados do exemplo na introdução.
Shared Sub SchemaValidationEventHandler(sender As Object, e As ValidationEventArgs)
Select Case e.Severity
Case XmlSeverityType.Error
Console.WriteLine(vbCrLf & "Error: {0}", e.Message)
Exit Sub
Case XmlSeverityType.Warning
Console.WriteLine(vbCrLf & "Warning: {0}", e.Message)
Exit Sub
End Select
End Sub
static void SchemaValidationEventHandler(object sender, ValidationEventArgs e)
{
switch (e.Severity)
{
case XmlSeverityType.Error:
Console.WriteLine("\nError: {0}", e.Message);
break;
case XmlSeverityType.Warning:
Console.WriteLine("\nWarning: {0}", e.Message);
break;
}
}
Para obter um exemplo completo do ValidationEventHandler, veja o exemplo na introdução. Para obter mais informações, consulte a documentação de referência de XmlSchemaInfo classe.
Transição de estado de XmlSchemaValidator
A XmlSchemaValidator classe tem uma transição de estado definida que impõe a sequência e a ocorrência de chamadas feitas para cada um dos métodos usados para validar elementos, atributos e conteúdo em um infoset XML.
A tabela a seguir descreve a XmlSchemaValidator transição de estado da classe e a sequência e ocorrência de chamadas de método que podem ser feitas em cada estado.
| Estado | Transition |
|---|---|
| Validar | InitializeValidateAttribute ( | Nível Superior*)EndValidation |
| Nível Superior | ValidateWhitespace | ValidateText | Elemento |
| Elemento | ValidateElementValidateAttribute* (ValidateEndOfAttributes Conteúdo*)? ValidateEndElement | ValidateElement ValidateAttribute* SkipToEndElement | ValidateElementValidateAttribute* ValidateEndOfAttributes Conteúdo*SkipToEndElement | |
| Conteúdo | ValidateWhitespace | ValidateText | Elemento |
Nota
Um é lançado por cada um InvalidOperationException dos métodos na tabela acima quando a chamada para o método é feita na sequência incorreta de acordo com o estado atual de um XmlSchemaValidator objeto.
A tabela de transição de estado acima usa símbolos de pontuação para descrever os métodos e outros estados que podem ser chamados para cada estado da transição de estado da XmlSchemaValidator classe. Os símbolos usados são os mesmos símbolos encontrados na referência de padrões XML para definição de tipo de documento (DTD).
A tabela a seguir descreve como os símbolos de pontuação encontrados na tabela de transição de estado acima afetam os métodos e outros estados que podem ser chamados para cada estado na transição de estado da XmlSchemaValidator classe.
| Símbolo | Description |
|---|---|
| | | Qualquer método ou estado (o anterior à barra ou o posterior) pode ser chamado. |
| ? | O método ou estado que precede o ponto de interrogação é opcional, mas se for chamado só pode ser chamado uma vez. |
| * | O método ou estado que precede o símbolo * é opcional e pode ser chamado mais de uma vez. |
Contexto de validação
Os métodos da XmlSchemaValidator classe usada para validar elementos, atributos e conteúdo em um infoset XML, alteram o contexto de validação de um XmlSchemaValidator objeto. Por exemplo, o SkipToEndElement método ignora a validação do conteúdo do elemento atual e prepara o objeto para validar o XmlSchemaValidator conteúdo no contexto do elemento pai, o que equivale a ignorar a validação para todos os filhos do elemento atual e, em seguida, chamar o ValidateEndElement método.
Os resultados do GetExpectedParticles, GetExpectedAttributese AddSchema os métodos da XmlSchemaValidator classe dependem do contexto atual que está sendo validado.
A tabela a seguir descreve os resultados da chamada desses métodos depois de chamar um dos métodos da XmlSchemaValidator classe usada para validar elementos, atributos e conteúdo em um infoset XML.
| Método | GetExpectedParticles | GetExpectedAttributes | AddSchema |
|---|---|---|---|
| Initialize | Se o método padrão Initialize for chamado, GetExpectedParticles retornará uma matriz contendo todos os elementos globais. Se o método sobrecarregado Initialize que usa um XmlSchemaObject parâmetro as é chamado para inicializar a validação parcial de um elemento, GetExpectedParticles retorna apenas o elemento para o qual o XmlSchemaValidator objeto foi inicializado. |
Se o método padrão Initialize for chamado, GetExpectedAttributes retornará uma matriz vazia. Se a sobrecarga do Initialize método que usa um XmlSchemaObject parâmetro as for chamada para inicializar a validação parcial de um atributo, GetExpectedAttributes retornará somente o atributo ao qual o XmlSchemaValidator objeto foi inicializado. |
Adiciona o esquema ao XmlSchemaSet do objeto se ele não tiver erros de XmlSchemaValidator pré-processamento. |
| ValidateElement | Se o elemento context for válido, GetExpectedParticles retornará a sequência de elementos esperados como filhos do elemento context. Se o elemento de contexto for inválido, GetExpectedParticles retornará uma matriz vazia. |
Se o elemento context for válido e se nenhuma chamada tiver ValidateAttribute sido feita anteriormente, GetExpectedAttributes retornará uma lista de todos os atributos definidos no elemento context. Se alguns atributos já tiverem sido validados, GetExpectedAttributes retornará uma lista dos atributos restantes a serem validados. Se o elemento de contexto for inválido, GetExpectedAttributes retornará uma matriz vazia. |
Mesmo que acima. |
| ValidateAttribute | Se o atributo context for um atributo de nível superior, GetExpectedParticles retornará uma matriz vazia. Caso contrário, GetExpectedParticles retorna a sequência de elementos esperados como o primeiro filho do elemento context. |
Se o atributo context for um atributo de nível superior, GetExpectedAttributes retornará uma matriz vazia. Caso contrário, GetExpectedAttributes retorna a lista de atributos restantes a serem validados. |
Mesmo que acima. |
| GetUnspecifiedDefaultAttributes | GetExpectedParticles Retorna a sequência de elementos esperados como o primeiro filho do elemento context. | GetExpectedAttributes Retorna uma lista dos atributos obrigatórios e opcionais que ainda precisam ser validados para o elemento context. | Mesmo que acima. |
| ValidateEndOfAttributes | GetExpectedParticles Retorna a sequência de elementos esperados como o primeiro filho do elemento context. | GetExpectedAttributes Retorna uma matriz vazia. | Mesmo que acima. |
| ValidateText | Se o contentType do elemento de contexto for Mixed, GetExpectedParticles retornará a sequência de elementos esperada na próxima posição. Se o contentType do elemento de contexto for TextOnly ou Empty, GetExpectedParticles retornará uma matriz vazia. Se o contentType do elemento de contexto for ElementOnly, retornará a sequência de elementos esperada na próxima posição, GetExpectedParticles mas já ocorreu um erro de validação. |
GetExpectedAttributes Retorna a lista de atributos não validados do elemento de contexto. | Mesmo que acima. |
| ValidateWhitespace | Se o espaço em branco do contexto for espaço em branco de nível superior, GetExpectedParticles retornará uma matriz vazia. Caso contrário, o GetExpectedParticles comportamento do método é o mesmo que em ValidateText. |
Se o espaço em branco do contexto for espaço em branco de nível superior, GetExpectedAttributes retornará uma matriz vazia. Caso contrário, o GetExpectedAttributes comportamento do método é o mesmo que em ValidateText. |
Mesmo que acima. |
| ValidateEndElement | GetExpectedParticles Devolve a sequência de elementos esperada após o elemento de contexto (possíveis irmãos). | GetExpectedAttributes Retorna a lista de atributos não validados do elemento de contexto. Se o elemento de contexto não tiver pai, retornará GetExpectedAttributes uma lista vazia (o elemento de contexto é o pai do elemento atual no qual ValidateEndElement foi chamado). |
Mesmo que acima. |
| SkipToEndElement | O mesmo que ValidateEndElement. | O mesmo que ValidateEndElement. | Mesmo que acima. |
| EndValidation | Retorna uma matriz vazia. | Retorna uma matriz vazia. | Mesmo que acima. |
Nota
Os valores retornados pelas várias propriedades da XmlSchemaValidator classe não são alterados chamando qualquer um dos métodos na tabela acima.
