Pushbasierte Validierung mit „XmlSchemaValidator“

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 Validierungs-Engines 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.

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 diesem Beispiel wird die Datei contosoBooks.xml als Eingabe verwendet.

<?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 diesem Beispiel wird auch contosoBooks.xsd als Eingabe verwendet.

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

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.

• XmlSchemaValidator.Initialize

• XmlSchemaValidator.Initialize

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.

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.

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 Leerzeichenknoten als CLR-Typ (Common Language Runtime) übergeben werden, der mit dem XSD-Typ (XML Schema Definition Language) des Attribut-, Text- oder Leerzeichenknotens kompatibel ist. XmlValueGetterdelegate ist hilfreich, wenn der CLR-Wert eines Attribut-, Text- oder Leerzeichenknotens bereits verfügbar ist, und erspart die Kosten für die Konvertierung in string und die anschließende erneute 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.

• ValidateAttribute

• ValidateText

• ValidateWhitespace

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 DateTime zurückgegebenen XmlValueGetter-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(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 XmlSchemaInfo, SchemaAttribute, SchemaType und MemberType des Validity-Objekts, sofern angegeben, auf die Ergebnisse der Validierung festgelegt.

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

• SkipToEndElement

• ValidateAttribute

• ValidateAttribute

• ValidateElement

• ValidateElement

• ValidateEndElement

• ValidateEndElement

• ValidateEndOfAttributes

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.

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 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 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>
  <title>My Book</title>
  <description>My Book's Description</description>
  <namespace>System.Xml.Schema</namespace>
</book>

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.

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 XmlSchemaValidationException-Wert von XmlSeverityType wird jedoch keine Warning 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(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;
    }
}

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.

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.

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.

Siehe auch

• XmlSchemaValidator