Delen via

Validatie op basis van xmlSchemaValidator

  • Artikel

De XmlSchemaValidator klasse biedt een efficiënt, krachtig mechanisme voor het valideren van XML-gegevens op basis van XML-schema's op een push-gebaseerde manier. Met de XmlSchemaValidator klasse kunt u bijvoorbeeld een XML-infoset ter plaatse valideren zonder dat u deze als XML-document hoeft te serialiseren en het document vervolgens opnieuw kunt parseren met behulp van een geldige XML-lezer.

De XmlSchemaValidator klasse kan worden gebruikt in geavanceerde scenario's, zoals het bouwen van validatie-engines via aangepaste XML-gegevensbronnen of als een manier om een validerende XML-schrijver te bouwen.

Hier volgt een voorbeeld van het gebruik van de XmlSchemaValidator klasse om het contosoBooks.xml bestand te valideren op basis van het contosoBooks.xsd schema. In het voorbeeld wordt de XmlSerializer klasse gebruikt om het contosoBooks.xml bestand te deserialiseren en de waarde van de knooppunten door te geven aan de methoden van de XmlSchemaValidator klasse.

Notitie

Dit voorbeeld wordt gebruikt in de secties van dit onderwerp.

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

In het voorbeeld wordt het contosoBooks.xml bestand als invoer gebruikt.

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

In het voorbeeld wordt ook de contosoBooks.xsd invoer gebruikt.

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

XML-gegevens valideren met xmlSchemaValidator

Als u een XML-infoset wilt valideren, moet u eerst een nieuw exemplaar van de XmlSchemaValidator klasse initialiseren met behulp van de XmlSchemaValidator constructor.

De XmlSchemaValidator constructor gebruikt XmlNameTable, XmlSchemaSeten XmlNamespaceManager objecten als parameters, evenals een XmlSchemaValidationFlags waarde als een parameter. Het XmlNameTable object wordt gebruikt voor het atomiseren van bekende naamruimtetekenreeksen zoals de schemanaamruimte, de XML-naamruimte, enzovoort, en wordt doorgegeven aan de methode tijdens het ParseValue valideren van eenvoudige inhoud. Het XmlSchemaSet object bevat de XML-schema's die worden gebruikt om de XML-infoset te valideren. Het XmlNamespaceManager object wordt gebruikt om naamruimten op te lossen die tijdens de validatie zijn aangetroffen. De XmlSchemaValidationFlags waarde wordt gebruikt om bepaalde functies van validatie uit te schakelen.

Zie de referentiedocumentatie voor klassen voor meer informatie over de XmlSchemaValidator XmlSchemaValidator constructor.

Validatie initialiseren

Nadat een XmlSchemaValidator object is samengesteld, zijn er twee overbelaste Initialize methoden die worden gebruikt om de status van het XmlSchemaValidator object te initialiseren. Hier volgen de twee Initialize methoden.

Met de standaardmethode XmlSchemaValidator.Initialize wordt een XmlSchemaValidator object geïnitialiseerd tot de beginstatus en de overbelaste XmlSchemaValidator.Initialize methode die een XmlSchemaObject parameter gebruikt, initialiseert een XmlSchemaValidator object tot de beginstatus voor gedeeltelijke validatie.

Beide Initialize methoden kunnen alleen direct worden aangeroepen nadat een XmlSchemaValidator object is gemaakt of na een aanroep naar EndValidation.

Zie het voorbeeld in de inleiding voor een voorbeeld van de XmlSchemaValidator.Initialize methode. Zie de XmlSchemaValidator documentatie over de klassereferentie voor meer informatie over de Initialize methode.

Gedeeltelijke validatie

Met XmlSchemaValidator.Initialize de methode die een XmlSchemaObject parameter als parameter gebruikt, wordt een XmlSchemaValidator object geïnitialiseerd tot de beginstatus voor gedeeltelijke validatie.

In het volgende voorbeeld wordt een XmlSchemaObject initialisatie geïnitialiseerd voor gedeeltelijke validatie met behulp van de XmlSchemaValidator.Initialize methode. Het orderNumber schema-element wordt doorgegeven door het schema-element XmlQualifiedName te selecteren in de XmlSchemaObjectTable verzameling die wordt geretourneerd door de GlobalElements eigenschap van het XmlSchemaSet object. Het XmlSchemaValidator object valideert vervolgens dit specifieke element.

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

In het voorbeeld wordt het volgende XML-schema als invoer gebruikt.

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

Zie de XmlSchemaValidator documentatie over de klassereferentie voor meer informatie over de Initialize methode.

Aanvullende schema's toevoegen

De AddSchema methode van de XmlSchemaValidator klasse wordt gebruikt om een XML-schema toe te voegen aan de set schema's die tijdens de validatie worden gebruikt. De AddSchema methode kan worden gebruikt om het effect te simuleren van een inline XML-schema in de XML-infoset die wordt gevalideerd.

Notitie

De doelnaamruimte van de XmlSchema parameter kan niet overeenkomen met die van een element of kenmerk dat al door het XmlSchemaValidator object is aangetroffen.

Als de XmlSchemaValidationFlags.ProcessInlineSchema waarde niet als parameter aan de XmlSchemaValidator constructor is doorgegeven, doet de AddSchema methode niets.

Het resultaat van de AddSchema methode is afhankelijk van de huidige XML-knooppuntcontext die wordt gevalideerd. Zie de sectie Validatiecontext van dit onderwerp voor meer informatie over validatiecontext.

Zie de XmlSchemaValidator documentatie over de klassereferentie voor meer informatie over de AddSchema methode.

Elementen, kenmerken en inhoud valideren

De XmlSchemaValidator klasse biedt verschillende methoden die worden gebruikt voor het valideren van elementen, kenmerken en inhoud in een XML-infoset op basis van XML-schema's. In de volgende tabel wordt elk van deze methoden beschreven.

Wijze Description
ValidateElement Valideert de elementnaam in de huidige context.
ValidateAttribute Valideert het kenmerk in de huidige elementcontext of op basis van het XmlSchemaAttribute object dat als parameter aan de Initialize methode is doorgegeven.
ValidateEndOfAttributes Controleert of alle vereiste kenmerken in de elementcontext aanwezig zijn en bereidt het XmlSchemaValidator object voor om de onderliggende inhoud van het element te valideren.
ValidateText Valideert of tekst is toegestaan in de context van het huidige element en verzamelt de tekst voor validatie als het huidige element eenvoudige inhoud heeft.
ValidateWhitespace Valideert of witruimte is toegestaan in de context van het huidige element en verzamelt de witruimte voor validatie of het huidige element eenvoudige inhoud heeft.
ValidateEndElement Controleert of de tekstinhoud van het element geldig is op basis van het gegevenstype voor elementen met eenvoudige inhoud en controleert of de inhoud van het huidige element is voltooid voor elementen met complexe inhoud.
SkipToEndElement Hiermee wordt de validatie van de huidige elementinhoud overgeslagen en wordt het XmlSchemaValidator object voorbereid om inhoud in de context van het bovenliggende element te valideren.
EndValidation Hiermee wordt de validatie beëindigd en worden identiteitsbeperkingen voor het hele XML-document gecontroleerd als de ProcessIdentityConstraints validatieoptie is ingesteld.

Notitie

De XmlSchemaValidator klasse heeft een gedefinieerde statusovergang waarmee de volgorde en het optreden van aanroepen naar elk van de methoden in de vorige tabel worden afgedwongen. De specifieke statusovergang van de XmlSchemaValidator klasse wordt beschreven in de sectie XmlSchemaValidator State Transition van dit onderwerp.

Zie het voorbeeld in de vorige sectie voor een voorbeeld van de methoden die worden gebruikt voor het valideren van elementen, kenmerken en inhoud in een XML-infoset. Zie de XmlSchemaValidator referentiedocumentatie voor klassen voor meer informatie over deze methoden.

Inhoud valideren met behulp van een XmlValueGetter

De XmlValueGetterdelegate kan worden gebruikt om de waarde van kenmerk-, tekst- of witruimteknooppunten door te geven als clr-typen (Common Language Runtime) die compatibel zijn met het XSD-type (XML Schema Definition Language) van het kenmerk, de tekst of het knooppunt met witruimte. Een XmlValueGetterdelegate is handig als de CLR-waarde van een kenmerk, tekst of witruimteknooppunt al beschikbaar is en de kosten voor het converteren naar een string knooppunt vermijdt en vervolgens opnieuw herstelt voor validatie.

De ValidateAttributemethoden , ValidateTexten ValidateWhitespace methoden worden overbelast en accepteren de waarde van kenmerk-, tekst- of witruimteknooppunten als een string of XmlValueGetterdelegate.

De volgende methoden van de XmlSchemaValidator klasse accepteren een XmlValueGetterdelegate als parameter.

Hier volgt een voorbeeld XmlValueGetterdelegate uit het XmlSchemaValidator klassevoorbeeld in de inleiding. De XmlValueGetterdelegate waarde van een kenmerk wordt als object DateTime geretourneerd. Als u wilt valideren dat dit DateTime object wordt geretourneerd door het XmlValueGetterobject, converteert het XmlSchemaValidator eerst naar het ValueType (ValueType is de standaard CLR-toewijzing voor het XSD-type) voor het gegevenstype van het kenmerk en controleert het vervolgens facetten op de geconverteerde waarde.

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

Zie het voorbeeld in de inleiding voor een volledig voorbeeld van XmlValueGetterdelegatede Zie voor meer informatie over de XmlValueGetterdelegatereferentiedocumentatie en XmlSchemaValidator de XmlValueGetterklassereferentie.

Post-Schema-Validation-Information

De XmlSchemaInfo klasse vertegenwoordigt enkele van de post-schema-validatiegegevens van een XML-knooppunt dat door de XmlSchemaValidator klasse is gevalideerd. Verschillende methoden van de XmlSchemaValidator klasse accepteren een XmlSchemaInfo object als een optionele (null) out parameter.

Bij een geslaagde validatie worden eigenschappen van het XmlSchemaInfo object ingesteld met de resultaten van de validatie. Bij een geslaagde validatie van een kenmerk met behulp van de ValidateAttribute methode worden bijvoorbeeld de eigenschappen van het XmlSchemaInfo object (indien opgegeven) MemberTypeSchemaAttributeSchemaTypeValidity en eigenschappen ingesteld met de resultaten van de validatie.

De volgende XmlSchemaValidator klassemethoden accepteren een XmlSchemaInfo object als een outparameter.

Zie het voorbeeld in de inleiding voor een volledig voorbeeld van de XmlSchemaInfo klasse. Zie de XmlSchemaInfo naslagdocumentatie voor klassen voor meer informatie over de XmlSchemaInfo klasse.

Verwachte deeltjes, kenmerken en niet-opgegeven standaardkenmerken ophalen

De XmlSchemaValidator klasse biedt de GetExpectedAttributes, GetExpectedParticlesen GetUnspecifiedDefaultAttributes methoden voor het ophalen van de verwachte deeltjes, kenmerken en niet-opgegeven standaardkenmerken in de huidige validatiecontext.

Verwachte deeltjes ophalen

De GetExpectedParticles methode retourneert een matrix van XmlSchemaParticle objecten die de verwachte deeltjes bevatten in de context van het huidige element. De geldige deeltjes die door de GetExpectedParticles methode kunnen worden geretourneerd, zijn exemplaren van de XmlSchemaElement en XmlSchemaAny klassen.

Wanneer de compositor voor de con tentmodus l een xs:sequenceis, wordt alleen het volgende deeltje in de reeks geretourneerd. Als de compositor voor de con tentmodus l een xs:all of een xs:choiceis, worden alle geldige deeltjes die in de huidige elementcontext kunnen volgen, geretourneerd.

Notitie

Als de GetExpectedParticles methode direct na het aanroepen van de Initialize methode wordt aangeroepen, retourneert de GetExpectedParticles methode alle globale elementen.

In het XSD-schema (XML Schema Definition Language) en het XML-document dat volgt, na het valideren van het book element, is het book element bijvoorbeeld de huidige elementcontext. De GetExpectedParticles methode retourneert een matrix die één XmlSchemaElement object bevat dat het title element vertegenwoordigt. Wanneer de validatiecontext het title element is, retourneert de GetExpectedParticles methode een lege matrix. Als de GetExpectedParticles methode wordt aangeroepen nadat het title element is gevalideerd, maar voordat het description element is gevalideerd, wordt een matrix geretourneerd die één XmlSchemaElement object bevat dat het description element vertegenwoordigt. Als de GetExpectedParticles methode wordt aangeroepen nadat het description element is gevalideerd, retourneert het een matrix die één XmlSchemaAny object bevat dat het jokerteken vertegenwoordigt.

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

In het voorbeeld wordt de volgende XML als invoer gebruikt:

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

In het voorbeeld wordt het volgende XSD-schema als invoer gebruikt:

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

Notitie

De resultaten van de GetExpectedParticlesklasse GetExpectedAttributesen AddSchema methoden van de XmlSchemaValidator klasse zijn afhankelijk van de huidige context die wordt gevalideerd. Zie de sectie Validatiecontext van dit onderwerp voor meer informatie.

Zie het voorbeeld in de inleiding voor een voorbeeld van de GetExpectedParticles methode. Zie de XmlSchemaValidator documentatie over de klassereferentie voor meer informatie over de GetExpectedParticles methode.

Verwachte kenmerken ophalen

De GetExpectedAttributes methode retourneert een matrix met XmlSchemaAttribute objecten met de verwachte kenmerken in de context van het huidige element.

In het voorbeeld in de inleiding wordt de GetExpectedAttributes methode bijvoorbeeld gebruikt om alle kenmerken van het book element op te halen.

Als u de GetExpectedAttributes methode onmiddellijk na de ValidateElement methode aanroept, worden alle kenmerken die in het XML-document kunnen worden weergegeven, geretourneerd. Als u de GetExpectedAttributes methode echter aanroept na een of meer aanroepen naar de ValidateAttribute methode, worden de kenmerken die nog niet zijn gevalideerd voor het huidige element geretourneerd.

Notitie

De resultaten van de GetExpectedParticlesklasse GetExpectedAttributesen AddSchema methoden van de XmlSchemaValidator klasse zijn afhankelijk van de huidige context die wordt gevalideerd. Zie de sectie Validatiecontext van dit onderwerp voor meer informatie.

Zie het voorbeeld in de inleiding voor een voorbeeld van de GetExpectedAttributes methode. Zie de XmlSchemaValidator documentatie over de klassereferentie voor meer informatie over de GetExpectedAttributes methode.

Niet-opgegeven standaardkenmerken ophalen

De GetUnspecifiedDefaultAttributes methode vult de ArrayList opgegeven met XmlSchemaAttribute objecten voor kenmerken met standaardwaarden die nog niet eerder zijn gevalideerd met behulp van de ValidateAttribute methode in de elementcontext. De GetUnspecifiedDefaultAttributes methode moet worden aangeroepen na het aanroepen van de ValidateAttribute methode voor elk kenmerk in de elementcontext. De GetUnspecifiedDefaultAttributes methode moet worden gebruikt om te bepalen welke standaardkenmerken moeten worden ingevoegd in het XML-document dat wordt gevalideerd.

Zie de XmlSchemaValidator documentatie over de klassereferentie voor meer informatie over de GetUnspecifiedDefaultAttributes methode.

Schemavalidatie-gebeurtenissen verwerken

Waarschuwingen voor schemavalidatie en fouten die tijdens de validatie zijn opgetreden, worden verwerkt door de ValidationEventHandler gebeurtenis van de XmlSchemaValidator klasse.

Schemavalidatiewaarschuwingen hebben een XmlSeverityType waarde van Warning en schemavalidatiefouten hebben een XmlSeverityType waarde van Error. Als er geen is ValidationEventHandler toegewezen, wordt er een XmlSchemaValidationException gegenereerd voor alle schemavalidatiefouten met een XmlSeverityType waarde van Error. XmlSchemaValidationException Er wordt echter geen waarschuwing gegenereerd voor schemavalidatie met een XmlSeverityType waarde van Warning.

Hier volgt een voorbeeld van een ValidationEventHandler die waarschuwingen en fouten voor schemavalidatie ontvangt die zijn opgetreden tijdens de schemavalidatie uit het voorbeeld in de inleiding.

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

Zie het voorbeeld in de inleiding voor een volledig voorbeeld van ValidationEventHandlerde Zie de referentiedocumentatie voor klassen XmlSchemaInfo voor meer informatie.

XmlSchemaValidator-statusovergang

De XmlSchemaValidator klasse heeft een gedefinieerde statusovergang waarmee de volgorde en het optreden van aanroepen naar elk van de methoden worden afgedwongen die worden gebruikt voor het valideren van elementen, kenmerken en inhoud in een XML-infoset.

De volgende tabel beschrijft de statusovergang van de XmlSchemaValidator klasse en de volgorde en het optreden van methode-aanroepen die in elke status kunnen worden gemaakt.

Provincie Transition
Valideren Initialize ( |ValidateAttribute TopLevel*) EndValidation
TopLevel ValidateWhitespace | ValidateText | Element
Element ValidateElementValidateAttribute* (ValidateEndOfAttributes Inhoud*)? ValidateEndElement |

ValidateElement ValidateAttribute* SkipToEndElement |

ValidateElementValidateAttribute* ValidateEndOfAttributes Tevreden*SkipToEndElement |
Inhoud ValidateWhitespace | ValidateText | Element

Notitie

Er InvalidOperationException wordt een gegenereerd door elk van de methoden in de bovenstaande tabel wanneer de aanroep naar de methode in de onjuiste volgorde wordt uitgevoerd op basis van de huidige status van een XmlSchemaValidator object.

In de bovenstaande statusovergangstabel worden leestekens gebruikt om de methoden en andere statussen te beschrijven die kunnen worden aangeroepen voor elke status van de statusovergang van de XmlSchemaValidator klasse. De gebruikte symbolen zijn dezelfde symbolen in de XML-standaardenreferentie voor documenttypedefinitie (DTD).

In de volgende tabel wordt beschreven hoe de interpunctiesymbolen in de bovenstaande statusovergangstabel van invloed zijn op de methoden en andere statussen die voor elke status in de statusovergang van de XmlSchemaValidator klasse kunnen worden aangeroepen.

Symbool Beschrijving
| Methode of status (de methode voor de balk of de balk erna) kan worden aangeroepen.
? De methode of status die voorafgaat aan het vraagteken is optioneel, maar als deze wordt aangeroepen, kan deze slechts eenmaal worden aangeroepen.
* De methode of status die voorafgaat aan het symbool * is optioneel en kan meerdere keren worden aangeroepen.

Validatiecontext

De methoden van de klasse die worden gebruikt voor het XmlSchemaValidator valideren van elementen, kenmerken en inhoud in een XML-infoset, wijzigen de validatiecontext van een XmlSchemaValidator object. De SkipToEndElement methode slaat bijvoorbeeld de validatie van de huidige elementinhoud over en bereidt het object voor op het XmlSchemaValidator valideren van inhoud in de context van het bovenliggende element. Het is gelijk aan het overslaan van validatie voor alle onderliggende elementen van het huidige element en vervolgens de ValidateEndElement methode aanroept.

De resultaten van de GetExpectedParticlesklasse GetExpectedAttributesen AddSchema methoden van de XmlSchemaValidator klasse zijn afhankelijk van de huidige context die wordt gevalideerd.

In de volgende tabel worden de resultaten beschreven van het aanroepen van deze methoden na het aanroepen van een van de methoden van de XmlSchemaValidator klasse die wordt gebruikt voor het valideren van elementen, kenmerken en inhoud in een XML-infoset.

Wijze GetExpectedParticles GetExpectedAttributes AddSchema
Initialize Als de standaardmethode Initialize wordt aangeroepen, GetExpectedParticles retourneert u een matrix met alle globale elementen.

Als de overbelaste Initialize methode die een XmlSchemaObject parameter gebruikt, wordt aangeroepen om gedeeltelijke validatie van een element te initialiseren, GetExpectedParticles wordt alleen het element geretourneerd waarnaar het XmlSchemaValidator object is geïnitialiseerd.		 Als de standaardmethode Initialize wordt aangeroepen, GetExpectedAttributes retourneert u een lege matrix.

Als de overbelasting van de Initialize methode die een XmlSchemaObject parameter gebruikt, wordt aangeroepen om gedeeltelijke validatie van een kenmerk te initialiseren, GetExpectedAttributes wordt alleen het kenmerk geretourneerd waarnaar het XmlSchemaValidator object is geïnitialiseerd.		 Voegt het schema toe aan het XmlSchemaSet XmlSchemaValidator object als er geen voorverwerkingsfouten zijn.
ValidateElement Als het contextelement geldig is, GetExpectedParticles wordt de reeks elementen geretourneerd die worden verwacht als onderliggende elementen van het contextelement.

Als het contextelement ongeldig is, GetExpectedParticles wordt een lege matrix geretourneerd.		 Als het contextelement geldig is en er eerder geen aanroep ValidateAttribute is gedaan, GetExpectedAttributes wordt een lijst geretourneerd met alle kenmerken die zijn gedefinieerd op het contextelement.

Als sommige kenmerken al zijn gevalideerd, GetExpectedAttributes retourneert u een lijst met de resterende kenmerken die moeten worden gevalideerd.

Als het contextelement ongeldig is, GetExpectedAttributes wordt een lege matrix geretourneerd.		 Hetzelfde als hierboven.
ValidateAttribute Als het contextkenmerk een kenmerk op het hoogste niveau is, GetExpectedParticles retourneert u een lege matrix.

Anders GetExpectedParticles wordt de volgorde geretourneerd van elementen die worden verwacht als het eerste onderliggende element van het contextelement.		 Als het contextkenmerk een kenmerk op het hoogste niveau is, GetExpectedAttributes retourneert u een lege matrix.

Anders GetExpectedAttributes wordt de lijst met resterende kenmerken geretourneerd die moeten worden gevalideerd.		 Hetzelfde als hierboven.
GetUnspecifiedDefaultAttributes GetExpectedParticles retourneert de volgorde van elementen die worden verwacht als het eerste onderliggende element van het contextelement. GetExpectedAttributes retourneert een lijst met de vereiste en optionele kenmerken die nog moeten worden gevalideerd voor het contextelement. Hetzelfde als hierboven.
ValidateEndOfAttributes GetExpectedParticles retourneert de volgorde van elementen die worden verwacht als het eerste onderliggende element van het contextelement. GetExpectedAttributes retourneert een lege matrix. Hetzelfde als hierboven.
ValidateText Als het contentType van het contextelement gemengd is, GetExpectedParticles retourneert u de reeks elementen die op de volgende positie worden verwacht.

Als het contentType van het contextelement TextOnly of Empty is, GetExpectedParticles wordt een lege matrix geretourneerd.

Als het contentType van het contextelement ElementOnly is, wordt de reeks elementen geretourneerd die op de volgende positie worden verwacht, GetExpectedParticles maar er is al een validatiefout opgetreden.		 GetExpectedAttributes retourneert de lijst met kenmerken van het contextelement die niet zijn gevalideerd. Hetzelfde als hierboven.
ValidateWhitespace Als de context witruimte op het hoogste niveau witruimte is, GetExpectedParticles retourneert u een lege matrix.

Anders is het gedrag van de GetExpectedParticles methode hetzelfde als in ValidateText.		 Als de context witruimte op het hoogste niveau witruimte is, GetExpectedAttributes retourneert u een lege matrix.

Anders is het gedrag van de GetExpectedAttributes methode hetzelfde als in ValidateText.		 Hetzelfde als hierboven.
ValidateEndElement GetExpectedParticles retourneert de reeks elementen die worden verwacht na het contextelement (mogelijke broers en zussen). GetExpectedAttributes retourneert de lijst met kenmerken van het contextelement die niet zijn gevalideerd.

Als het contextelement geen bovenliggend element heeft, GetExpectedAttributes wordt een lege lijst geretourneerd (het contextelement is het bovenliggende element van het huidige element waarop ValidateEndElement is aangeroepen).		 Hetzelfde als hierboven.
SkipToEndElement Hetzelfde als ValidateEndElement. Hetzelfde als ValidateEndElement. Hetzelfde als hierboven.
EndValidation Retourneert een lege matrix. Retourneert een lege matrix. Hetzelfde als hierboven.

Notitie

De waarden die door de verschillende eigenschappen van de XmlSchemaValidator klasse worden geretourneerd, worden niet gewijzigd door een van de methoden in de bovenstaande tabel aan te roepen.

Zie ook