Přímé ověření XmlSchemaValidator

Třída XmlSchemaValidator poskytuje efektivní a vysoce výkonný mechanismus pro ověřování dat XML vůči XML schématům formou aktivního zasílání. Třída například XmlSchemaValidator umožňuje ověřit místní informační sadu XML, aniž byste ji museli serializovat jako dokument XML a pak znovu vytvořit dokument pomocí validující čtečky XML.

Třídu XmlSchemaValidator lze použít v pokročilých scénářích, jako je vytváření ověřovacích modulů přes vlastní zdroje dat XML nebo jako způsob, jak vytvořit validační zapisovač XML.

Následuje příklad použití XmlSchemaValidator třídy k ověření contosoBooks.xml souboru proti schématu contosoBooks.xsd . Příklad používá XmlSerializer třídu k deserializaci contosoBooks.xml souboru a předání hodnoty uzlů metodám XmlSchemaValidator třídy.

Poznámka:

Tento příklad se používá v částech tohoto tématu.

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

Příklad přebírá contosoBooks.xml soubor jako vstup.

<?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>

Příklad také přebírá contosoBooks.xsd jako vstup.

<?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>

Ověřování dat XML pomocí XmlSchemaValidator

Chcete-li začít ověřovat informační sadu XML, musíte nejprve inicializovat novou instanci XmlSchemaValidator třídy pomocí konstruktoru XmlSchemaValidator .

Konstruktor XmlSchemaValidator přebírá XmlNameTable, XmlSchemaSeta XmlNamespaceManager objekty jako parametry a také XmlSchemaValidationFlags hodnotu jako parametr. Objekt XmlNameTable se používá k atomizaci dobře známých řetězců oboru názvů, jako je obor názvů schématu, obor názvů XML atd., a je předán metodě při ověřování jednoduchého ParseValue obsahu. Objekt XmlSchemaSet obsahuje schémata XML použitá k ověření informační sady XML. Objekt XmlNamespaceManager se používá k řešení oborů názvů, které vznikají během ověřování. Hodnota XmlSchemaValidationFlags se používá k zakázání určitých funkcí ověření.

Další informace o konstruktoru XmlSchemaValidator naleznete v referenční dokumentaci k třídě XmlSchemaValidator.

Inicializace ověření

Po vytvoření objektu XmlSchemaValidator existují dvě přetížené Initialize metody, které slouží k inicializaci stavu objektu XmlSchemaValidator . Následují dvě Initialize metody.

• XmlSchemaValidator.Initialize

• XmlSchemaValidator.Initialize

Výchozí XmlSchemaValidator.Initialize metoda inicializuje XmlSchemaValidator objekt do počátečního stavu a přetížená XmlSchemaValidator.Initialize metoda, která přebírá XmlSchemaObject jako parametr inicializuje XmlSchemaValidator objekt do jeho počátečního stavu pro částečné ověření.

Obě Initialize metody lze volat pouze ihned po vytvoření objektu XmlSchemaValidator nebo po volání EndValidation.

Příklad XmlSchemaValidator.Initialize metody najdete v příkladu v úvodu. Další informace o metodě Initialize naleznete v dokumentaci referenční třídy XmlSchemaValidator.

Částečné ověření

Metoda XmlSchemaValidator.Initialize , která přebírá XmlSchemaObject jako parametr inicializuje XmlSchemaValidator objekt do jeho počátečního stavu pro částečné ověření.

V následujícím příkladu XmlSchemaObject je inicializován pro částečné ověření pomocí XmlSchemaValidator.Initialize metody. Prvek orderNumber schématu je předán výběrem prvku XmlQualifiedName schématu v XmlSchemaObjectTable kolekci vrácené GlobalElements vlastností objektu XmlSchemaSet . Objekt XmlSchemaValidator pak ověří tento konkrétní prvek.

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);

V příkladu se jako vstup používá následující schéma XML.

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="orderNumber" type="xs:int" />
</xs:schema>

Další informace o metodě Initialize naleznete v dokumentaci referenční třídy XmlSchemaValidator.

Přidání dalších schémat

Metoda AddSchemaXmlSchemaValidator třídy se používá k přidání schématu XML do sady schémat používaných při ověřování. Metodu AddSchema lze použít k simulaci efektu výskytu vloženého schématu XML v ověřované sadě informací XML.

Poznámka:

Cílový obor názvů parametru XmlSchema se nemůže shodovat s žádným prvkem nebo atributem, který XmlSchemaValidator již objekt zjistil.

XmlSchemaValidationFlags.ProcessInlineSchema Pokud hodnota nebyla předána jako parametr XmlSchemaValidator konstruktoru, AddSchema metoda nic nedělá.

Výsledek AddSchema metody závisí na ověření aktuálního kontextu uzlu XML. Další informace o kontextech ověření najdete v části Kontext ověření v tomto tématu.

Další informace o metodě AddSchema naleznete v dokumentaci referenční třídy XmlSchemaValidator.

Ověřování elementů, atributů a obsahu

Třída XmlSchemaValidator poskytuje několik metod, které slouží k ověření prvků, atributů a obsahu v informační sadě XML pro schémata XML. Následující tabulka popisuje každou z těchto metod.

Metoda	Popis
ValidateElement	Ověří název elementu v aktuálním kontextu.
ValidateAttribute	Ověří atribut v kontextu aktuálního prvku nebo proti objektu XmlSchemaAttribute předaného jako parametr metodě Initialize .
ValidateEndOfAttributes	Ověřuje, zda jsou přítomny všechny požadované atributy v kontextu elementu a připraví XmlSchemaValidator objekt k ověření podřízeného obsahu elementu.
ValidateText	Ověří, jestli je text povolený v kontextu aktuálního elementu, a shromažďuje text pro ověření, pokud má aktuální prvek jednoduchý obsah.
ValidateWhitespace	Ověří, jestli je v kontextu aktuálního prvku povolená mezera, a shromažďuje prázdné znaky pro ověření, zda aktuální prvek má jednoduchý obsah.
ValidateEndElement	Ověřuje, zda je textový obsah prvku platný podle jeho datového typu pro prvky s jednoduchým obsahem, a ověřuje, zda je obsah aktuálního prvku úplný pro prvky se složitým obsahem.
SkipToEndElement	Přeskočí ověření aktuálního obsahu elementu XmlSchemaValidator a připraví objekt k ověření obsahu v kontextu nadřazeného elementu.
EndValidation	Ukončí ověřování a kontroluje omezení identity pro celý dokument XML, pokud je nastavena ProcessIdentityConstraints možnost ověření.

Poznámka:

Třída XmlSchemaValidator má definovaný přechod stavu, který vynucuje posloupnost a výskyt volání provedených pro každou z metod popsaných v předchozí tabulce. Konkrétní přechod stavů třídy XmlSchemaValidator je popsán v části „Přechod stavů XmlSchemaValidator“ v tomto tématu.

Příklad metod použitých k ověření prvků, atributů a obsahu v informační sadě XML najdete v příkladu v předchozí části. Další informace o těchto metodách naleznete v XmlSchemaValidator referenční dokumentaci třídy.

Ověřování obsahu pomocí XmlValueGetter

Dá XmlValueGetterdelegate se použít k předání hodnoty atributů, textu nebo prázdných uzlů jako typů CLR (Common Language Runtime) kompatibilních s typem XSD (XML Schema Definition Language Language) atributu, textu nebo prázdného uzlu. XmlValueGetter delegate je užitečné, pokud je hodnota CLR atributu, textu nebo uzlu s bílým znakem již k dispozici, a zabraňuje nákladům na její převod na string a následné opětovné zpracování pro ověření.

Metody ValidateAttribute, ValidateText a ValidateWhitespace jsou přetíženy a přijímají hodnotu atributu, textu nebo uzly bílých znaků jako string nebo XmlValueGetterdelegate.

Následující metody XmlSchemaValidator třídy přijímají XmlValueGetterdelegate jako parametr.

• ValidateAttribute

• ValidateText

• ValidateWhitespace

Následuje příklad XmlValueGetterdelegate z příkladu XmlSchemaValidator třídy v úvodu. Vrátí XmlValueGetterdelegate hodnotu atributu jako DateTime objektu. Chcete-li ověřit tento DateTime objekt vrácený objektem XmlValueGetter, nejprve jej XmlSchemaValidator objekt převede na ValueType (ValueType je výchozí mapování CLR pro typ XSD) pro datový typ atributu a poté zkontroluje omezující vlastnosti tohoto převedeného hodnoty.

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);
}

Úplný příklad tohoto příkladu XmlValueGetterdelegatenajdete v příkladu v úvodu. Další informace o XmlValueGetterdelegate naleznete v referenční dokumentaci XmlValueGetter a třídě XmlSchemaValidator.

Post-Schema –Validation-Information

Třída XmlSchemaInfo představuje některé části Post-Schema-Validation-Information uzlu XML, které ověřuje třída XmlSchemaValidator. Různé metody XmlSchemaValidator třídy přijímají XmlSchemaInfo objekt jako volitelný parametr (null). out

Po úspěšném ověření se vlastnosti objektu XmlSchemaInfo nastaví s výsledky ověření. Například při úspěšném ověření atributu pomocí ValidateAttribute metody jsou vlastnosti XmlSchemaInfo, SchemaAttribute, SchemaType a MemberType objektu Validity (pokud je zadán) nastaveny s výsledky ověření.

Metody třídy XmlSchemaValidator, které přijímají objekt XmlSchemaInfo jako výstupní parametr.

• SkipToEndElement

• ValidateAttribute

• ValidateAttribute

• ValidateElement

• ValidateElement

• ValidateEndElement

• ValidateEndElement

• ValidateEndOfAttributes

Úplný příklad XmlSchemaInfo třídy najdete v příkladu v úvodu. Další informace o XmlSchemaInfo třídě najdete v XmlSchemaInfo referenční dokumentaci ke třídě.

Načítání očekávaných částic, atributů a nespecifikovaných výchozích atributů

Třída XmlSchemaValidator poskytuje metody GetExpectedAttributes, GetExpectedParticles a GetUnspecifiedDefaultAttributes pro načtení předpokládaných částic, atributů a přednastavených výchozích atributů v rámci aktuálního kontextu ověřování.

Načítání očekávaných částic

Metoda GetExpectedParticles vrátí pole XmlSchemaParticle objektů obsahujících očekávané částice v kontextu aktuálního prvku. Platné částice, které mohou být vráceny GetExpectedParticles metodou, jsou instancemi XmlSchemaElement a XmlSchemaAny třídy.

Pokud je kompozitor pro model xs:sequence obsahu, vrátí se pouze další částice v sekvenci. Pokud je kompozitor pro model obsahu xs:all nebo xs:choice, vrátí se všechny platné částice, které by mohly následovat v kontextu aktuálního prvku.

Poznámka:

GetExpectedParticles Pokud metoda je volána okamžitě po volání Initialize metody, GetExpectedParticles vrátí metoda všechny globální prvky.

Například ve schématu XML Schema Definition Language (XSD) a dokumentu XML, které následují, po ověření book elementu je element book aktuálním kontextem. Metoda GetExpectedParticles vrátí pole obsahující jeden XmlSchemaElement objekt představující title prvek. Pokud je title kontextem ověření prvek, GetExpectedParticles metoda vrátí prázdné pole. GetExpectedParticles Pokud metoda je volána po title ověření elementu, ale před ověřením elementudescription, vrátí pole obsahující jeden XmlSchemaElement objekt představující description prvek. GetExpectedParticles Pokud metoda je volána po description ověření elementu, vrátí pole obsahující jeden XmlSchemaAny objekt představující zástupný znak.

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);

Příklad přebírá jako vstup následující kód XML:

<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>

Příklad používá jako vstup následující schéma XSD:

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

Poznámka:

Výsledky metod GetExpectedParticles, GetExpectedAttributes a AddSchema třídy XmlSchemaValidator jsou závislé na aktuálním kontextu, který se ověřuje. Další informace najdete v části Kontext ověření v tomto tématu.

Příklad GetExpectedParticles metody najdete v příkladu v úvodu. Další informace o metodě GetExpectedParticles naleznete v dokumentaci referenční třídy XmlSchemaValidator.

Získávání očekávaných atributů

Metoda GetExpectedAttributes vrátí pole XmlSchemaAttribute objektů obsahující očekávané atributy v kontextu aktuálního elementu.

Například v příkladu v úvodu GetExpectedAttributes se metoda používá k načtení všech atributů elementu book .

Pokud metodu GetExpectedAttributes zavoláte ihned za metodou ValidateElement , vrátí se všechny atributy, které by se mohly zobrazit v dokumentu XML. Pokud však voláte metodu GetExpectedAttributes po jednom nebo několika voláních ValidateAttribute metody, vrátí se atributy, které ještě nebyly ověřeny pro aktuální prvek.

Poznámka:

Výsledky metod GetExpectedParticles, GetExpectedAttributes a AddSchema třídy XmlSchemaValidator jsou závislé na aktuálním kontextu, který se ověřuje. Další informace najdete v části Kontext ověření v tomto tématu.

Příklad GetExpectedAttributes metody najdete v příkladu v úvodu. Další informace o metodě GetExpectedAttributes naleznete v dokumentaci referenční třídy XmlSchemaValidator.

Načítání nezadaného výchozího atributu

Metoda GetUnspecifiedDefaultAttributes naplní ArrayList zadané XmlSchemaAttribute objekty pro všechny atributy výchozími hodnotami, které nebyly dříve ověřeny pomocí ValidateAttribute metody v kontextu elementu. Metoda GetUnspecifiedDefaultAttributes by měla být volána po volání ValidateAttribute metody pro každý atribut v kontextu elementu. Metoda GetUnspecifiedDefaultAttributes by se měla použít k určení výchozích atributů, které se mají vložit do ověřovaného dokumentu XML.

Další informace o metodě GetUnspecifiedDefaultAttributes naleznete v dokumentaci referenční třídy XmlSchemaValidator.

Zpracování událostí ověření schématu

Upozornění a chyby ověřování schématu ValidationEventHandler , ke kterým došlo během ověřování, se zpracovávají událostí XmlSchemaValidator třídy.

Upozornění na ověření schématu mají XmlSeverityType hodnotu Warning a chyby ověření schématu XmlSeverityType mají hodnotu Error. Pokud nebylo přiřazeno žádné ValidationEventHandler, je vyvolána výjimka XmlSchemaValidationException pro všechny chyby ověření schématu s hodnotou XmlSeverityTypeError. Není však vyvolán XmlSchemaValidationException pro upozornění na ověření schématu s hodnotou XmlSeverityTypeWarning.

Následuje příklad ValidationEventHandler , který obdrží upozornění na ověření schématu a chyby, ke kterým došlo během ověřování schématu převzatého z příkladu v úvodu.

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;
    }
}

Úplný příklad tohoto příkladu ValidationEventHandlernajdete v příkladu v úvodu. Další informace najdete v referenční dokumentaci ke třídě XmlSchemaInfo .

Přechod stavu XmlSchemaValidator

Třída XmlSchemaValidator má definovaný přechod stavu, který vynucuje posloupnost a výskyt volání provedených pro každou z metod používaných k ověření prvků, atributů a obsahu v informační sadě XML.

Následující tabulka popisuje přechod stavu třídy XmlSchemaValidator, a posloupnost a výskyt volání metod, jež lze provést v jednotlivých stavech.

Stát	Přechod
Ověřit	Initialize (ValidateAttribute | TopLevel*) EndValidation
Nejvyšší úroveň	ValidateWhitespace | ValidateText | Element
prvek	ValidateElement ValidateAttribute* (ValidateEndOfAttributes Obsah*)? ValidateEndElement | ValidateElement ValidateAttribute * SkipToEndElement | ValidateElement ValidateAttribute * ValidateEndOfAttributes Obsah* SkipToEndElement |
Obsah	ValidateWhitespace | ValidateText | Element

Poznámka:

Každá z metod v tabulce výše vyvolá InvalidOperationException při provedení volání metody ve špatném pořadí podle aktuálního stavu objektu XmlSchemaValidator.

Výše uvedená tabulka přechodu stavu používá interpunkční symboly k popisu metod a dalších stavů, které lze volat pro každý stav přechodu XmlSchemaValidator stavu třídy. Použité symboly jsou stejné symboly, které najdete v odkazu na standardy XML pro definici typu dokumentu (DTD).

Následující tabulka popisuje, jak interpunkční symboly nalezené v tabulce přechodu stavu výše ovlivňují metody a jiné stavy, které lze volat pro každý stav v přechodu stavu třídy XmlSchemaValidator.

Symbol	Popis
|	Je možné volat metodu nebo stav (tu před lomenou čarou nebo za ní).
?	Metoda nebo stav, které předcházejí otazníku, jsou nepovinné, ale pokud jsou volány, lze je volat pouze jednou.
*	Metoda nebo stav, který předchází symbolu *, je nepovinný a lze volat více než jednou.

Kontext ověření

Metody XmlSchemaValidator třídy používané k ověření elementů, atributů a obsahu v informační sadě XML změní kontext ověření objektu XmlSchemaValidator . Například metoda SkipToEndElement přeskočí ověření aktuálního obsahu elementu a připraví XmlSchemaValidator objekt k ověření obsahu v kontextu nadřazeného elementu; což je ekvivalentní vynechání ověření pro všechny podřízené prvky aktuálního elementu a následné volání metody ValidateEndElement.

Výsledky metod GetExpectedParticles, GetExpectedAttributes a AddSchema třídy XmlSchemaValidator jsou závislé na aktuálním kontextu, který se ověřuje.

Následující tabulka popisuje výsledky volání těchto metod po volání jedné z metod XmlSchemaValidator třídy sloužící k ověření prvků, atributů a obsahu v informační sadě XML.

Metoda	GetExpectedParticles	GetExpectedAttributes	AddSchema
Initialize	Pokud je volána výchozí Initialize metoda, GetExpectedParticles vrátí pole obsahující všechny globální prvky. Pokud je přetížená Initialize metoda, která přebírá XmlSchemaObject jako parametr, volána k inicializaci částečného ověření elementu, GetExpectedParticles vrátí pouze prvek, do kterého byl objekt XmlSchemaValidator inicializován.	Pokud je volána výchozí Initialize metoda, GetExpectedAttributes vrátí prázdné pole. Pokud je přetížení metody Initialize, které přijímá XmlSchemaObject jako parametr, voláno k inicializaci částečného ověření atributu, GetExpectedAttributes vrátí pouze atribut, ke kterému byl objekt XmlSchemaValidator inicializován.	Přidá schéma do XmlSchemaSet objektu XmlSchemaValidator , pokud nemá žádné chyby předběžného zpracování.
ValidateElement	Pokud je kontextový prvek platný, GetExpectedParticles vrátí posloupnost prvků očekávaných jako podřízené položky kontextového prvku. Pokud je kontextový prvek neplatný, GetExpectedParticles vrátí prázdné pole.	Pokud je kontextový prvek platný a pokud nebylo dříve učiněno žádné volání ValidateAttribute, GetExpectedAttributes vrátí seznam všech atributů definovaných v kontextovém elementu. Pokud již byly některé atributy ověřeny, vrátí seznam zbývajících atributů, GetExpectedAttributes které se mají ověřit. Pokud je kontextový prvek neplatný, GetExpectedAttributes vrátí prázdné pole.	Platí to samé jako výše.
ValidateAttribute	Pokud je kontextovým atributem atribut nejvyšší úrovně, GetExpectedParticles vrátí prázdné pole. V opačném případě vrací GetExpectedParticles posloupnost prvků, které jsou očekávány jako první podřízené prvky kontextového prvku.	Pokud je kontextovým atributem atribut nejvyšší úrovně, GetExpectedAttributes vrátí prázdné pole. V opačném případě GetExpectedAttributes vrátí seznam zbývajících atributů, které se mají ověřit.	Platí to samé jako výše.
GetUnspecifiedDefaultAttributes	GetExpectedParticles vrátí posloupnost prvků očekávaných jako první podřazené prvky kontextového elementu.	GetExpectedAttributes vrátí seznam požadovaných a nepovinných atributů, které se ještě mají ověřit pro kontextový prvek.	Platí to samé jako výše.
ValidateEndOfAttributes	GetExpectedParticles vrátí posloupnost prvků očekávaných jako první podřazené prvky kontextového elementu.	GetExpectedAttributes vrátí prázdné pole.	Platí to samé jako výše.
ValidateText	Pokud je contentType kontextového prvku smíšený, GetExpectedParticles vrátí posloupnost prvků očekávaných v další pozici. Pokud je contentType kontextového prvku TextOnly nebo Empty, GetExpectedParticles vrátí prázdné pole. Pokud je contentType elementu kontextu ElementOnly, GetExpectedParticles vrátí posloupnost prvků očekávaných na další pozici, ale již došlo k chybě ověření.	GetExpectedAttributes vrátí seznam atributů, které nejsou ověřeny kontextovým prvkem.	Platí to samé jako výše.
ValidateWhitespace	Pokud je kontextovým prázdným místem prázdné místo na nejvyšší úrovni, GetExpectedParticles vrátí prázdné pole. GetExpectedParticles Jinak chování metody je stejné jako v ValidateText.	Pokud je kontextovým prázdným místem prázdné místo na nejvyšší úrovni, GetExpectedAttributes vrátí prázdné pole. GetExpectedAttributes Jinak chování metody je stejné jako v ValidateText.	Platí to samé jako výše.
ValidateEndElement	GetExpectedParticles vrátí sekvenci prvků, které se očekávají za kontextovým prvkem (možní sourozenci).	GetExpectedAttributes vrátí seznam atributů, které nejsou ověřeny kontextovým prvkem. Pokud kontextový prvek nemá žádný nadřazený prvek, GetExpectedAttributes vrátí prázdný seznam (kontextový prvek je rodičem aktuálního prvku, pro který byl ValidateEndElement volán).	Platí to samé jako výše.
SkipToEndElement	Stejné jako ValidateEndElement.	Stejné jako ValidateEndElement.	Platí to samé jako výše.
EndValidation	Vrátí prázdné pole.	Vrátí prázdné pole.	Platí to samé jako výše.

Poznámka:

Hodnoty vrácené různými vlastnostmi XmlSchemaValidator třídy nejsou změněny voláním žádné z metod v předchozí tabulce.

Viz také

• XmlSchemaValidator