Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

XmlSchemaValidator-Klasse

 

Veröffentlicht: Oktober 2016

Stellt ein XSD-Schema-Validierungsmodul (XML Schema Definition Language) dar. Die XmlSchemaValidator Klasse kann nicht vererbt werden.

Namespace:   System.Xml.Schema
Assembly:  System.Xml (in System.Xml.dll)

System.Object
  System.Xml.Schema.XmlSchemaValidator

public sealed class XmlSchemaValidator

NameBeschreibung
System_CAPS_pubmethodXmlSchemaValidator(XmlNameTable, XmlSchemaSet, IXmlNamespaceResolver, XmlSchemaValidationFlags)

Initialisiert eine neue Instanz der XmlSchemaValidator-Klasse.

NameBeschreibung
System_CAPS_pubpropertyLineInfoProvider

Ruft die Zeilennummerninformationen für den derzeit validierten XML-Knoten ab oder legt diese fest.

System_CAPS_pubpropertySourceUri

Ruft den Quell-URI für den derzeit validierten XML-Knoten ab oder legt diesen fest.

System_CAPS_pubpropertyValidationEventSender

Ruft das als das Absenderobjekt eines Validierungsereignisses gesendete Objekt ab oder legt dieses fest.

System_CAPS_pubpropertyXmlResolver

Legt die XmlResolver -Objekt zum Auflösen xs:import und xs:include Elemente sowie xsi:schemaLocation und xsi:noNamespaceSchemaLocation Attribute.

NameBeschreibung
System_CAPS_pubmethodAddSchema(XmlSchema)

Fügt den für die Validierung verwendeten Schemas ein XSD-Schema (XML Schema Definition Language) hinzu.

System_CAPS_pubmethodEndValidation()

Beendet die Validierung und überprüft die Identitätseinschränkungen für das gesamte XML-Dokument.

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_pubmethodGetExpectedAttributes()

Gibt die erwarteten Attribute für den Kontext des aktuellen Elements zurück.

System_CAPS_pubmethodGetExpectedParticles()

Gibt die erwarteten Partikel im Kontext des aktuellen Elements zurück.

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodGetUnspecifiedDefaultAttributes(ArrayList)

Validiert identitätseinschränkungen bei den Standardattributen und füllt die ArrayList angegebenen XmlSchemaAttribute Objekte für alle Attribute mit Standardwerten, die noch nicht mit validiert wurden die ValidateAttribute Methode im Kontext Elements.

System_CAPS_pubmethodInitialize()

Initialisiert den Zustand des der XmlSchemaValidator Objekt.

System_CAPS_pubmethodInitialize(XmlSchemaObject)

Initialisiert den Zustand des dem XmlSchemaValidator -Objekt unter Verwendung der XmlSchemaObject für die teilweise Validierung angegebenen.

System_CAPS_pubmethodSkipToEndElement(XmlSchemaInfo)

Überspringt die Validierung des aktuellen Elementinhalts und bereitet das XmlSchemaValidator-Objekt zum Validieren des Inhalts im Kontext des übergeordneten Elements vor.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodValidateAttribute(String, String, String, XmlSchemaInfo)

Überprüft den Attributnamen, den Namespace-URI und den Wert im aktuellen Kontext des aktuellen Elements.

System_CAPS_pubmethodValidateAttribute(String, String, XmlValueGetter, XmlSchemaInfo)

Überprüft den Attributnamen, den Namespace-URI und den Wert im aktuellen Kontext des aktuellen Elements.

System_CAPS_pubmethodValidateElement(String, String, XmlSchemaInfo)

Validiert das Element im aktuellen Kontext.

System_CAPS_pubmethodValidateElement(String, String, XmlSchemaInfo, String, String, String, String)

Validiert das Element im aktuellen Kontext mit den xsi:Type, xsi:Nil, xsi:SchemaLocation, und xsi:NoNamespaceSchemaLocation angegebenen Attributwerten.

System_CAPS_pubmethodValidateEndElement(XmlSchemaInfo)

Überprüft, ob der Textinhalt des Elements gemäß seinem Datentyp für Elemente mit einfachem Inhalt gültig ist, und überprüft darüber hinaus, ob der Inhalt des aktuellen Elements für Elemente mit komplexem Inhalt vollständig ist.

System_CAPS_pubmethodValidateEndElement(XmlSchemaInfo, Object)

Überprüft, ob der Textinhalt des angegebenen Elements gemäß seinem Datentyp gültig ist.

System_CAPS_pubmethodValidateEndOfAttributes(XmlSchemaInfo)

Überprüft, ob alle erforderlichen Attribute im Elementkontext vorhanden sind, und bereitet das XmlSchemaValidator-Objekt auf das Validieren des untergeordneten Inhalts des Elements vor.

System_CAPS_pubmethodValidateText(String)

Überprüft, ob der Text string angegeben, die im aktuellen Elementkontext zulässig ist und sammelt den Text für die Validierung, wenn das aktuelle Element einfachen Inhalt aufweist.

System_CAPS_pubmethodValidateText(XmlValueGetter)

Überprüft, ob der zurückgegebene Text die XmlValueGetter angegebene Objekt im aktuellen Elementkontext zulässig ist und sammelt den Text für die Validierung, wenn das aktuelle Element einfachen Inhalt aufweist.

System_CAPS_pubmethodValidateWhitespace(String)

Überprüft, ob der Leerraum im der string angegeben, die im aktuellen Elementkontext zulässig ist und sammelt den Leerraum für die Validierung, wenn das aktuelle Element einfachen Inhalt aufweist.

System_CAPS_pubmethodValidateWhitespace(XmlValueGetter)

Überprüft, ob der Leerraum zurückgegebene der XmlValueGetter angegebene Objekt im aktuellen Elementkontext zulässig ist und sammelt den Leerraum für die Validierung, wenn das aktuelle Element einfachen Inhalt aufweist.

NameBeschreibung
System_CAPS_pubeventValidationEventHandler

Die ValidationEventHandler der schemavalidierungswarnungen und-Fehler während der Schema-Validierung empfängt.

System_CAPS_security Sicherheit Hinweis
  • Verwenden Sie keine Schemata aus unbekannten oder nicht vertrauenswürdigen Quellen oder Speicherorte. Auf diese Weise wird die Sicherheit Ihres Codes beeinträchtigt werden.

  • XML-Schemas (auch Inlineschemas) sind von Natur aus anfällig für DOS-Angriffe. Nehmen Sie diese nicht in nicht vertrauenswürdigen Szenarios.

  • Schema-Validation-Fehlermeldungen und Ausnahmen können vertrauliche Informationen über das Inhaltsmodell oder die Pfade der URI der Schemadatei verfügbar machen. Achten Sie darauf, dass nicht auf diese Informationen, um nicht vertrauenswürdige Aufrufer verfügbar zu machen.

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 auch zum Erstellen von Validierungsmodulen für benutzerdefinierte XML-Datenquellen oder als eine Möglichkeit zum Erstellen eines validierenden XML-Writers verwendet werden.

Weitere Informationen zu den XmlSchemaValidator Klasse, finden Sie unter der Pushbasierte Validierung mit "XmlSchemaValidator" Thema.

System_CAPS_security Sicherheit Hinweis

Die ProcessInlineSchema und ProcessSchemaLocation Validierungsflag ein XmlSchemaValidator Objekt sind nicht standardmäßig sein. Darüber hinaus die XmlResolver Eigenschaft ein XmlSchemaValidator Objekt null standardmäßig. Daher enthalten externe Schemas, die in verwiesen wird, importiert oder neu definierten Elementen nicht standardmäßig aufgelöst.

Das folgende Beispiel überprüft die contosoBooks.xml -Datei anhand der contosoBooks.xsd Schema. 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 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", "http://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();

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

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>

.NET Framework
Verfügbar seit 2.0

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: