Convalida basata sul metodo push di XmlSchemaValidator
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 utilizzata 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 utilizzata la classe XmlSerializer per deserializzare il file contosoBooks.xml e passare il valore dei nodi ai metodi della classe XmlSchemaValidator.
.gif "Nota") Nota |
|---|
Questo esempio viene utilizzato in tutte le sezioni di questo argomento. |
Imports System
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("https://www.contoso.com/books", "contosoBooks.xsd")
' The XmlNamespaceManager object used to handle namespaces.
Dim manager As XmlNamespaceManager = New XmlNamespaceManager(reader.NameTable)
' Assign a ValidationEventHandler to handle schema validation warnings and errors.
Dim validator As XmlSchemaValidator = New XmlSchemaValidator(reader.NameTable, schemaSet, manager, XmlSchemaValidationFlags.None)
'validator.ValidationEventHandler += New ValidationEventHandler(SchemaValidationEventHandler)
AddHandler validator.ValidationEventHandler, AddressOf SchemaValidationEventHandler
' Initialize the XmlSchemaValidator object.
validator.Initialize()
' Validate the bookstore element, verify that all required attributes are present
' and prepare to validate child content.
validator.ValidateElement("bookstore", "https://www.contoso.com/books", Nothing)
validator.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", "https://www.contoso.com/books", Nothing)
' Get the exptected attributes for the book element.
Console.Write(vbCrLf & "Expected attributes: ")
Dim attributes() As XmlSchemaAttribute = validator.GetExpectedAttributes()
For Each attribute As XmlSchemaAttribute In attributes
Console.Write("'{0}' ", attribute.Name)
Next
Console.WriteLine()
' Validate the genre attribute and display its post schema validation information.
If Not book.Genre Is Nothing Then
validator.ValidateAttribute("genre", "", book.Genre, schemaInfo)
End If
DisplaySchemaInfo()
' Validate the publicationdate attribute and display its post schema validation information.
If Not book.PublicationDate = Nothing Then
validator.ValidateAttribute("publicationdate", "", dateTimeGetter(book.PublicationDate), schemaInfo)
End If
DisplaySchemaInfo()
' Validate the ISBN attribute and display its post schema validation information.
If Not book.Isbn Is Nothing Then
validator.ValidateAttribute("ISBN", "", book.Isbn, schemaInfo)
End If
DisplaySchemaInfo()
' 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", "https://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Title)
' Validate the author element, verify that all required attributes are present
' and prepare to validate child content.
validator.ValidateElement("author", "https://www.contoso.com/books", Nothing)
validator.GetUnspecifiedDefaultAttributes(New ArrayList())
validator.ValidateEndOfAttributes(Nothing)
If Not book.Author.Name Is Nothing Then
' Validate the name element and its content.
validator.ValidateElement("name", "https://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Author.Name)
End If
If Not book.Author.FirstName Is Nothing Then
' Validate the first-name element and its content.
validator.ValidateElement("first-name", "https://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Author.FirstName)
End If
If Not book.Author.LastName Is Nothing Then
' Validate the last-name element and its content.
validator.ValidateElement("last-name", "https://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Author.LastName)
End If
' Validate the content of the author element.
validator.ValidateEndElement(Nothing)
' Validate the price element and its content.
validator.ValidateElement("price", "https://www.contoso.com/books", Nothing)
validator.ValidateEndElement(Nothing, book.Price)
' Validate the content of the book element.
validator.ValidateEndElement(Nothing)
Next
' Validate the content of the bookstore element.
validator.ValidateEndElement(Nothing)
' Close the XmlReader object.
reader.Close()
End Sub
Shared schemaInfo As XmlSchemaInfo = New XmlSchemaInfo()
Shared dateTimeGetterContent As Object
Shared Function dateTimeGetterHandle() As Object
Return dateTimeGetterContent
End Function
Shared Function dateTimeGetter(ByVal dateTime As DateTime) As XmlValueGetter
dateTimeGetterContent = dateTime
Return New XmlValueGetter(AddressOf dateTimeGetterHandle)
End Function
Shared Sub DisplaySchemaInfo()
If Not schemaInfo.SchemaElement Is Nothing Then
Console.WriteLine("Element '{0}' with type '{1}' is '{2}'", schemaInfo.SchemaElement.Name, schemaInfo.SchemaType, schemaInfo.Validity)
ElseIf Not schemaInfo.SchemaAttribute Is Nothing Then
Console.WriteLine("Attribute '{0}' with type '{1}' is '{2}'", schemaInfo.SchemaAttribute.Name, schemaInfo.SchemaType, schemaInfo.Validity)
End If
End Sub
Shared Sub SchemaValidationEventHandler(ByVal sender As Object, ByVal e As ValidationEventArgs)
Select Case e.Severity
Case XmlSeverityType.Error
Console.WriteLine(vbCrLf & "Error: {0}", e.Message)
Exit Sub
Case XmlSeverityType.Warning
Console.WriteLine(vbCrLf & "Warning: {0}", e.Message)
Exit Sub
End Select
End Sub
End Class
<XmlRootAttribute("bookstore", Namespace:="https://www.contoso.com/books", IsNullable:=False)> _
Public Class ContosoBooks
<XmlElementAttribute("book")> _
Public book() As BookType
End Class
Public Class BookType
<XmlAttributeAttribute("genre")> _
Public Genre As String
<XmlAttributeAttribute("publicationdate", DataType:="date")> _
Public PublicationDate As DateTime
<XmlAttributeAttribute("ISBN")> _
Public Isbn As String
<XmlElementAttribute("title")> _
Public Title As String
<XmlElementAttribute("author")> _
Public Author As BookAuthor
<XmlElementAttribute("price")> _
Public Price As Decimal
End Class
Public Class BookAuthor
<XmlElementAttribute("name")> _
Public Name As String
<XmlElementAttribute("first-name")> _
Public FirstName As String
<XmlElementAttribute("last-name")> _
Public LastName As String
End Class
End Namespace
using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
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("https://www.contoso.com/books", "contosoBooks.xsd");
// The XmlNamespaceManager object used to handle namespaces.
XmlNamespaceManager manager = new XmlNamespaceManager(reader.NameTable);
// Assign a ValidationEventHandler to handle schema validation warnings and errors.
XmlSchemaValidator validator = new XmlSchemaValidator(reader.NameTable, schemaSet, manager, XmlSchemaValidationFlags.None);
validator.ValidationEventHandler += new ValidationEventHandler(SchemaValidationEventHandler);
// Initialize the XmlSchemaValidator object.
validator.Initialize();
// Validate the bookstore element, verify that all required attributes are present
// and prepare to validate child content.
validator.ValidateElement("bookstore", "https://www.contoso.com/books", null);
validator.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", "https://www.contoso.com/books", null);
// Get the exptected attributes for the book element.
Console.Write("\nExpected attributes: ");
XmlSchemaAttribute[] attributes = validator.GetExpectedAttributes();
foreach (XmlSchemaAttribute attribute in attributes)
{
Console.Write("'{0}' ", attribute.Name);
}
Console.WriteLine();
// Validate the genre attribute and display its post schema validation information.
if (book.Genre != null)
{
validator.ValidateAttribute("genre", "", book.Genre, schemaInfo);
}
DisplaySchemaInfo();
// Validate the publicationdate attribute and display its post schema validation information.
if (book.PublicationDate != null)
{
validator.ValidateAttribute("publicationdate", "", dateTimeGetter(book.PublicationDate), schemaInfo);
}
DisplaySchemaInfo();
// Validate the ISBN attribute and display its post schema validation information.
if (book.Isbn != null)
{
validator.ValidateAttribute("ISBN", "", book.Isbn, schemaInfo);
}
DisplaySchemaInfo();
// 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", "https://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Title);
// Validate the author element, verify that all required attributes are present
// and prepare to validate child content.
validator.ValidateElement("author", "https://www.contoso.com/books", null);
validator.GetUnspecifiedDefaultAttributes(new ArrayList());
validator.ValidateEndOfAttributes(null);
if (book.Author.Name != null)
{
// Validate the name element and its content.
validator.ValidateElement("name", "https://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Author.Name);
}
if (book.Author.FirstName != null)
{
// Validate the first-name element and its content.
validator.ValidateElement("first-name", "https://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Author.FirstName);
}
if (book.Author.LastName != null)
{
// Validate the last-name element and its content.
validator.ValidateElement("last-name", "https://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Author.LastName);
}
// Validate the content of the author element.
validator.ValidateEndElement(null);
// Validate the price element and its content.
validator.ValidateElement("price", "https://www.contoso.com/books", null);
validator.ValidateEndElement(null, book.Price);
// Validate the content of the book element.
validator.ValidateEndElement(null);
}
// Validate the content of the bookstore element.
validator.ValidateEndElement(null);
// Close the XmlReader object.
reader.Close();
}
static XmlSchemaInfo schemaInfo = new XmlSchemaInfo();
static object dateTimeGetterContent;
static object dateTimeGetterHandle()
{
return dateTimeGetterContent;
}
static XmlValueGetter dateTimeGetter(DateTime dateTime)
{
dateTimeGetterContent = dateTime;
return new XmlValueGetter(dateTimeGetterHandle);
}
static void DisplaySchemaInfo()
{
if (schemaInfo.SchemaElement != null)
{
Console.WriteLine("Element '{0}' with type '{1}' is '{2}'",
schemaInfo.SchemaElement.Name, schemaInfo.SchemaType, schemaInfo.Validity);
}
else if (schemaInfo.SchemaAttribute != null)
{
Console.WriteLine("Attribute '{0}' with type '{1}' is '{2}'",
schemaInfo.SchemaAttribute.Name, schemaInfo.SchemaType, schemaInfo.Validity);
}
}
static void SchemaValidationEventHandler(object sender, ValidationEventArgs e)
{
switch (e.Severity)
{
case XmlSeverityType.Error:
Console.WriteLine("\nError: {0}", e.Message);
break;
case XmlSeverityType.Warning:
Console.WriteLine("\nWarning: {0}", e.Message);
break;
}
}
}
[XmlRootAttribute("bookstore", Namespace = "https://www.contoso.com/books", IsNullable = false)]
public class ContosoBooks
{
[XmlElementAttribute("book")]
public BookType[] Book;
}
public class BookType
{
[XmlAttributeAttribute("genre")]
public string Genre;
[XmlAttributeAttribute("publicationdate", DataType = "date")]
public DateTime PublicationDate;
[XmlAttributeAttribute("ISBN")]
public string Isbn;
[XmlElementAttribute("title")]
public string Title;
[XmlElementAttribute("author")]
public BookAuthor Author;
[XmlElementAttribute("price")]
public Decimal Price;
}
public class BookAuthor
{
[XmlElementAttribute("name")]
public string Name;
[XmlElementAttribute("first-name")]
public string FirstName;
[XmlElementAttribute("last-name")]
public string LastName;
}
}
Nell'esempio il file contosoBooks.xml viene considerato come input.
<?xml version="1.0" encoding="utf-8" ?>
<bookstore xmlns="https://www.contoso.com/books">
<book genre="autobiography" publicationdate="1981-03-22" ISBN="1-861003-11-0">
<title>The Autobiography of Benjamin Franklin</title>
<author>
<first-name>Benjamin</first-name>
<last-name>Franklin</last-name>
</author>
<price>8.99</price>
</book>
<book genre="novel" publicationdate="1967-11-17" ISBN="0-201-63361-2">
<title>The Confidence Man</title>
<author>
<first-name>Herman</first-name>
<last-name>Melville</last-name>
</author>
<price>11.99</price>
</book>
<book genre="philosophy" publicationdate="1991-02-15" ISBN="1-861001-57-6">
<title>The Gorgias</title>
<author>
<name>Plato</name>
</author>
<price>9.99</price>
</book>
</bookstore>
Anche il file contosoBooks.xsd viene considerato come input.
<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="https://www.contoso.com/books" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="bookstore">
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs="unbounded" name="book">
<xs:complexType>
<xs:sequence>
<xs:element name="title" type="xs:string" />
<xs:element name="author">
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="0" name="name" type="xs:string" />
<xs:element minOccurs="0" name="first-name" type="xs:string" />
<xs:element minOccurs="0" name="last-name" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="price" type="xs:decimal" />
</xs:sequence>
<xs:attribute name="genre" type="xs:string" use="required" />
<xs:attribute name="publicationdate" type="xs:date" use="required" />
<xs:attribute name="ISBN" type="xs:string" use="required" />
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Convalida di dati XML mediante XmlSchemaValidator
Per iniziare la convalida di un infoset XML, è necessario innanzitutto inizializzare una nuova istanza della classe XmlSchemaValidator utilizzando il costruttore XmlSchemaValidator.
Il costruttore XmlSchemaValidator accetta gli oggetti XmlNameTable, XmlSchemaSet, XmlNamespaceManager e un valore XmlSchemaValidationFlags come parametri. L'oggetto XmlNameTable viene utilizzato 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 utilizzato per convalidare l'infoset XML. L'oggetto XmlNamespaceManager viene utilizzato per risolvere gli spazi dei nomi rilevati durante la convalida. Il valore XmlSchemaValidationFlags viene utilizzato per disabilitare determinate funzionalità di convalida.
Per ulteriori 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 utilizzati 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 ulteriori 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 utilizzando 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 ulteriori informazioni sul metodo Initialize, vedere la documentazione di riferimento per la classe XmlSchemaValidator.
Aggiunta di ulteriori schemi
Per aggiungere uno schema XML al set di schemi utilizzato durante la convalida, viene utilizzando il metodo AddSchema della classe XmlSchemaValidator. Il metodo AddSchema può essere utilizzato 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 ulteriori informazioni sui contesti di convalida, vedere la sezione "Contesto di convalida" in questo argomento.
Per ulteriori 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 utilizzati 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 |
|---|---|
Convalida il nome dell'elemento nel contesto corrente. |
|
Convalida l'attributo nel contesto dell'elemento corrente oppure in base all'oggetto XmlSchemaAttribute passato come parametro al metodo Initialize. |
|
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. |
|
Verifica se il testo è consentito nel contesto dell'elemento corrente e accumula il testo da convalidare se l'elemento corrente dispone di contenuto semplice. |
|
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. |
|
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. |
|
Ignora la convalida del contenuto dell'elemento corrente e prepara l'oggetto XmlSchemaValidator per la convalida del contenuto nel contesto dell'elemento padre. |
|
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 utilizzati per convalidare elementi, attributi e contenuto di un infoset XML, vedere l'esempio nella sezione precedente. Per ulteriori informazioni su questi metodi, vedere la documentazione di riferimento per la classe XmlSchemaValidator.
Convalida del contenuto mediante XmlValueGetter
Il XmlValueGetter delegatepuò essere utilizzato 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 delegate XmlValueGetter è 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 delegate XmlValueGetter.
I metodi seguenti della classe XmlSchemaValidator accettano un oggetto delegate XmlValueGetter come parametro.
Di seguito è riportato un oggetto delegate XmlValueGetter di esempio descritto nell'esempio della classe XmlSchemaValidator nell'introduzione. Il delegate XmlValueGetter 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(ByVal dateTime As DateTime) As XmlValueGetter
dateTimeGetterContent = dateTime
Return New XmlValueGetter(AddressOf dateTimeGetterHandle)
End Function
static object dateTimeGetterContent;
static object dateTimeGetterHandle()
{
return dateTimeGetterContent;
}
static XmlValueGetter dateTimeGetter(DateTime dateTime)
{
dateTimeGetterContent = dateTime;
return new XmlValueGetter(dateTimeGetterHandle);
}
Per un esempio completo dell'oggetto delegate XmlValueGetter, vedere l'introduzione. Per ulteriori informazioni sul delegate XmlValueGetter, 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 out (null) 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 utilizzando il metodo ValidateAttribute, le proprietà SchemaAttribute, SchemaType, MemberType e Validity dell'oggetto XmlSchemaInfo, se specificate, vengono impostate con i risultati della convalida.
I metodi seguenti della classe XmlSchemaValidator accetta un oggetto XmlSchemaInfo come parametro out.
Per un esempio completo della classe XmlSchemaInfo, vedere l'introduzione. Per ulteriori 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 XmlSchemaSet = New XmlSchemaSet()
schemaSet.Add(Nothing, "schema.xsd")
Dim manager As XmlNamespaceManager = New XmlNamespaceManager(reader.NameTable)
Dim validator As XmlSchemaValidator = New XmlSchemaValidator(reader.NameTable,schemaSet,manager,XmlSchemaValidationFlags.None)
validator.Initialize()
validator.ValidateElement("book", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
For Each element As XmlSchemaElement In validator.GetExpectedParticles()
Console.WriteLine(element.Name)
Next
validator.ValidateElement("title", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
For Each element As XmlSchemaElement In validator.GetExpectedParticles()
Console.WriteLine(element.Name)
Next
validator.ValidateEndElement(Nothing)
For Each element As XmlSchemaElement In validator.GetExpectedParticles()
Console.WriteLine(element.Name)
Next
validator.ValidateElement("description", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
validator.ValidateEndElement(Nothing)
For Each particle As XmlSchemaParticle In validator.GetExpectedParticles()
Console.WriteLine(particle.GetType())
Next
validator.ValidateElement("namespace", "", Nothing)
validator.ValidateEndOfAttributes(Nothing)
validator.ValidateEndElement(Nothing)
validator.ValidateEndElement(Nothing)
XmlReader reader = XmlReader.Create("input.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "schema.xsd");
XmlNamespaceManager manager = new XmlNamespaceManager(reader.NameTable);
XmlSchemaValidator validator = new XmlSchemaValidator(reader.NameTable, schemaSet, manager, XmlSchemaValidationFlags.None);
validator.Initialize();
validator.ValidateElement("book", "", null);
validator.ValidateEndOfAttributes(null);
foreach (XmlSchemaElement element in validator.GetExpectedParticles())
{
Console.WriteLine(element.Name);
}
validator.ValidateElement("title", "", null);
validator.ValidateEndOfAttributes(null);
foreach (XmlSchemaElement element in validator.GetExpectedParticles())
{
Console.WriteLine(element.Name);
}
validator.ValidateEndElement(null);
foreach (XmlSchemaElement element in validator.GetExpectedParticles())
{
Console.WriteLine(element.Name);
}
validator.ValidateElement("description", "", null);
validator.ValidateEndOfAttributes(null);
validator.ValidateEndElement(null);
foreach (XmlSchemaParticle particle in validator.GetExpectedParticles())
{
Console.WriteLine(particle.GetType());
}
validator.ValidateElement("namespace", "", null);
validator.ValidateEndOfAttributes(null);
validator.ValidateEndElement(null);
validator.ValidateEndElement(null);
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 ulteriori informazioni, vedere la sezione "Contesto di convalida" in questo argomento. |
Per un esempio del metodo GetExpectedParticles, vedere l'introduzione. Per ulteriori 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 utilizzato 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 ulteriori informazioni, vedere la sezione "Contesto di convalida" in questo argomento. |
Per un esempio del metodo GetExpectedAttributes, vedere l'introduzione. Per ulteriori 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 utilizzando 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 utilizzato per determinare gli attributi predefiniti da inserire nel documento XML da convalidare, è necessario utilizzare .
Per ulteriori 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(ByVal sender As Object, ByVal e As ValidationEventArgs)
Select Case e.Severity
Case XmlSeverityType.Error
Console.WriteLine(vbCrLf & "Error: {0}", e.Message)
Exit Sub
Case XmlSeverityType.Warning
Console.WriteLine(vbCrLf & "Warning: {0}", e.Message)
Exit Sub
End Select
End Sub
static void SchemaValidationEventHandler(object sender, ValidationEventArgs e)
{
switch (e.Severity)
{
case XmlSeverityType.Error:
Console.WriteLine("\nError: {0}", e.Message);
break;
case XmlSeverityType.Warning:
Console.WriteLine("\nWarning: {0}", e.Message);
break;
}
}
Per un esempio completo del tipo ValidationEventHandler, vedere l'introduzione. Per ulteriori 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 utilizzati 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.
Stato |
Transizione |
|---|---|
Validate |
Initialize (ValidateAttribute | TopLevel*) EndValidation |
TopLevel |
ValidateWhitespace | ValidateText | Element |
Element |
ValidateElement ValidateAttribute* (ValidateEndOfAttributes Content*)? ValidateEndElement | ValidateElement ValidateAttribute* SkipToEndElement | ValidateElement ValidateAttribute* ValidateEndOfAttributes Content* SkipToEndElement | |
Content |
ValidateWhitespace | ValidateText | Element |
| Nota |
|---|
Se la chiamata al metodo non viene effettuata nella sequenza corretta in base allo stato corrente di un oggetto XmlSchemaValidator, verrà generato un oggetto InvalidOperationException da parte di ciascuno dei metodi della tabella precedente. |
Nella tabella precedente, relativa alla transizione dello stato, vengono utilizzati 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 utilizzati 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 utilizzati 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 utilizzata per convalidare elementi, attributi e contenuto di un infoset XML.
Metodo |
GetExpectedParticles |
GetExpectedAttributes |
AddSchema |
|---|---|---|---|
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. |
|
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. |
Vedi sopra. |
|
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. |
Vedi sopra. |
|
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. |
Vedi sopra. |
|
GetExpectedParticles restituisce la sequenza di elementi prevista come primo elemento figlio dell'elemento di contesto. |
Il metodo GetExpectedAttributes restituisce una matrice vuota. |
Vedi sopra. |
|
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. |
Vedi sopra. |
|
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. |
Vedi sopra. |
|
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. |
Vedi sopra. |
|
Uguale a ValidateEndElement. |
Uguale a ValidateEndElement. |
Vedi sopra. |
|
Restituisce una matrice vuota. |
Restituisce una matrice vuota. |
Vedi sopra. |
| Nota |
|---|
La chiamata dei metodi descritti nella tabella precedente non influisce sul valore restituito dalle diverse proprietà della classe XmlSchemaValidator. |