Udostępnij przez

XmlSchemaValidator Klasa

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Xml.Schema
Zestaw:
System.Xml.ReaderWriter.dll
Zestaw:
System.Xml.dll
Zestaw:
netstandard.dll

Reprezentuje aparat weryfikacji schematu XML Schema Definition Language (XSD). Nie XmlSchemaValidator można dziedziczyć klasy.

public ref class XmlSchemaValidator sealed
public sealed class XmlSchemaValidator
type XmlSchemaValidator = class
Public NotInheritable Class XmlSchemaValidator
Dziedziczenie
Object
XmlSchemaValidator

Przykłady

Poniższy przykład weryfikuje contosoBooks.xml plik względem schematu contosoBooks.xsd . W przykładzie użyto XmlSerializer klasy do deserializacji contosoBooks.xml pliku i przekazania wartości węzłów do metod XmlSchemaValidator klasy.

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

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 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", "http://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()
    
                ' 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

W przykładzie plik jest pobierany contosoBooks.xml jako dane wejściowe.

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

Przykład przyjmuje contosoBooks.xsd również element jako dane wejściowe.

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

Uwagi

Ważne

  • Nie używaj schematów z nieznanych lub niezaufanych źródeł ani lokalizacji. Spowoduje to naruszenie bezpieczeństwa kodu.
  • Schematy XML (w tym schematy wbudowane) są z natury narażone na ataki typu "odmowa usługi"; nie akceptuj ich w niezaufanych scenariuszach.
  • Komunikaty o błędach weryfikacji schematu i wyjątki mogą ujawniać poufne informacje o modelu zawartości lub ścieżkach identyfikatorów URI do pliku schematu. Uważaj, aby nie ujawniać tych informacji niezaufanym obiektom wywołującym.

Klasa XmlSchemaValidator zapewnia wydajny mechanizm wysokiej wydajności umożliwiający weryfikowanie danych XML względem schematów XML w sposób wypychany. Na przykład XmlSchemaValidator klasa umożliwia zweryfikowanie zestawu informacji XML w miejscu bez konieczności serializacji go jako dokumentu XML, a następnie ponownej analizy dokumentu przy użyciu czytnika xml. Klasa XmlSchemaValidator może również służyć do tworzenia aparatów walidacji za pośrednictwem niestandardowych źródeł danych XML lub jako sposobu tworzenia modułu zapisywania walidacji XML.

Aby uzyskać więcej informacji na temat XmlSchemaValidator klasy, zobacz temat XmlSchemaValidator Push-Based Validation (Walidacja ).

Ważne

Flagi ProcessInlineSchema i ProcessSchemaLocation walidacji XmlSchemaValidator obiektu nie są ustawione jako domyślne. XmlResolver Ponadto właściwość XmlSchemaValidator obiektu jest null domyślnie. W związku z tym schematy zewnętrzne, do których odwołuje się element include, import lub redefine, nie są domyślnie rozwiązywane.

Konstruktory

XmlSchemaValidator(XmlNameTable, XmlSchemaSet, IXmlNamespaceResolver, XmlSchemaValidationFlags)

Inicjuje nowe wystąpienie klasy XmlSchemaValidator.

Właściwości

LineInfoProvider

Pobiera lub ustawia informacje o numerze wiersza dla weryfikowanego węzła XML.
SourceUri

Pobiera lub ustawia źródłowy identyfikator URI dla weryfikowanego węzła XML.
ValidationEventSender

Pobiera lub ustawia obiekt wysłany jako obiekt nadawcy zdarzenia weryfikacji.
XmlResolver

XmlResolver Ustawia obiekt używany do rozpoznawania atrybutów xs:import i xs:include, a także xsi:schemaLocation i xsi:noNamespaceSchemaLocation.

Metody

AddSchema(XmlSchema)

Dodaje schemat języka XML Schema Definition Language (XSD) do zestawu schematów używanych do walidacji.
EndValidation()

Kończy walidację i sprawdza ograniczenia tożsamości dla całego dokumentu XML.
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetExpectedAttributes()

Zwraca oczekiwane atrybuty dla bieżącego kontekstu elementu.
GetExpectedParticles()

Zwraca oczekiwane cząstki w kontekście bieżącego elementu.
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
GetUnspecifiedDefaultAttributes(ArrayList)

Weryfikuje ograniczenia tożsamości dla atrybutów domyślnych i wypełnia ArrayList określony obiektami XmlSchemaAttribute dla wszystkich atrybutów z wartościami domyślnymi, które nie zostały wcześniej zweryfikowane przy użyciu ValidateAttribute metody w kontekście elementu.
Initialize()

Inicjuje stan XmlSchemaValidator obiektu.
Initialize(XmlSchemaObject)

Inicjuje stan XmlSchemaValidator obiektu przy użyciu określonego XmlSchemaObject elementu na potrzeby częściowej walidacji.
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
SkipToEndElement(XmlSchemaInfo)

Pomija walidację zawartości bieżącego elementu i przygotowuje XmlSchemaValidator obiekt do sprawdzania poprawności zawartości w kontekście elementu nadrzędnego.
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
ValidateAttribute(String, String, String, XmlSchemaInfo)

Weryfikuje nazwę atrybutu, identyfikator URI przestrzeni nazw i wartość w bieżącym kontekście elementu.
ValidateAttribute(String, String, XmlValueGetter, XmlSchemaInfo)

Weryfikuje nazwę atrybutu, identyfikator URI przestrzeni nazw i wartość w bieżącym kontekście elementu.
ValidateElement(String, String, XmlSchemaInfo)

Weryfikuje element w bieżącym kontekście.
ValidateElement(String, String, XmlSchemaInfo, String, String, String, String)

Weryfikuje element w bieżącym kontekście przy użyciu określonych wartości atrybutów xsi:Type, xsi:Nil, xsi:SchemaLocation i xsi:NoNamespaceSchemaLocation .
ValidateEndElement(XmlSchemaInfo)

Sprawdza, czy zawartość tekstowa elementu jest prawidłowa zgodnie z jego typem danych dla elementów z prostą zawartością, i sprawdza, czy zawartość bieżącego elementu jest kompletna dla elementów ze złożoną zawartością.
ValidateEndElement(XmlSchemaInfo, Object)

Sprawdza, czy zawartość tekstowa określonego elementu jest prawidłowa zgodnie z typem danych.
ValidateEndOfAttributes(XmlSchemaInfo)

Sprawdza, czy wszystkie wymagane atrybuty w kontekście elementu są obecne i przygotowuje XmlSchemaValidator obiekt do zweryfikowania zawartości podrzędnej elementu.
ValidateText(String)

Sprawdza, czy określony tekst string jest dozwolony w bieżącym kontekście elementu i gromadzi tekst do weryfikacji, jeśli bieżący element ma prostą zawartość.
ValidateText(XmlValueGetter)

Sprawdza, czy tekst zwrócony przez XmlValueGetter określony obiekt jest dozwolony w bieżącym kontekście elementu i gromadzi tekst na potrzeby walidacji, jeśli bieżący element ma prostą zawartość.
ValidateWhitespace(String)

Sprawdza, czy biały odstęp w określonym elemencie jest dozwolony w string bieżącym kontekście elementu i gromadzi biały odstęp na potrzeby walidacji, jeśli bieżący element ma prostą zawartość.
ValidateWhitespace(XmlValueGetter)

Sprawdza, czy biały odstęp zwrócony przez XmlValueGetter określony obiekt jest dozwolony w bieżącym kontekście elementu i gromadzi biały odstęp na potrzeby walidacji, jeśli bieżący element ma prostą zawartość.

Zdarzenia

ValidationEventHandler

Podczas ValidationEventHandler walidacji schematu są wyświetlane ostrzeżenia i błędy sprawdzania poprawności schematu.

Dotyczy

Zobacz też