Compartilhar via

XmlSchemaValidator Envio- de validação

  • Artigo

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 de XmlSchemaValidator permite que você valide um infoset XML no local sem ter que para serializá-lo como um documento XML e então um nova análise o documento usando um leitor validando XML.

A classe de XmlSchemaValidator pode ser usada em cenários avançados como mecanismos de validação de compilação sobre fontes de dados XML personalizados ou como uma maneira de criar um gravador validando XML.

A seguir está um exemplo de uso da classe de XmlSchemaValidator para validar o arquivo de contosoBooks.xml com o esquema de contosoBooks.xsd . O exemplo usa a classe de XmlSerializer para desserializar o arquivo de contosoBooks.xml e passar o valor de nós métodos de classe de XmlSchemaValidator .

Observação

Este exemplo é usado em todo as 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 arquivo contosoBooks.xml 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 usa contosoBooks.xsd como 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 iniciar a validar um infoset XML, primeiro você deve inicializar uma nova instância da classe XmlSchemaValidator que usa o construtor de XmlSchemaValidator .

O construtor de XmlSchemaValidator leva XmlNameTable, XmlSchemaSet, e objetos de XmlNamespaceManager como os parâmetros bem como XmlSchemaValidationFlags avaliada como um parâmetro. O objeto de XmlNameTable é usado para atomizar cadeias de caracteres conhecidos de namespace como o namespace do esquema, o namespace XML, e assim por diante, e passado para o método de ParseValue para validar o conteúdo simples. O objeto de XmlSchemaSet contém os esquemas XML usados para validar o infoset XML. O objeto de XmlNamespaceManager é usado para resolver namespaces encontrados durante a validação. O valor de XmlSchemaValidationFlags é usado para desativar determinados recursos de validação.

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

Inicializando a validação

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

O método de XmlSchemaValidator.Initialize de opção inicializa um objeto de XmlSchemaValidator ao seu estado inicial, e o método sobrecarregado de XmlSchemaValidator.Initialize que leva XmlSchemaObject como um parâmetro inicializa um objeto de XmlSchemaValidator ao seu estado inicial para a validação parcial.

Ambos os métodos de Initialize só podem ser chamados imediatamente após um objeto de XmlSchemaValidator foi construído ou após uma chamada a EndValidation.

Para um exemplo de método XmlSchemaValidator.Initialize , consulte o exemplo na introdução. Para obter mais informações sobre o método de Initialize , consulte a documentação de referência da classe XmlSchemaValidator .

Validação parcial

O método de XmlSchemaValidator.Initialize que leva XmlSchemaObject como um parâmetro inicializa um objeto de XmlSchemaValidator ao seu estado inicial para a validação parcial.

No exemplo a seguir, XmlSchemaObject é inicializado para validação usando o método parcial de XmlSchemaValidator.Initialize . 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 de XmlSchemaValidator valida neste 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 a seguir usa o 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 método de Initialize , consulte a documentação de referência da classe XmlSchemaValidator .

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 método de AddSchema pode ser usado para simular o efeito de localizar um esquema XML embutido no infoset XML que está sendo validada.

Observação

O namespace de destino do parâmetro de XmlSchema pode não corresponder de qualquer elemento ou atributo já encontrado pelo objeto de XmlSchemaValidator .

Se o valor de XmlSchemaValidationFlags.ProcessInlineSchema não foi passado como um parâmetro para o construtor de XmlSchemaValidator , o método de AddSchema não fará nada.

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 validação” neste tópico.

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

Validando elementos, atributos, e conteúdo

A classe de XmlSchemaValidator fornece vários métodos usados para validar elementos, atributos, e o conteúdo em um infoset XML com esquemas XML. A tabela a seguir descreve cada um desses métodos.

Método Descrição
ValidateElement Valida o nome do elemento no contexto atual.
ValidateAttribute Valida o atributo no contexto do elemento atual ou contra o objeto de XmlSchemaAttribute passado como um parâmetro para o método de Initialize .
ValidateEndOfAttributes Verifica se todos os atributos necessários no contexto do elemento entram presente e prepara o objeto de XmlSchemaValidator 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 tem 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álida de acordo com seu tipo de dados para elementos com conteúdo simples, e verifica se o conteúdo do elemento atual seja concluída para elementos com conteúdo complexo.
SkipToEndElement Ignora a validação de conteúdo do elemento atual e prepara o objeto de XmlSchemaValidator para validar o conteúdo no contexto do elemento pai.
EndValidation Termina a validação verifica e restrições de identidade para o documento inteiro XML se a opção de validação de ProcessIdentityConstraints é definida.

Observação

A classe de XmlSchemaValidator tiver definido uma transição de estado que aplica a sequência e a ocorrência de chamadas feitas a cada um dos métodos descritos na tabela anterior. A transição específica do estado da classe de XmlSchemaValidator é descrita da seção “de transição de estado XmlSchemaValidator” neste tópico.

Para um exemplo dos métodos usados para validar elementos, atributos, e o conteúdo em um infoset XML, consulte o exemplo na seção anterior. Para obter mais informações sobre estes métodos, consulte a documentação de referência da classe XmlSchemaValidator .

Validando conteúdo usando um XmlValueGetter

XmlValueGetterdelegate 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. XmlValueGetterdelegate é ú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 seguintes métodos da classe XmlSchemaValidator aceitam XmlValueGetterdelegate como um parâmetro.

A seguir está um exemplo XmlValueGetterdelegate extraído do exemplo de classe de XmlSchemaValidator na introdução. XmlValueGetterdelegate retorna o valor de um atributo como um objeto de DateTime . 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 um exemplo completo de XmlValueGetterdelegate, consulte o exemplo na introdução. Para obter mais informações sobre XmlValueGetter de delegate, consulte XmlValueGetter, e 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 . Os vários métodos da classe XmlSchemaValidator aceitar um objeto de XmlSchemaInfo como um opcional), (nullparâmetro de out .

Em cima de validação com êxito, as propriedades do objeto de XmlSchemaInfo são definidas com os resultados de validação. Por exemplo, em cima de validação com êxito de um atributo usando o método de ValidateAttribute , XmlSchemaInfodo objeto de SchemaAttribute (se especificado), SchemaType, MemberType, e as propriedades de Validity são especificados com os resultados de validação.

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

Para um exemplo completo da classe de XmlSchemaInfo , consulte o exemplo na introdução. Para obter mais informações sobre a classe de XmlSchemaInfo , consulte a documentação de referência da classe XmlSchemaInfo .

Recuperando partículas previstas, atributos, e atributos padrão não especificado

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

Recuperando partículas previstas

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

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

Observação

Se o método de GetExpectedParticles é chamado imediatamente depois de chamar o método de Initialize , o método de GetExpectedParticles retorna todos os elementos globais.

Por exemplo, no esquema e o documento XML de idioma de XSD (XSD) que seguem, após validar o elemento de book , o elemento de book é o contexto do elemento atual. O método de GetExpectedParticles retorna uma matriz que contém um único objeto de XmlSchemaElement que representa o elemento de title . Quando o contexto de validação é o elemento de title , o método de GetExpectedParticles retorna uma matriz vazia. Se o método de GetExpectedParticles é chamado depois que o elemento de title foi validado mas antes do elemento de description está validado, retorna uma matriz que contém um único objeto de XmlSchemaElement que representa o elemento de description . Se o método de GetExpectedParticles é chamado depois que o elemento de description já foi validado então retorna uma matriz que contém um único objeto de XmlSchemaAny que representa a 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 a seguir usa 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 a seguir usa o esquema XSD como entrada:

<book>
  <title>My Book</title>
  <description>My Book's Description</description>
  <namespace>System.Xml.Schema</namespace>
</book>

Observação

Os resultados de GetExpectedParticles, de GetExpectedAttributes, e métodos de AddSchema da classe de XmlSchemaValidator são dependentes no contexto atual sendo validada. Para obter mais informações, consulte a seção contexto validação” neste tópico.

Para um exemplo de método GetExpectedParticles , consulte o exemplo na introdução. Para obter mais informações sobre o método de GetExpectedParticles , consulte a documentação de referência da classe XmlSchemaValidator .

Recuperando atributos esperados

O método de GetExpectedAttributes retorna uma matriz de objetos de XmlSchemaAttribute que contêm os atributos esperados no contexto do elemento atual.

Por exemplo, no exemplo na introdução, o método de GetExpectedAttributes é usado para recuperar todos os atributos do elemento de book .

Se você chamar o método de GetExpectedAttributes imediatamente após o método de ValidateElement , todos os atributos que podem aparecer no documento XML são retornados. No entanto, se você chamar o método de GetExpectedAttributes depois que um ou mais chamadas para o método de ValidateAttribute , os atributos que não foram validados ainda para o elemento atual são retornados.

Observação

Os resultados de GetExpectedParticles, de GetExpectedAttributes, e métodos de AddSchema da classe de XmlSchemaValidator são dependentes no contexto atual sendo validada. Para obter mais informações, consulte a seção contexto validação” neste tópico.

Para um exemplo de método GetExpectedAttributes , consulte o exemplo na introdução. Para obter mais informações sobre o método de GetExpectedAttributes , consulte a documentação de referência da classe XmlSchemaValidator .

Recuperando atributos padrão não especificado

O método de GetUnspecifiedDefaultAttributes preenche ArrayList especificado com objetos de XmlSchemaAttribute para todos os atributos com valores padrão que não foram validados anteriormente usando o método de ValidateAttribute no contexto do elemento. O método de GetUnspecifiedDefaultAttributes deve ser chamado após o método chamado de ValidateAttribute em cada atributo no contexto do elemento. O método de GetUnspecifiedDefaultAttributes deve ser usado para determinar quais atributos padrão devem ser inseridos no documento XML que está sendo validada.

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

Eventos de validação do esquema de tratamento

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.

O código a seguir é um exemplo de ValidationEventHandler que receberá os avisos e os erros de validação de esquema encontrados durante a validação de esquema tomada de 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 um exemplo completo de ValidationEventHandler, consulte o exemplo na introdução. Para obter mais informações, consulte a documentação de referência da classe XmlSchemaInfo .

Transição de estado de XmlSchemaValidator

A classe de XmlSchemaValidator tiver definido uma transição de estado que aplica a sequência e a ocorrência de chamadas feitas a cada um dos métodos usados para validar elementos, atributos, e o conteúdo em um infoset XML.

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

Estado Transição
Validar Initialize (ValidateAttribute | TopLevel*) EndValidation
TopLevel ValidateWhitespace | ValidateText | Elemento
Element ValidateElement ValidateAttribute* (ValidateEndOfAttributes Conteúdo*)? ValidateEndElement |

ValidateElement ValidateAttribute* SkipToEndElement |

ValidateElement ValidateAttribute* ValidateEndOfAttributes Conteúdo* SkipToEndElement |
Conteúdo ValidateWhitespace | ValidateText | Elemento

Observação

InvalidOperationException é acionada por cada um dos métodos na tabela acima quando a chamada para o método é feito na sequência incorreta de acordo com o estado atual de um objeto de XmlSchemaValidator .

A tabela de transição de estado anterior de símbolos de pontuação usos para descrever os métodos e outros estados que podem ser chamados para cada estado de transição de estado da classe de XmlSchemaValidator . Os símbolos usados são os mesmos símbolos localizados na referência de padrões XML para o Document type definition (DTD).

A tabela a seguir descreve como símbolos de pontuação localizados na tabela de transição de estado anterior afetam os métodos e outros estados que podem ser chamados para cada estado na transição de estado da classe de XmlSchemaValidator .

Símbolo Descrição
| O método ou o estado (aquele antes de barra ou esse após ele) podem ser chamados.
? O método ou indica que antes do ponto de interrogação é opcional mas se é chamado pode ser chamado somente uma vez.
* O método ou indica que precede * o símbolo é opcional, e pode ser chamado mais de uma vez.

Contexto de validação

Os métodos da classe XmlSchemaValidator usada para validar elementos, atributos, e o conteúdo em um infoset XML, alterar o contexto de validação de um objeto de XmlSchemaValidator . Por exemplo, a validação ignora do método de SkipToEndElement de conteúdo do elemento atual e prepara o objeto de XmlSchemaValidator para validar o conteúdo no contexto do elemento pai; é equivalente à validação de ir para todos os filhos do elemento atual e de chamar o método de ValidateEndElement .

Os resultados de GetExpectedParticles, de GetExpectedAttributes, e métodos de AddSchema da classe de XmlSchemaValidator são dependentes no contexto atual sendo validada.

A tabela a seguir descreve os resultados de chamar esses métodos após chamando um dos métodos da classe XmlSchemaValidator usada para validar elementos, atributos, e o conteúdo em um infoset XML.

Método GetExpectedParticles GetExpectedAttributes AddSchema
Initialize Se o método de Initialize padrão é chamado, GetExpectedParticles retorna uma matriz que contém todos os elementos globais.

Se o método sobrecarregado que leva Initialize como um parâmetro é chamado para inicializar a validação parcial de um elemento, XmlSchemaObject de GetExpectedParticles retorna somente o elemento ao qual o objeto de XmlSchemaValidator foi inicializado.		 Se o método de Initialize padrão é chamado, GetExpectedAttributes retorna uma matriz vazia.

Se a sobrecarga de método que usa Initialize como um parâmetro é chamado para inicializar a validação parcial de um atributo, XmlSchemaObject de GetExpectedAttributes retorna somente o atributo para que o objeto de XmlSchemaValidator foi inicializado.		 Adiciona o esquema a XmlSchemaSet do objeto de XmlSchemaValidator se não tem nenhum erro de pré-processamento.
ValidateElement Se o elemento de contexto é válido, GetExpectedParticles retorna a sequência de elementos esperado como filhos do elemento de contexto.

Se o elemento de contexto é inválido, GetExpectedParticles retorna uma matriz vazia.		 Se o elemento de contexto é válido, e se nenhuma chamada a ValidateAttribute tiver sido feito anteriormente, GetExpectedAttributes retorna uma lista de todos os atributos definidos no elemento de contexto.

Se alguns atributos já foram validados, GetExpectedAttributes retorna uma lista dos outros atributos a ser validados.

Se o elemento de contexto é inválido, GetExpectedAttributes retorna uma matriz vazia.		 Mesmo que acima.
ValidateAttribute Se o atributo de contexto é um atributo de nível superior, GetExpectedParticles retorna uma matriz vazia.

Se não GetExpectedParticles retorna a sequência de elementos esperado como o primeiro filho do elemento de contexto.		 Se o atributo de contexto é um atributo de nível superior, GetExpectedAttributes retorna uma matriz vazia.

Se não GetExpectedAttributes retorna a lista dos outros atributos a ser validados.		 Mesmo que acima.
GetUnspecifiedDefaultAttributes GetExpectedParticles retorna a sequência de elementos esperado como o primeiro filho do elemento de contexto. GetExpectedAttributes retorna uma lista de atributos necessários e opcionais que devem ser validados ainda para o elemento de contexto. Mesmo que acima.
ValidateEndOfAttributes GetExpectedParticles retorna a sequência de elementos esperado como o primeiro filho do elemento de contexto. GetExpectedAttributes retorna uma matriz vazia. Mesmo que acima.
ValidateText Se o contentType do elemento de contexto é misturado, GetExpectedParticles retorna a sequência de elementos esperado na próxima posição.

Se o contentType do elemento de contexto é TextOnly ou Empty, GetExpectedParticles retorna uma matriz vazia.

Se o contentType do elemento de contexto é ElementOnly, GetExpectedParticles retorna a sequência de elementos esperado na próxima posição mas um erro de validação tem ocorreu.		 GetExpectedAttributes retorna a lista de elemento do contexto de atributos não validados. Mesmo que acima.
ValidateWhitespace Se o espaço em branco de contexto é o espaço em branco de nível superior, GetExpectedParticles retorna uma matriz vazia.

Se não o comportamento de método GetExpectedParticles é o mesmo que em ValidateText.		 Se o espaço em branco de contexto é o espaço em branco de nível superior, GetExpectedAttributes retorna uma matriz vazia.

Se não o comportamento de método GetExpectedAttributes é o mesmo que em ValidateText.		 Mesmo que acima.
ValidateEndElement GetExpectedParticles retorna a sequência de elementos esperado após o elemento de contexto (irmãos possíveis). GetExpectedAttributes retorna a lista de elemento do contexto de atributos não validados.

Se o elemento de contexto não tem nenhum pai em GetExpectedAttributes retorna uma lista vazia (o elemento de contexto é o pai do elemento atual em ValidateEndElement que foi chamado.)		 Mesmo que acima.
SkipToEndElement Mesmo que ValidateEndElement. Mesmo que ValidateEndElement. Mesmo que acima.
EndValidation Retorna uma matriz vazia. Retorna uma matriz vazia. Mesmo que acima.

Observação

Os valores retornados por várias propriedades da classe de XmlSchemaValidator não são alterados chamando os métodos na tabela anterior.

Confira também