Condividi tramite

Convalida basata sul metodo push di XmlSchemaValidator

  • Articolo

La classe XmlSchemaValidator fornisce un meccanismo efficiente e a elevate prestazioni per la convalida basata sul metodo push di dati XML in base a schemi XML. Ad esempio, la classe XmlSchemaValidator consente di convalidare un infoset XML sul posto senza la necessità di serializzarlo come documento XML e di eseguire nuovamente l'analisi del documento mediante un lettore XML di convalida.

La classe XmlSchemaValidator può essere usata in scenari avanzati, ad esempio per la compilazione di motori di convalida in base a origini dati XML personalizzate oppure per la compilazione di un writer XML di convalida.

Di seguito è riportato un esempio di utilizzo della classe XmlSchemaValidator per convalidare il file contosoBooks.xml in base allo schema contosoBooks.xsd. Nell'esempio viene usata la classe XmlSerializer per deserializzare il file contosoBooks.xml e passare il valore dei nodi ai metodi della classe XmlSchemaValidator.

Nota

Questo esempio viene usato in tutte le sezioni di questo argomento.

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

Nell'esempio il file contosoBooks.xml viene considerato come input.

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

Anche il file contosoBooks.xsd viene considerato come input.

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

Convalida di dati XML mediante XmlSchemaValidator

Per iniziare la convalida di un infoset XML, è necessario innanzitutto inizializzare una nuova istanza della classe XmlSchemaValidator usando il costruttore XmlSchemaValidator.

Il costruttore XmlSchemaValidator accetta gli oggetti XmlNameTable, XmlSchemaSet, XmlNamespaceManager e un valore XmlSchemaValidationFlags come parametri. L'oggetto XmlNameTable viene usato per atomizzare stringhe note di spazi dei nomi, quali lo spazio dei nomi dello schema, lo spazio dei nomi XML e così via. Tale oggetto viene passato al metodo ParseValue durante la convalida del contenuto semplice. Nell'oggetto XmlSchemaSet sono contenuti gli schemi XML usato per convalidare l'infoset XML. L'oggetto XmlNamespaceManager viene usato per risolvere gli spazi dei nomi rilevati durante la convalida. Il valore XmlSchemaValidationFlags viene usato per disabilitare determinate funzionalità di convalida.

Per altre informazioni sul costruttore XmlSchemaValidator, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Inizializzazione della convalida

Dopo la creazione di un oggetto XmlSchemaValidator, sono disponibili due metodi di overload Initialize usati per inizializzare lo stato dell'oggetto XmlSchemaValidator. Di seguito sono riportati i due metodi Initialize.

Il metodo XmlSchemaValidator.Initialize predefinito consente di inizializzare un oggetto XmlSchemaValidator al relativo stato iniziale e il metodo di overload XmlSchemaValidator.Initialize che accetta un tipo XmlSchemaObject come parametro consente di inizializzare un oggetto XmlSchemaValidator al relativo stato iniziale per la convalida parziale.

È possibile chiamare i metodi Initialize solo dopo la creazione di un oggetto XmlSchemaValidator o la chiamata al metodo EndValidation.

Per un esempio del metodo XmlSchemaValidator.Initialize, vedere l'introduzione. Per altre informazioni sul metodo Initialize, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Convalida parziale

Il metodo XmlSchemaValidator.Initialize che accetta un tipo XmlSchemaObject come parametro consente di inizializzare un oggetto XmlSchemaValidator al relativo stato iniziale per la convalida parziale.

Nell'esempio seguente un tipo XmlSchemaObject viene inizializzato per la convalida parziale usando il metodo XmlSchemaValidator.Initialize. L'elemento dello schema orderNumber viene passato selezionandolo in base al tipo XmlQualifiedName nella raccolta XmlSchemaObjectTable restituita dalla proprietà GlobalElements dell'oggetto XmlSchemaSet. Questo elemento specifico viene quindi convalidato dall'oggetto XmlSchemaValidator.

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

Nell'esempio il seguente schema XML viene considerato come input.

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

Per altre informazioni sul metodo Initialize, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Aggiunta di altri schemi

Per aggiungere uno schema XML al set di schemi usato durante la convalida, viene usando il metodo AddSchema della classe XmlSchemaValidator. Il metodo AddSchema può essere usato per simulare l'effetto prodotto dal rilevamento di uno schema XML inline nell'infoset XML da convalidare.

Nota

Lo spazio dei nomi di destinazione del parametro XmlSchema non può corrispondere ad alcun elemento o attributo già rilevato dall'oggetto XmlSchemaValidator.

Se il valore XmlSchemaValidationFlags.ProcessInlineSchema non è stato passato come parametro al costruttore XmlSchemaValidator, il metodo AddSchema non esegue alcuna operazione.

Il risultato del metodo AddSchema dipende dal contesto corrente del nodo XML da convalidare. Per altre informazioni sui contesti di convalida, vedere la sezione "Contesto di convalida" in questo argomento.

Per altre informazioni sul metodo AddSchema, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Convalida di elementi, attributi e contenuto

La classe XmlSchemaValidator fornisce diversi metodi usati per convalidare elementi, attributi e contenuto in un infoset XML in base a schemi XML. Nella tabella seguente viene descritto ciascuno di questi metodi.

metodo Descrizione
ValidateElement Convalida il nome dell'elemento nel contesto corrente.
ValidateAttribute Convalida l'attributo nel contesto dell'elemento corrente oppure in base all'oggetto XmlSchemaAttribute passato come parametro al metodo Initialize.
ValidateEndOfAttributes Verifica la presenza di tutti gli attributi richiesti nel contesto dell'elemento e prepara l'oggetto XmlSchemaValidator per la convalida del contenuto figlio dell'elemento.
ValidateText Verifica se il testo è consentito nel contesto dell'elemento corrente e accumula il testo da convalidare se l'elemento corrente dispone di contenuto semplice.
ValidateWhitespace Verifica se gli spazi vuoti sono consentiti nel contesto dell'elemento corrente e accumula gli spazi vuoti da convalidare se l'elemento corrente dispone di contenuto semplice.
ValidateEndElement Verifica se il contenuto di testo dell'elemento è valido in base al relativo tipo di dati per gli elementi con contenuto semplice e verifica se il contenuto dell'elemento corrente è completo per gli elementi con contenuto complesso.
SkipToEndElement Ignora la convalida del contenuto dell'elemento corrente e prepara l'oggetto XmlSchemaValidator per la convalida del contenuto nel contesto dell'elemento padre.
EndValidation Termina la convalida e verifica i vincoli di identità per l'intero documento XML se è impostata l'opzione di convalida ProcessIdentityConstraints.

Nota

La classe XmlSchemaValidator presenta una transizione dello stato definita che impone la sequenza e l'occorrenza delle chiamate effettuate a ciascuno dei metodi descritti nella tabella precedente. La transizione dello stato specifica per la classe XmlSchemaValidator è descritta nella sezione "Transizione dello stato di XmlSchemaValidator" di questo argomento.

Per un esempio dei metodi usati per convalidare elementi, attributi e contenuto di un infoset XML, vedere l'esempio nella sezione precedente. Per altre informazioni su questi metodi, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Convalida del contenuto mediante XmlValueGetter

Il XmlValueGetterdelegate può essere usato per passare il valore di nodi Attribute, di nodi di tipo text o di nodi con spazi vuoti come tipi CLR (Common Language Runtime) compatibili con il tipo XSD (XML Schema Definition Language) del nodo Attribute, di tipo text o con spazi vuoti. Un XmlValueGetterdelegate è utile se il valore CLR di un nodo Attribute, di un nodo di tipo text o di un nodo con spazi vuoti è già disponibile. Inoltre, evita la necessità di convertire il nodo in string e di analizzarlo nuovamente per la convalida.

I metodi di overload ValidateAttribute, ValidateText e ValidateWhitespace accettano il valore dei nodi Attribute, dei nodi di tipo text o dei nodi con spazi vuoti come string o come XmlValueGetterdelegate.

I seguenti metodi della classe XmlSchemaValidator accettano un tipo XmlValueGetterdelegate come parametro.

Di seguito è riportato un XmlValueGetterdelegate di esempio descritto nell'esempio della classe XmlSchemaValidator nell'introduzione. Il XmlValueGetterdelegate restituisce il valore di un attributo come oggetto DateTime. Per convalidare l'oggetto DateTime restituito dall'oggetto XmlValueGetter, l'oggetto XmlSchemaValidator lo converte innanzitutto in ValueType (ovvero nel mapping predefinito di CLR per il tipo XSD) per il tipo di dati dell'attributo, quindi verifica i facet nel valore convertito.

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

Per un esempio completo dell'oggetto XmlValueGetterdelegate, vedere l'introduzione. Per altre informazioni sul XmlValueGetterdelegate, vedere la documentazione di riferimento per il tipo XmlValueGetter e per la classe XmlSchemaValidator.

informazioni sulla convalida post-schema

La classe XmlSchemaInfo rappresenta alcune delle informazioni di convalida post-schema di un nodo XML convalidata dalla classe XmlSchemaValidator. Diversi metodi della classe XmlSchemaValidator accettano un oggetto XmlSchemaInfo come parametro null (out) facoltativo.

Una volta eseguita la convalida, le proprietà dell'oggetto XmlSchemaInfo vengono impostate con i risultati della convalida. Ad esempio, dopo la convalida di un attributo usando il metodo ValidateAttribute, le proprietà XmlSchemaInfo, SchemaAttribute, SchemaType e MemberType dell'oggetto Validity, se specificate, vengono impostate con i risultati della convalida.

Il seguente metodo della classe XmlSchemaValidator accetta un oggetto XmlSchemaInfo come parametro out.

Per un esempio completo della classe XmlSchemaInfo, vedere l'introduzione. Per altre informazioni sulla classe XmlSchemaInfo, vedere la documentazione di riferimento per la classe XmlSchemaInfo.

Recupero di particelle e attributi previsti e di attributi predefiniti non specificati

La classe XmlSchemaValidator fornisce i metodi GetExpectedAttributes, GetExpectedParticles e GetUnspecifiedDefaultAttributes per il recupero di particelle e attributi previsti e di attributi predefiniti non specificati nel contesto di convalida corrente.

Recupero di particelle previste

Il metodo GetExpectedParticles restituisce una matrice di oggetti XmlSchemaParticle contenenti le particelle previste nel contesto dell'elemento corrente. Le particelle valide che possono essere restituite dal metodo GetExpectedParticles sono istanze delle classi XmlSchemaElement e XmlSchemaAny.

Se il compositor per il modello di contenuto è xs:sequence, verrà restituita solo la particella successiva nella sequenza. Se il compositor per il modello di contenuto è xs:all o xs:choice, verranno restituite tutte le particelle che possono seguire nel contesto dell'elemento corrente.

Nota

Se il metodo GetExpectedParticles viene chiamato subito dopo il metodo Initialize, il metodo GetExpectedParticles restituirà tutti gli elementi globali.

Ad esempio, nello schema XSD (XML Schema Definition Language) e nel documento XML seguenti, dopo la convalida dell'elemento book, l'elemento book è il contesto dell'elemento corrente. Il metodo GetExpectedParticles restituisce una matrice contenente un singolo oggetto XmlSchemaElement che rappresenta l'elemento title. Se il contesto di convalida è l'elemento title, il metodo GetExpectedParticles restituisce una matrice vuota. Se il metodo GetExpectedParticles viene chiamato dopo la convalida dell'elemento title ma prima della convalida dell'elemento description, restituirà una matrice contenente un singolo oggetto XmlSchemaElement che rappresenta l'elemento description. Se il metodo GetExpectedParticles viene chiamato dopo la convalida dell'elemento description, restituirà una matrice contenente un singolo oggetto XmlSchemaAny che rappresenta il carattere jolly.

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

Nell'esempio il seguente XML viene considerato come input:

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

Nell'esempio il seguente schema XSD viene considerato come input:

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

Nota

I risultati dei metodi GetExpectedParticles, GetExpectedAttributes e AddSchema della classe XmlSchemaValidator dipendono dal contesto corrente da convalidare. Per altre informazioni, vedere la sezione "Contesto di convalida" in questo argomento.

Per un esempio del metodo GetExpectedParticles, vedere l'introduzione. Per altre informazioni sul metodo GetExpectedParticles, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Recupero di attributi previsti

Il metodo GetExpectedAttributes restituisce una matrice di oggetti XmlSchemaAttribute contenenti gli attributi previsti nel contesto dell'elemento corrente.

Ad esempio, nell'esempio dell'introduzione il metodo GetExpectedAttributes viene usato per recuperare tutti gli attributi dell'elemento book.

Se il metodo GetExpectedAttributes viene chiamato subito dopo il metodo ValidateElement, verranno restituiti tutti gli attributi che possono essere presenti nel documento XML. Tuttavia, se il metodo GetExpectedAttributes viene chiamato dopo una o più chiamate al metodo ValidateAttribute, verranno restituiti gli attributi che non sono ancora stati convalidati per l'elemento corrente.

Nota

I risultati dei metodi GetExpectedParticles, GetExpectedAttributes e AddSchema della classe XmlSchemaValidator dipendono dal contesto corrente da convalidare. Per altre informazioni, vedere la sezione "Contesto di convalida" in questo argomento.

Per un esempio del metodo GetExpectedAttributes, vedere l'introduzione. Per altre informazioni sul metodo GetExpectedAttributes, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Recupero di attributi predefiniti non specificati

Il metodo GetUnspecifiedDefaultAttributes compila il tipo ArrayList specificato con gli oggetti XmlSchemaAttribute per gli attributi con valori predefiniti che non sono stati convalidati in precedenza usando il metodo ValidateAttribute nel contesto dell'elemento. Il metodo GetUnspecifiedDefaultAttributes deve essere chiamato dopo aver chiamato il metodo ValidateAttribute in ogni attributo del contesto dell'elemento. Il metodo GetUnspecifiedDefaultAttributes deve essere usato per determinare gli attributi predefiniti da inserire nel documento XML da convalidare, è necessario usare .

Per altre informazioni sul metodo GetUnspecifiedDefaultAttributes, vedere la documentazione di riferimento per la classe XmlSchemaValidator.

Gestione degli eventi di convalida dello schema

Gli avvisi e gli errori di convalida dello schema rilevati durante la convalida sono gestiti dall'evento ValidationEventHandler della classe XmlSchemaValidator.

Gli avvisi di convalida dello schema presentano un valore XmlSeverityType pari a Warning mentre gli errori di convalida dello schema presentano un valore XmlSeverityType pari a Error. Se non è stato assegnato alcun evento ValidationEventHandler, verrà generato un tipo XmlSchemaValidationException per tutti gli errori di convalida dello schema con un valore XmlSeverityType pari a Error. Tuttavia, non verrà generato un tipo XmlSchemaValidationException per gli avvisi di convalida dello schema con un valore XmlSeverityType pari a Warning.

Di seguito è riportato un esempio di un tiValidationEventHandler che riceve avvisi ed errori di convalida dello schema rilevati durante la convalida dello schema nell'esempio dell'introduzione.

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

Per un esempio completo dell'oggetto ValidationEventHandler, vedere l'introduzione. Per altre informazioni, vedere la documentazione di riferimento per la classe XmlSchemaInfo.

Transizione dello stato di XmlSchemaValidator

La classe XmlSchemaValidator presenta una transizione dello stato definita che impone la sequenza e l'occorrenza delle chiamate effettuate a ciascuno dei metodi usati per convalidare elementi, attributi e contenuto di un infoset XML.

Nella tabella seguente vengono descritti la transizione dello stato della classe XmlSchemaValidator, nonché la sequenza e l'occorrenza delle chiamate del metodo che possono essere effettuate in ciascuno stato.

Provincia Transizione
Convalida Initialize (ValidateAttribute | TopLevel*) EndValidation
TopLevel ValidateWhitespace | ValidateText | Elemento
Elemento ValidateElement ValidateAttribute* (ValidateEndOfAttributes Contenuto*)? ValidateEndElement |

ValidateElement ValidateAttribute* SkipToEndElement |

ValidateElement ValidateAttribute* ValidateEndOfAttributes Contenuto* SkipToEndElement |
Contenuto ValidateWhitespace | ValidateText | Elemento

Nota

Se la chiamata al metodo non viene effettuata nella sequenza corretta in base allo stato corrente di un oggetto InvalidOperationException, verrà generato un oggetto XmlSchemaValidator da parte di ciascuno dei metodi della tabella precedente.

Nella tabella precedente, relativa alla transizione dello stato, vengono usati i segni di punteggiatura per descrivere i metodi e alti stati che possono essere chiamati per ciascuno stato di transizione della classe XmlSchemaValidator. I segni usati sono gli stessi del riferimento agli standard XML per la DTD (Document Type Definition).

Nella tabella seguente vengono descritti gli effetti dei segni di punteggiatura della tabella precedente relativa alla transizione dello stato sui metodi e su altri stati che possono essere chiamati per ciascuno stato di transizione della classe XmlSchemaValidator.

Simbolo Descrizione
| È possibile chiamare il metodo o lo stato che precede o che segue la barra.
? Il metodo o lo stato che precede il punto interrogativo è facoltativo. Tuttavia, se viene chiamato, può essere chiamato solo una volta.
* Il metodo o lo stato che precede il simbolo * è facoltativo e può essere chiamato più di una volta.

Contesto di convalida

I metodi della classe XmlSchemaValidator usati per convalidare elementi, attributi e contenuto in un infoset XML modificano il contesto di convalida di un oggetto XmlSchemaValidator. Ad esempio, il metodo SkipToEndElement ignora la convalida del contenuto dell'elemento corrente e prepara l'oggetto XmlSchemaValidator per la convalida del contenuto nel contesto dell'elemento padre. Dal punto di vista funzionale, equivale a ignorare la convalida di tutti gli elementi figlio dell'elemento corrente e a chiamare il metodo ValidateEndElement.

I risultati dei metodi GetExpectedParticles, GetExpectedAttributes e AddSchema della classe XmlSchemaValidator dipendono dal contesto corrente da convalidare.

Nella tabella seguente vengono descritti i risultati della chiamata di questi metodi dopo aver chiamato uno dei metodi della classe XmlSchemaValidator usata per convalidare elementi, attributi e contenuto di un insieme di informazioni XML.

metodo GetExpectedParticles GetExpectedAttributes AddSchema
Initialize Se viene chiamato il metodo predefinito Initialize, il metodo GetExpectedParticles restituirà una matrice contenente tutti gli elementi globali.

Se il metodo di overload Initialize che accetta un tipo XmlSchemaObject come parametro viene chiamato per inizializzare la convalida parziale di un elemento, il metodo GetExpectedParticles restituirà solo l'elemento con cui viene inizializzato l'oggetto XmlSchemaValidator.		 Se viene chiamato il metodo predefinito Initialize, il metodo GetExpectedAttributes restituirà una matrice vuota.

Se il metodo di overload Initialize che accetta un tipo XmlSchemaObject come parametro viene chiamato per inizializzare la convalida parziale di un attributo, il metodo GetExpectedAttributes restituirà solo l'attributo con cui viene inizializzato l'oggetto XmlSchemaValidator.		 Aggiunge lo schema al tipo XmlSchemaSet dell'oggetto XmlSchemaValidator se non si verificano errori di pre-elaborazione.
ValidateElement Se l'elemento di contesto è valido, il metodo GetExpectedParticles restituirà la sequenza di elementi prevista come elementi figlio dell'elemento di contesto.

Se l'elemento di contesto è non valido, il metodo GetExpectedParticles restituirà una matrice vuota.		 Se l'elemento di contesto è valido e se non è stata effettuata in precedenza alcuna chiamata a ValidateAttribute, il metodo GetExpectedAttributes restituirà un elenco di tutti gli attributi definiti nell'elemento di contesto.

Se alcuni attributi sono già stati convalidati, il metodo GetExpectedAttributes restituirà un elenco degli attributi rimanenti da convalidare.

Se l'elemento di contesto è non valido, il metodo GetExpectedAttributes restituirà una matrice vuota.		 Come sopra.
ValidateAttribute Se l'attributo di contesto è un attributo di primo livello, il metodo GetExpectedParticles restituirà una matrice vuota.

In caso contrario, il metodo GetExpectedParticles restituirà la sequenza di elementi prevista come primo elemento figlio dell'elemento di contesto.		 Se l'attributo di contesto è un attributo di primo livello, il metodo GetExpectedAttributes restituirà una matrice vuota.

In caso contrario, il metodo GetExpectedAttributes restituirà l'elenco degli attributi rimanenti da convalidare.		 Come sopra.
GetUnspecifiedDefaultAttributes GetExpectedParticles restituisce la sequenza di elementi prevista come primo elemento figlio dell'elemento di contesto. Il metodo GetExpectedAttributes restituisce un elenco degli attributi obbligatori e facoltativi che devono ancora essere convalidati per l'elemento di contesto. Come sopra.
ValidateEndOfAttributes GetExpectedParticles restituisce la sequenza di elementi prevista come primo elemento figlio dell'elemento di contesto. Il metodo GetExpectedAttributes restituisce una matrice vuota. Come sopra.
ValidateText Se contentType dell'elemento di contesto è Mixed, il metodo GetExpectedParticles restituirà la sequenza di elementi prevista nella posizione successiva.

Se contentType dell'elemento di contesto è TextOnly o Empty, il metodo GetExpectedParticles restituirà una matrice vuota.

Se contentType dell'elemento di contesto è ElementOnly, il metodo GetExpectedParticles restituirà la sequenza di elementi prevista nella posizione successiva. Tuttavia, si è già verificato un errore di convalida.		 Il metodo GetExpectedAttributes restituisce un elenco degli attributi non convalidati per l'elemento di contesto. Come sopra.
ValidateWhitespace Se lo spazio vuoto di contesto è uno spazio vuoto di primo livello, il metodo GetExpectedParticles restituirà una matrice vuota.

In caso contrario, il comportamento del metodo GetExpectedParticles sarà lo stesso di ValidateText.		 Se lo spazio vuoto di contesto è uno spazio vuoto di primo livello, il metodo GetExpectedAttributes restituirà una matrice vuota.

In caso contrario, il comportamento del metodo GetExpectedAttributes sarà lo stesso di ValidateText.		 Come sopra.
ValidateEndElement Il metodo GetExpectedParticles restituisce la sequenza di elementi prevista dopo l'elemento di contesto, ovvero gli eventuali elementi di pari livello. Il metodo GetExpectedAttributes restituisce un elenco degli attributi non convalidati per l'elemento di contesto.

Se l'elemento di contesto non presenta un elemento padre, il metodo GetExpectedAttributes restituirà un elenco vuoto. L'elemento di contesto è l'elemento padre dell'elemento corrente in cui è stato chiamato ValidateEndElement.		 Come sopra.
SkipToEndElement Uguale a ValidateEndElement. Uguale a ValidateEndElement. Come sopra.
EndValidation Restituisce una matrice vuota. Restituisce una matrice vuota. Come sopra.

Nota

La chiamata dei metodi descritti nella tabella precedente non influisce sul valore restituito dalle diverse proprietà della classe XmlSchemaValidator.

Vedi anche