XmlSchemaValidator Envio- de validação

A classe de XmlSchemaValidator fornece um mecanismo eficiente, de alto desempenho validar dados XML com esquemas XML de uma maneira envio- base. Por exemplo, a classe XmlSchemaValidator permite que você valide um conjunto de informações XML no local, sem precisar serializá-lo como um documento XML e, em seguida, reprocessar o documento usando um leitor XML validador.

A XmlSchemaValidator classe pode ser usada em cenários avançados, como a criação de mecanismos de validação em fontes de dados XML personalizadas ou como uma forma de criar um gravador XML de validação.

A seguir, é apresentado um exemplo de uso da XmlSchemaValidator classe para validar o contosoBooks.xml arquivo contra o 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.

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: '{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 '{schemaInfo.SchemaElement.Name}' with type '{schemaInfo.SchemaType}' is '{schemaInfo.Validity}'");
            }
            else if (schemaInfo.SchemaAttribute != null)
            {
                Console.WriteLine($"Attribute '{schemaInfo.SchemaAttribute.Name}' with type '{schemaInfo.SchemaType}' is '{schemaInfo.Validity}'");
            }
        }

        static void SchemaValidationEventHandler(object sender, ValidationEventArgs e)
        {
            switch (e.Severity)
            {
                case XmlSeverityType.Error:
                    Console.WriteLine($"\nError: {e.Message}");
                    break;
                case XmlSeverityType.Warning:
                    Console.WriteLine($"\nWarning: {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 contosoBooks.xsd como parte da 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 conjunto de informações XML, primeiro você deve inicializar uma nova instância da XmlSchemaValidator classe usando o XmlSchemaValidator construtor.

O XmlSchemaValidator construtor usa XmlNameTable, XmlSchemaSete 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 ParseValue método ao validar conteúdo simples. O XmlSchemaSet objeto contém os esquemas XML usados para validar o conjunto de informações XML. O XmlNamespaceManager objeto é usado para resolver namespaces encontrados durante a validação. O XmlSchemaValidationFlags valor é usado para desabilitar determinados recursos de validação.

Para obter mais informações sobre o construtor XmlSchemaValidator, consulte a documentação de referência da classe XmlSchemaValidator.

Inicializando a validação

Depois que um XmlSchemaValidator objeto é construído, há dois métodos sobrecarregados Initialize usados para inicializar o estado do XmlSchemaValidator objeto. Estes são os dois métodos de Initialize .

• XmlSchemaValidator.Initialize

• XmlSchemaValidator.Initialize

O método padrão XmlSchemaValidator.Initialize inicializa um XmlSchemaValidator objeto para seu estado inicial e o método sobrecarregado XmlSchemaValidator.Initialize que usa um XmlSchemaObject parâmetro 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 a construção de um XmlSchemaValidator objeto 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 usa um XmlSchemaObject parâmetro como um inicializa um XmlSchemaValidator objeto para 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 elemento do esquema de orderNumber é passado selecionando o elemento de esquema por XmlQualifiedName na coleção de XmlSchemaObjectTable retornada pela propriedade de GlobalElements do objeto de XmlSchemaSet . O objeto XmlSchemaValidator em seguida 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 método de AddSchema da classe de XmlSchemaValidator é usado para adicionar um esquema XML para o 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 conjunto de informações XML que está sendo validado.

O resultado de método AddSchema é dependente no contexto atual do nó XML que está sendo validada. 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 conjunto de informações XML contra esquemas XML. A tabela a seguir descreve cada um desses métodos.

Para obter um exemplo dos métodos usados para validar elementos, atributos e conteúdo em um conjunto de informações 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

XmlValueGetter delegate pode ser usado para passar o valor do atributo, texto, ou de nós de espaço em branco como o Common Language Runtime (CLR) tipos compatível com o tipo de idioma de XSD (XSD) de atributo, texto, ou o nó de espaço em branco. XmlValueGetter delegate é útil se o valor de CLR de um atributo, um texto, ou um nó de espaço em branco já estiver disponível, e evita o custo de convertê-los em string e dos reparsing novamente para validação.

ValidateAttribute, ValidateText, e os métodos de ValidateWhitespace são sobrecarregados e aceitar o valor do atributo, texto, ou de nós de espaço em branco como string ou XmlValueGetterdelegate.

Os métodos a seguir da XmlSchemaValidator classe aceitam um XmlValueGetterdelegate parâmetro como um parâmetro.

• ValidateAttribute

• ValidateText

• ValidateWhitespace

Veja a seguir um exemplo XmlValueGetterdelegate retirado do exemplo de classe XmlSchemaValidator na introdução. O XmlValueGetterdelegate retorna o valor de um atributo como um DateTime objeto. Para validar este objeto de DateTime retornado por XmlValueGetter, converte o objeto de XmlSchemaValidator ele para o primeiro ValueType (ValueType é CLR padrão que mapeia para o tipo XSD) para o tipo de dados de atributo e então verifica facetas o 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, consulte a seção de introdução. Para obter mais informações sobre XmlValueGetterdelegate, consulte XmlValueGetter e a documentação de referência da classe XmlSchemaValidator.

POST-Esquema-Validação-informações

A classe de XmlSchemaInfo representa algumas de POST-Esquema-Validação- informações de um nó XML validado pela classe de XmlSchemaValidator . 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, as propriedades XmlSchemaInfo, SchemaAttribute, SchemaType e MemberType do objeto Validity (se especificado) são definidas com os resultados da validação.

Os seguintes métodos de classe XmlSchemaValidator aceitam um objeto XmlSchemaInfo como parâmetro de saída.

• SkipToEndElement

• ValidateAttribute

• ValidateAttribute

• ValidateElement

• ValidateElement

• ValidateEndElement

• ValidateEndElement

• ValidateEndOfAttributes

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 de XmlSchemaInfo classe.

Recuperando partículas esperadas, atributos esperados e atributos padrão não especificados

A classe XmlSchemaValidator fornece os métodos GetExpectedAttributes, GetExpectedParticles e GetUnspecifiedDefaultAttributes para recuperar as partículas esperadas, os atributos e os atributos padrão não especificados no contexto de validação atual.

Recuperando partículas previstas

O GetExpectedParticles método retorna uma matriz de XmlSchemaParticle objetos que contém as partículas esperadas no contexto do elemento atual. As partículas válidas que podem ser retornadas pelo método GetExpectedParticles são instâncias das classes XmlSchemaElement e XmlSchemaAny.

Quando o compositor do modelo de conteúdo é um xs:sequence, somente a próxima partícula na sequência é retornada. Se o compositor do modelo de conteúdo for um xs:all ou um xs:choice, todas as partículas válidas que podem seguir no contexto do elemento atual serão retornadas.

Por exemplo, no esquema XSD (Linguagem de Definição de Esquema XML) e no documento XML a seguir, depois de validar o book elemento, o book elemento é o contexto do elemento atual. O GetExpectedParticles método retorna uma matriz que contém 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 do description elemento ter sido validado, ele retornará uma matriz que contém um único XmlSchemaElement objeto que representa o description elemento. Se o GetExpectedParticles método for chamado após a validação do description elemento, ele retornará uma matriz que contém 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>

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 que contém 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 serã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.

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 e os erros de validação de esquema encontrados durante a validação são tratadas pelo evento de ValidationEventHandler da classe de XmlSchemaValidator .

Os avisos de validação de esquema têm um valor de XmlSeverityType de Warning e os erros de validação de esquema têm um valor de XmlSeverityType de Error. Se nenhum ValidationEventHandler foi atribuído, XmlSchemaValidationException é acionada para todos os erros de validação de esquema com um valor de XmlSeverityType de Error. No entanto, XmlSchemaValidationException não é lançada para avisos de validação de esquema com um valor de XmlSeverityType de Warning.

Veja a seguir um exemplo de um ValidationEventHandler que recebe avisos de validação de esquema e erros encontrados durante a validação do esquema obtidos 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, consulte a introdução. Para obter mais informações, consulte a documentação de referência de XmlSchemaInfo classe.

Transição de estado do XmlSchemaValidator

A XmlSchemaValidator classe tem uma transição de estado definida que impõe a sequência e a ocorrência de chamadas feitas a cada um dos métodos usados para validar elementos, atributos e conteúdo em um conjunto de informações XML.

A tabela a seguir descreve a transição de estado da XmlSchemaValidator classe e a sequência e a ocorrência de chamadas de método que podem ser feitas em cada estado.

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 XML Standards para DTD (Definição de Tipo de Documento).

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.

Contexto de validação

Os métodos da XmlSchemaValidator classe usados para validar elementos, atributos e conteúdo em um conjunto de informações 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 XmlSchemaValidator objeto para validar o conteúdo no contexto do elemento pai; ele é equivalente a ignorar a validação para todos os filhos do elemento atual e, em seguida, chamar o ValidateEndElement método.

Os resultados de GetExpectedParticles, GetExpectedAttributese AddSchema métodos da XmlSchemaValidator classe dependem do contexto atual que está sendo validado.

A tabela a seguir descreve os resultados de chamar esses métodos depois de chamar um dos métodos da XmlSchemaValidator classe usados para validar elementos, atributos e conteúdo em um conjunto de informações XML.

Consulte também

• XmlSchemaValidator