Pushbasierte Validierung mit "XmlSchemaValidator"

Artikel
08/21/2008

Aktualisiert: November 2007

Die XmlSchemaValidator-Klasse stellt eine effiziente leistungsstarke Methode zum Validieren von XML-Daten anhand von XML-Schemata in einem Push-Verfahren bereit. Zum Beispiel ermöglicht Ihnen die XmlSchemaValidator-Klasse das direkte Validieren eines XML-Infosets, ohne es als XML-Dokument serialisieren zu müssen, und das anschließende erneute Analysieren des XML-Infosets mithilfe eines validierenden XML-Readers.

Die XmlSchemaValidator-Klasse kann in erweiterten Szenarios verwendet werden, z. B. beim Erstellen von Validierungsmodulen für benutzerdefinierte XML-Datenquellen oder als eine Möglichkeit zum Erstellen eines validierenden XML-Writers.

Im folgenden Beispiel wird mithilfe der XmlSchemaValidator-Klasse die contosoBooks.xml-Datei anhand des contosoBooks.xsd-Schemas validiert. Im Beispiel wird mit der XmlSerializer-Klasse die contosoBooks.xml-Datei deserialisiert, und der Wert der Knoten wird an die Methoden der XmlSchemaValidator-Klasse übergeben.

Hinweis:
Dieses Beispiel wird in allen Abschnitten dieses Themas verwendet.

Imports System
Imports System.Xml
Imports System.Xml.Schema
Imports System.Xml.Serialization

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("https://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", "https://www.contoso.com/books", Nothing)
            validator.ValidateEndOfAttributes(Nothing)

            ' Get the next exptected 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", "https://www.contoso.com/books", Nothing)

                ' Get the exptected 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()

                ' 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", "https://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", "https://www.contoso.com/books", Nothing)
                validator.ValidateEndOfAttributes(Nothing)

                If Not book.Author.Name Is Nothing Then
                    ' Validate the name element and its content.
                    validator.ValidateElement("name", "https://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", "https://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", "https://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", "https://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:="https://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

using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

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("https://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", "https://www.contoso.com/books", null);
            validator.ValidateEndOfAttributes(null);

            // Get the next exptected 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", "https://www.contoso.com/books", null);

                // Get the exptected 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();

                // 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", "https://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", "https://www.contoso.com/books", null);
                validator.ValidateEndOfAttributes(null);

                if (book.Author.Name != null)
                {
                    // Validate the name element and its content.
                    validator.ValidateElement("name", "https://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", "https://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", "https://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", "https://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 = "https://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;
    }
}

In diesem Beispiel wird die Datei contosoBooks.xml als Eingabe verwendet.

<bookstore xmlns="https://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 diesem Beispiel wird auch contosoBooks.xsd als Eingabe verwendet.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="https://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>

Validieren von XML-Daten mithilfe von "XmlSchemaValidator"

Um die Validierung eines XML-Infosets zu starten, müssen Sie zuerst eine neue Instanz der XmlSchemaValidator-Klasse mithilfe des XmlSchemaValidator-Konstruktors initialisieren.

Der XmlSchemaValidator-Konstruktor nimmt die Objekte XmlNameTable, XmlSchemaSet und XmlNamespaceManager sowie den XmlSchemaValidationFlags-Wert als Parameter an. Mit dem XmlNameTable-Objekt werden bekannte Namespacezeichenfolgen, z. B. der Schemanamespace, der XML-Namespace usw., atomisiert und während der Validierung von einfachem Inhalt an die ParseValue-Methode übergeben. Das XmlSchemaSet-Objekt enthält die XML-Schemata, mit denen die XML-Infosets validiert werden. Mit dem XmlNamespaceManager-Objekt werden während der Validierung gefundene Namespaces aufgelöst. Mit dem XmlSchemaValidationFlags-Wert werden bestimmte Validierungsfunktionen deaktiviert.

Weitere Informationen zum XmlSchemaValidator-Konstruktor finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Initialisieren der Validierung

Nach dem Erstellen eines XmlSchemaValidator-Objekts wird mit zwei überladenen Initialize-Methoden der Zustand des XmlSchemaValidator-Objekts initialisiert. Nachfolgend sind die zwei Initialize-Methoden dargestellt.

Die Standard-XmlSchemaValidator.Initialize-Methode initialisiert ein XmlSchemaValidator-Objekt mit dessen Anfangszustand, und die überladene XmlSchemaValidator.Initialize-Methode, die ein XmlSchemaObject als Parameter annimmt, initialisiert ein XmlSchemaValidator-Objekt mit dessen Anfangszustand zur teilweisen Validierung.

Beide Initialize-Methoden können nur unmittelbar nach dem Erstellen eines XmlSchemaValidator-Objekts oder nach einem Aufruf von EndValidation aufgerufen werden.

Ein Beispiel für die XmlSchemaValidator.Initialize-Methode finden Sie im Beispiel in der Einleitung. Weitere Informationen zur Initialize-Methode finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Teilweise Validierung

Die XmlSchemaValidator.Initialize-Methode, die ein XmlSchemaObject als Parameter annimmt, initialisiert ein XmlSchemaValidator-Objekt mit dessen anfänglichem Zustand zur teilweisen Validierung.

Im folgenden Beispiel wird ein XmlSchemaObject mithilfe der XmlSchemaValidator.Initialize-Methode zur teilweisen Validierung initialisiert. Das orderNumber-Schemaelement wird durch Auswählen des Schemaelements durch XmlQualifiedName in der XmlSchemaObjectTable-Auflistung übergeben, die von der GlobalElements-Eigenschaft des XmlSchemaSet-Objekts zurückgegeben wurde. Das XmlSchemaValidator-Objekt validiert dann dieses bestimmte 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 diesem Beispiel wird das folgende XML-Schema als Eingabe verwendet.

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="orderNumber" type="xs:int" />

</xs:schema>

Weitere Informationen zur Initialize-Methode finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Hinzufügen von zusätzlichen Schemata

Mit der AddSchema-Methode der XmlSchemaValidator-Klasse wird der Gruppe von Schemata, die während der Validierung verwendet werden, ein XML-Schema hinzugefügt. Mit der AddSchema-Methode können die Auswirkungen des Findens eines XML-Inlineschemas in dem XML-Infoset simuliert werden, das validiert wird.

Hinweis:
Der Zielnamespace des XmlSchema-Parameters darf nicht mit dem Namespace eines der Elemente oder Attribute übereinstimmen, die bereits vom XmlSchemaValidator-Objekt gefunden wurden. Wenn der XmlSchemaValidationFlags.ProcessInlineSchema-Wert nicht als Parameter an den XmlSchemaValidator-Konstruktor übergeben wurde, hat die AddSchema-Methode keine Auswirkungen.

Der Zielnamespace des XmlSchema-Parameters darf nicht mit dem Namespace eines der Elemente oder Attribute übereinstimmen, die bereits vom XmlSchemaValidator-Objekt gefunden wurden.

Wenn der XmlSchemaValidationFlags.ProcessInlineSchema-Wert nicht als Parameter an den XmlSchemaValidator-Konstruktor übergeben wurde, hat die AddSchema-Methode keine Auswirkungen.

Das Ergebnis der AddSchema-Methode hängt von dem aktuellen XML-Knotenkontext ab, der validiert wird. Weitere Informationen zu Validierungskontexten finden Sie in diesem Thema im Abschnitt "Validierungskontext".

Weitere Informationen zur AddSchema-Methode finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Validieren von Elementen, Attributen und Inhalt

Die XmlSchemaValidator-Klasse stellt verschiedene Methoden zum Validieren von Elementen, Attributen und Inhalt in einem XML-Infoset anhand von XML-Schemata bereit. In der folgenden Tabelle werden diese Methoden beschrieben.

Methode	Beschreibung
ValidateElement	Validiert den Elementnamen im aktuellen Kontext.
ValidateAttribute	Validiert das Attribut im aktuellen Elementkontext oder anhand des XmlSchemaAttribute-Objekts, das als Parameter an die Initialize-Methode übergeben wurde.
ValidateEndOfAttributes	Überprüft, ob alle erforderlichen Attribute im Elementkontext vorhanden sind, und bereitet das XmlSchemaValidator-Objekt auf das Validieren des untergeordneten Inhalts des Elements vor.
ValidateText	Validiert, ob Text im aktuellen Elementkontext zulässig ist, und sammelt den Text zum Validieren, ob das aktuelle Element einfachen Inhalt aufweist.
ValidateWhitespace	Validiert, ob Leerraum im aktuellen Elementkontext zulässig ist, und sammelt den Leerraum zum Validieren, ob das aktuelle Element einfachen Inhalt aufweist.
ValidateEndElement	Überprüft, ob der Textinhalt des Elements gemäß des Datentyps für Elemente mit einfachem Inhalt gültig ist und ob der Inhalt des aktuellen Elements für Elemente mit komplexem Inhalt vollständig ist.
SkipToEndElement	Überspringt die Validierung des aktuellen Elementinhalts und bereitet das XmlSchemaValidator-Objekt zum Validieren des Inhalts im Kontext des übergeordneten Elements vor.
EndValidation	Beendet die Validierung und überprüft Identitätseinschränkungen für das gesamte XML-Dokument, wenn die ProcessIdentityConstraints-Validierungsoption festgelegt ist.

Hinweis:
Die XmlSchemaValidator-Klasse verfügt über einen definierten Zustandsübergang, der die Abfolge und das Vorkommen von Aufrufen der Methoden erzwingt, die in der vorherigen Tabelle beschrieben wurden. Der bestimmte Zustandsübergang der XmlSchemaValidator-Klasse wird im Abschnitt "Zustandsübergang von "XmlSchemaValidator"" dieses Themas beschrieben.

Ein Beispiel für Methoden zum Validieren von Elementen, Attributen und Inhalt eines XML-Infosets finden Sie im Beispiel des vorherigen Abschnitts. Weitere Informationen zu diesen Methoden finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Validieren von Inhalt mithilfe von "XmlValueGetter"

Mit XmlValueGetterdelegate kann der Wert von Attribut-, Text- oder Leerraumknoten als CLR-Typ (Common Language Runtime) übergeben werden, der mit dem XSD-Typ (XML Schema Definition Language) des Attribut-, Text- oder Leerraumknotens kompatibel ist. XmlValueGetterdelegate ist hilfreich, wenn der CLR-Wert eines Attribut-, Text- oder Leerraumknotens bereits verfügbar ist, und vermeidet die Kosten der Konvertierung in string und der anschließenden erneuten Analyse zur Validierung.

Die Methoden ValidateAttribute, ValidateText und ValidateWhitespace sind überladen und akzeptieren den Wert der Attribut-, Text- oder Leerraumknoten als string oder XmlValueGetterdelegate.

Die folgenden Methoden der XmlSchemaValidator-Klasse akzeptieren einen XmlValueGetterdelegate als Parameter.

Im Folgenden wird ein Beispiel für XmlValueGetterdelegate aus dem Beispiel für die XmlSchemaValidator-Klasse in der Einleitung dargestellt. XmlValueGetterdelegate gibt den Wert eines Attributs als DateTime-Objekt zurück. Zum Validieren dieses von XmlValueGetter zurückgegebenen DateTime-Objekts wird es zunächst vom XmlSchemaValidator-Objekt in den ValueType (ValueType ist die Standard-CLR-Zuordnung für den XSD-Typ) des Datentyps des Attributs konvertiert und dann werden Facets des konvertierten Werts überprüft.

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

static object dateTimeGetterContent;

static object dateTimeGetterHandle()
{
    return dateTimeGetterContent;
}

static XmlValueGetter dateTimeGetter(DateTime dateTime)
{
    dateTimeGetterContent = dateTime;
    return new XmlValueGetter(dateTimeGetterHandle);
}

Ein vollständiges Beispiel für XmlValueGetterdelegate finden Sie im Beispiel in der Einleitung. Weitere Informationen zum XmlValueGetterdelegate finden Sie in der Referenzdokumentation zur XmlValueGetter-Klasse und zur XmlSchemaValidator-Klasse.

Informationen zur Post-Schema-Validation

Die XmlSchemaInfo-Klasse stellt einige der Informationen zur Post-Schema-Validation eines XML-Knotens dar, der von der XmlSchemaValidator-Klasse validiert wird. Verschiedene Methoden der XmlSchemaValidator-Klasse akzeptieren ein XmlSchemaInfo-Objekt als einen optionalen (null) out-Parameter.

Bei einer erfolgreichen Validierung werden Eigenschaften des XmlSchemaInfo-Objekts auf die Ergebnisse der Validierung festgelegt. Bei der erfolgreichen Validierung eines Attributs mithilfe der ValidateAttribute-Methode werden z. B. die Eigenschaften SchemaAttribute, SchemaType, MemberType und Validity des XmlSchemaInfo-Objekts, sofern angegeben, auf die Ergebnisse der Validierung festgelegt.

Die folgenden Methoden der XmlSchemaValidator-Klasse akzeptieren ein XmlSchemaInfo-Objekt als out-Parameter.

Ein vollständiges Beispiel für die XmlSchemaInfo-Klasse finden Sie im Beispiel in der Einleitung. Weitere Informationen zur XmlSchemaInfo-Klasse finden Sie in der Referenzdokumentation der XmlSchemaInfo-Klasse.

Abrufen von erwarteten Partikeln, Attributen und nicht angegebenen Standardattributen

Die XmlSchemaValidator-Klasse stellt die Methoden GetExpectedAttributes, GetExpectedParticles und GetUnspecifiedDefaultAttributes zum Abrufen der erwarteten Partikel, Attribute und nicht angegebenen Standardattribute im aktuellen Validierungskontext bereit.

Abrufen von erwarteten Partikeln

Die GetExpectedParticles-Methode gibt ein Array von XmlSchemaParticle-Objekten mit den erwarteten Partikeln im aktuellen Elementkontext zurück. Die gültigen Partikel, die von der GetExpectedParticles-Methode zurückgegeben werden können, sind Instanzen der XmlSchemaElement-Klasse und der XmlSchemaAny-Klasse.

Wenn der Compositor für das Inhaltsmodell eine xs:sequence ist, wird nur der nächste Partikel in der Abfolge zurückgegeben. Wenn der Compositor für das Inhaltsmodell xs:all oder xs:choice ist, werden alle gültigen Partikel zurückgegeben, die im aktuellen Elementkontext folgen können.

Hinweis:
Wenn die GetExpectedParticles-Methode unmittelbar nach dem Aufrufen der Initialize-Methode aufgerufen wird, gibt die GetExpectedParticles-Methode alle globalen Elemente zurück.

Im folgenden XSD-Schema (XML Schema Definition Language) und XML-Dokument entspricht z. B. nach dem Validieren des book-Elements das book-Element dem aktuellen Elementkontext. Die GetExpectedParticles-Methode gibt ein Array mit einem einzelnen XmlSchemaElement-Objekt zurück, das das title-Element darstellt. Wenn der Validierungskontext dem title-Element entspricht, gibt die GetExpectedParticles-Methode ein leeres Array zurück. Wenn die GetExpectedParticles-Methode aufgerufen wird, nachdem das title-Element validiert wurde und bevor das description-Element validiert wurde, gibt sie ein Array mit einem einzelnen XmlSchemaElement-Objekt zurück, das das description-Element darstellt. Wenn die GetExpectedParticles-Methode aufgerufen wird, nachdem das description-Element validiert wurde, gibt sie ein Array mit einem einzelnen XmlSchemaAny-Objekt zurück, das den Platzhalter darstellt.

Dim reader As XmlReader =  XmlReader.Create("input.xml") 

Dim schemaSet As XmlSchemaSet =  New XmlSchemaSet() 
schemaSet.Add(Nothing, "schema.xsd")
Dim manager As XmlNamespaceManager =  New XmlNamespaceManager(reader.NameTable) 

Dim validator As XmlSchemaValidator =  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");

XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "schema.xsd");
XmlNamespaceManager manager = new XmlNamespaceManager(reader.NameTable);

XmlSchemaValidator 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 diesem Beispiel wird der folgende XML-Code als Eingabe verwendet.

<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 diesem Beispiel wird das folgende XSD-Schema als Eingabe verwendet.

<book>

<description>My Book's Description</description>

<namespace>System.Xml.Schema</namespace>

</book>

Hinweis:
Die Ergebnisse der Methoden GetExpectedParticles, GetExpectedAttributes und AddSchema der XmlSchemaValidator-Klasse hängen vom aktuellen Kontext ab, der validiert wird. Weitere Informationen finden Sie in diesem Thema im Abschnitt "Validierungskontext".

Ein Beispiel für die GetExpectedParticles-Methode finden Sie im Beispiel in der Einleitung. Weitere Informationen zur GetExpectedParticles-Methode finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Abrufen von erwarteten Attributen

Die GetExpectedAttributes-Methode gibt ein Array von XmlSchemaAttribute-Objekten mit den erwarteten Attributen im aktuellen Elementkontext zurück.

Im Beispiel in der Einleitung werden mit der GetExpectedAttributes-Methode alle Attribute des book-Elements abgerufen.

Wenn Sie die GetExpectedAttributes-Methode unmittelbar nach der ValidateElement-Methode aufrufen, werden alle Attribute zurückgegeben, die im XML-Dokument vorhanden sein können. Wenn Sie jedoch die GetExpectedAttributes-Methode nach einem oder mehreren Aufrufen der ValidateAttribute-Methode aufrufen, werden die Attribute zurückgegeben, die bisher noch nicht für das aktuelle Element validiert wurden.

Hinweis:
Die Ergebnisse der Methoden GetExpectedParticles, GetExpectedAttributes und AddSchema der XmlSchemaValidator-Klasse hängen vom aktuellen Kontext ab, der validiert wird. Weitere Informationen finden Sie in diesem Thema im Abschnitt "Validierungskontext".

Ein Beispiel für die GetExpectedAttributes-Methode finden Sie im Beispiel in der Einleitung. Weitere Informationen zur GetExpectedAttributes-Methode finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Abrufen von nicht angegebenen Standardattributen

Die GetUnspecifiedDefaultAttributes-Methode füllt die angegebene ArrayList mit den XmlSchemaAttribute-Objekten für alle Attribute mit Standardwerten, die noch nicht mithilfe der ValidateAttribute-Methode im Elementkontext validiert wurden. Die GetUnspecifiedDefaultAttributes-Methode muss nach einem Aufruf der ValidateAttribute-Methode für alle Attribute im Elementkontext aufgerufen werden. Mit der GetUnspecifiedDefaultAttributes-Methode muss bestimmt werden, welche Standardattribute in das XML-Dokument eingefügt werden sollen, das validiert wird.

Weitere Informationen zur GetUnspecifiedDefaultAttributes-Methode finden Sie in der Referenzdokumentation der XmlSchemaValidator-Klasse.

Behandeln von Schemavalidierungsereignissen

Schemavalidierungswarnungen und -fehler, die während der Validierung gefunden wurden, werden vom ValidationEventHandler-Ereignis der XmlSchemaValidator-Klasse behandelt.

Schemavalidierungswarnungen weisen einen XmlSeverityType-Wert von Warning auf, und Schemavalidierungsfehler weisen einen XmlSeverityType-Wert von Error auf. Wenn kein ValidationEventHandler zugewiesen wurde, wird eine XmlSchemaValidationException für alle Schemavalidierungsfehler mit einem XmlSeverityType-Wert von Error ausgelöst. Für Schemavalidierungswarnungen mit einem XmlSeverityType-Wert von Warning wird jedoch keine XmlSchemaValidationException ausgelöst.

Das folgende Beispiel für einen ValidationEventHandler, der Schemavalidierungswarnungen und -fehler während der Schemavalidierung empfängt, stammt aus dem Beispiel in der Einleitung.

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

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

Ein vollständiges Beispiel von ValidationEventHandler finden Sie im Beispiel in der Einleitung. Weitere Informationen finden Sie in der Referenzdokumentation der XmlSchemaInfo-Klasse.

Zustandsübergänge von "XmlSchemaValidator"

Die XmlSchemaValidator-Klasse verfügt über einen definierten Zustandsübergang, der die Abfolge und das Vorkommen von Aufrufen der Methoden erzwingt, mit denen Elemente, Attribute und Inhalt in einem XML-Infoset validiert werden.

In der folgenden Tabelle werden die Zustandsübergänge der XmlSchemaValidator-Klasse und die Abfolge und das Vorkommen von Methodenaufrufen erläutert, die in den einzelnen Zuständen auftreten können.

Zustand	Übergang
Validieren	Initialize (ValidateAttribute \| TopLevel*) EndValidation
TopLevel	ValidateWhitespace \| ValidateText \| Element
Element	ValidateElement ValidateAttribute* (ValidateEndOfAttributes Content)? ValidateEndElement \| ValidateElement ValidateAttribute SkipToEndElement \| ValidateElement ValidateAttribute* ValidateEndOfAttributes Content* SkipToEndElement \|
Content	ValidateWhitespace \| ValidateText \| Element

Hinweis:
Von den einzelnen Methoden in der Tabelle oben wird eine InvalidOperationException ausgelöst, wenn der Aufruf der Methode gemäß des aktuellen Zustands eines XmlSchemaValidator-Objekts in der falschen Abfolge ausgeführt wurde.

In der Tabelle der Zustandsübergänge oben werden Satzzeichen verwendet, um die Methoden und andere Zustände zu beschreiben, die für jeden Zustand des Zustandübergangs der XmlSchemaValidator-Klasse aufgerufen werden können. Die verwendeten Symbole entsprechen den Symbolen der XML-Richtlinien für DTD (Document Type Definition).

In der folgenden Tabelle wird beschrieben, welche Auswirkungen die Satzzeichen in der Tabelle der Zustandsübergänge oben auf die Methoden und andere Zustände haben, die für jeden Zustand im Zustandsübergang der XmlSchemaValidator-Klasse aufgerufen werden können.

Zeichen	Beschreibung
\|	Entweder die Methode bzw. der Zustand vor oder die Methode bzw. der Zustand nach dem senkrechten Strich, kann aufgerufen werden.
?	Die Methode oder der Zustand nach dem Fragezeichen ist optional, es kann jedoch nur ein Aufruf der Methode bzw. des Zustands erfolgen.
*	Die Methode bzw. der Zustand nach dem Zeichen "*" ist optional und kann mehr als einmal aufgerufen werden.

Validierungskontext

Die Methoden der XmlSchemaValidator-Klasse, mit denen Elemente, Attribute und Inhalt in einem XML-Infoset validiert werden, ändern den Validierungskontext eines XmlSchemaValidator-Objekts. Die SkipToEndElement-Methode überspringt die Validierung des aktuellen Elementinhalts und bereitet das XmlSchemaValidator-Objekt zum Validieren des Inhalts im Kontext des übergeordneten Elements vor. Dies entspricht dem Überspringen der Validierung aller untergeordneten Elemente des aktuellen Elements und dem anschließenden Aufrufen der ValidateEndElement-Methode.

Die Ergebnisse der Methoden GetExpectedParticles, GetExpectedAttributes und AddSchema der XmlSchemaValidator-Klasse hängen vom aktuellen Kontext ab, der validiert wird.

In der folgenden Tabelle werden die Ergebnisse der Aufrufe dieser Methoden nach dem Aufrufen einer der Methoden der XmlSchemaValidator-Klasse erläutert, mit der Elemente, Attribute und Inhalt in einem XML-Infoset validiert werden.

Methode	GetExpectedParticles	GetExpectedAttributes	AddSchema
Initialize	Wenn die Initialize-Standardmethode aufgerufen wird, gibt GetExpectedParticles ein Array mit allen globalen Elementen zurück. Wenn die überladene Initialize-Methode, die ein XmlSchemaObject als Parameter annimmt, zum Initialisieren der teilweisen Validierung eines Elements aufgerufen wird, gibt GetExpectedParticles nur das Element zurück, mit dem das XmlSchemaValidator-Objekt initialisiert wurde.	Wenn die Initialize-Standardmethode aufgerufen wird, gibt GetExpectedAttributes ein leeres Array zurück. Wenn die Überladung der Initialize-Methode, die ein XmlSchemaObject als Parameter annimmt, zum Initialisieren der teilweisen Validierung eines Attributs aufgerufen wird, gibt GetExpectedAttributes nur das Attribut zurück, mit dem das XmlSchemaValidator-Objekt initialisiert wurde.	Fügt dem XmlSchemaSet des XmlSchemaValidator-Objekts das Schema hinzu, wenn es keine Vorverarbeitungsfehler aufweist.
ValidateElement	Wenn das Kontextelement gültig ist, gibt GetExpectedParticles die Abfolge der Elemente zurück, die als untergeordnete Elemente des Kontextelements erwartet werden. Wenn das Kontextelement ungültig ist, gibt GetExpectedParticles ein leeres Array zurück.	Wenn das Kontextelement gültig ist und ValidateAttribute bisher nicht aufgerufen wurde, gibt GetExpectedAttributes eine Liste aller im Kontextelement definierten Attribute zurück. Wenn einige Attribute bereits validiert wurden, gibt GetExpectedAttributes eine Liste der noch zu validierenden Attribute zurück. Wenn das Kontextelement ungültig ist, gibt GetExpectedAttributes ein leeres Array zurück.	Siehe oben.
ValidateAttribute	Wenn sich das Kontextattribut auf der obersten Ebene befindet, gibt GetExpectedParticles ein leeres Array zurück. Andernfalls gibt GetExpectedParticles die Abfolge der Elemente zurück, die als das erste untergeordnete Element des Kontextelements erwartet werden.	Wenn sich das Kontextattribut auf der obersten Ebene befindet, gibt GetExpectedAttributes ein leeres Array zurück. Andernfalls gibt GetExpectedAttributes die Liste der noch zu validierenden Attribute zurück.	Siehe oben.
GetUnspecifiedDefaultAttributes	GetExpectedParticles gibt die Abfolge der Elemente zurück, die als das erste untergeordnete Element des Kontextelements erwartet werden.	GetExpectedAttributes gibt eine Liste der erforderlichen und optionalen Attribute zurück, die noch für das Kontextelement validiert werden müssen.	Siehe oben.
ValidateEndOfAttributes	GetExpectedParticles gibt die Abfolge der Elemente zurück, die als das erste untergeordnete Element des Kontextelements erwartet werden.	GetExpectedAttributes gibt ein leeres Array zurück.	Siehe oben.
ValidateText	Wenn contentType des Kontextelements Mixed ist, gibt GetExpectedParticles die Abfolge der Elemente zurück, die auf der nächsten Position erwartet werden. Wenn contentType des Kontextelements TextOnly oder Empty ist, gibt GetExpectedParticles ein leeres Array zurück. Wenn contentType des Kontextelements ElementOnly ist, gibt GetExpectedParticles die Abfolge der Elemente zurück, die auf der nächsten Position erwartet werden. Es ist jedoch bereits ein Validierungsfehler aufgetreten.	GetExpectedAttributes gibt die Liste der nicht validierten Attribute des Kontextelements zurück.	Siehe oben.
ValidateWhitespace	Wenn sich der Kontextleerraum auf der obersten Ebene befindet, gibt GetExpectedParticles ein leeres Array zurück. Andernfalls entspricht das Verhalten der GetExpectedParticles-Methode dem von ValidateText.	Wenn sich der Kontextleerraum auf der obersten Ebene befindet, gibt GetExpectedAttributes ein leeres Array zurück. Andernfalls entspricht das Verhalten der GetExpectedAttributes-Methode dem von ValidateText.	Siehe oben.
ValidateEndElement	GetExpectedParticles gibt die Abfolge der Elemente zurück, die nach dem Kontextelement erwartet werden (möglicherweise nebengeordnete Elemente).	GetExpectedAttributes gibt die Liste der nicht validierten Attribute des Kontextelements zurück. Wenn das Kontextelement kein übergeordnetes Element aufweist, gibt GetExpectedAttributes eine leere Liste zurück. (Das Kontextelement ist das übergeordnete Element des aktuellen Elements, für das ValidateEndElement aufgerufen wurde.)	Siehe oben.
SkipToEndElement	Wie in ValidateEndElement.	Wie in ValidateEndElement.	Siehe oben.
EndValidation	Gibt ein leeres Array zurück.	Gibt ein leeres Array zurück.	Siehe oben.

Hinweis:
Die von den verschiedenen Eigenschaften der XmlSchemaValidator-Klasse zurückgegebenen Werte werden nicht durch das Aufrufen einer der Methoden in der oben stehenden Tabelle verändert.

Siehe auch

Referenz

XmlSchemaValidator

Freigeben über