Validación de XmlSchemaValidator Push-Based

2025-06-19

La XmlSchemaValidator clase proporciona un mecanismo eficaz y de alto rendimiento para validar los datos XML contra esquemas XML de manera push. Por ejemplo, la XmlSchemaValidator clase permite validar un conjunto de información XML en contexto sin tener que serializarlo como un documento XML y, a continuación, volver a analizar el documento mediante un lector XML de validación.

La XmlSchemaValidator clase se puede usar en escenarios avanzados, como la creación de motores de validación a través de orígenes de datos XML personalizados o como una manera de crear un escritor XML de validación.

A continuación se muestra un ejemplo del uso de la clase XmlSchemaValidator para validar el archivo contosoBooks.xml contra el esquema contosoBooks.xsd. En el ejemplo se usa la XmlSerializer clase para deserializar el contosoBooks.xml archivo y pasar el valor de los nodos a los métodos de la XmlSchemaValidator clase .

Nota:

Este ejemplo se usa en las secciones de este tema.

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: '{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 '{schemaInfo.SchemaElement.Name}' with type '{schemaInfo.SchemaType}' is '{schemaInfo.Validity}'");
            }
            else if (schemaInfo.SchemaAttribute != null)
            {
                Console.WriteLine($"Attribute '{schemaInfo.SchemaAttribute.Name}' with type '{schemaInfo.SchemaType}' is '{schemaInfo.Validity}'");
            }
        }

        static void SchemaValidationEventHandler(object sender, ValidationEventArgs e)
        {
            switch (e.Severity)
            {
                case XmlSeverityType.Error:
                    Console.WriteLine($"\nError: {e.Message}");
                    break;
                case XmlSeverityType.Warning:
                    Console.WriteLine($"\nWarning: {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

En el ejemplo se toma el archivo contosoBooks.xml como entrada.

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

El ejemplo también toma el contosoBooks.xsd como entrada.

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

Validación de datos XML mediante XmlSchemaValidator

Para empezar a validar un conjunto de información XML, primero debe inicializar una nueva instancia de la XmlSchemaValidator clase mediante el XmlSchemaValidator constructor .

El XmlSchemaValidator constructor toma XmlNameTablelos objetos , XmlSchemaSety XmlNamespaceManager como parámetros, así como un XmlSchemaValidationFlags valor como parámetro. El objeto XmlNameTable se utiliza para atomizar cadenas bien conocidas de espacios de nombres, como el espacio de nombres de esquema, el espacio de nombres XML, etc., y se pasa al método ParseValue mientras se valida contenido simple. El XmlSchemaSet objeto contiene los esquemas XML usados para validar el conjunto de información XML. El XmlNamespaceManager objeto se usa para resolver los espacios de nombres encontrados durante la validación. El XmlSchemaValidationFlags valor se usa para deshabilitar determinadas características de validación.

Para obtener más información sobre el XmlSchemaValidator constructor, consulte la documentación de referencia de clases XmlSchemaValidator .

Inicialización de la validación

Después de construir un XmlSchemaValidator objeto, hay dos métodos sobrecargados Initialize que se usan para inicializar el estado del XmlSchemaValidator objeto. A continuación se muestran los dos Initialize métodos.

El método predeterminado XmlSchemaValidator.Initialize inicializa un XmlSchemaValidator objeto en su estado inicial y el método sobrecargado XmlSchemaValidator.Initialize que toma XmlSchemaObject como parámetro inicializa un XmlSchemaValidator objeto en su estado inicial para la validación parcial.

Solo se puede llamar a ambos Initialize métodos inmediatamente después de construir un XmlSchemaValidator objeto o después de una llamada a EndValidation.

Para obtener un ejemplo del XmlSchemaValidator.Initialize método , vea el ejemplo de la introducción. Para obtener más información sobre el Initialize método, consulte la documentación de referencia de clases XmlSchemaValidator .

Validación parcial

El XmlSchemaValidator.Initialize método que toma XmlSchemaObject como parámetro inicializa un XmlSchemaValidator objeto en su estado inicial para la validación parcial.

En el siguiente ejemplo, se inicializa un XmlSchemaObject para la validación parcial utilizando el método XmlSchemaValidator.Initialize. Para pasar el elemento de esquema orderNumber, se selecciona por XmlQualifiedName en la colección XmlSchemaObjectTable que devuelve la propiedad GlobalElements del objeto XmlSchemaSet. A continuación, el XmlSchemaValidator objeto valida este elemento específico.

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

En el ejemplo se toma el siguiente esquema XML como entrada.

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

Para obtener más información sobre el Initialize método, consulte la documentación de referencia de clases XmlSchemaValidator .

Agregar esquemas adicionales

El AddSchema método de la XmlSchemaValidator clase se usa para agregar un esquema XML al conjunto de esquemas usados durante la validación. El AddSchema método se puede usar para simular el efecto de encontrar un esquema XML insertado en el conjunto de información XML que se está validando.

Nota:

El espacio de nombres de destino del XmlSchema parámetro no puede coincidir con el de ningún elemento o atributo ya encontrado por el XmlSchemaValidator objeto .

Si el XmlSchemaValidationFlags.ProcessInlineSchema valor no se pasó como parámetro al XmlSchemaValidator constructor, el AddSchema método no hace nada.

El resultado del AddSchema método depende del contexto de nodo XML actual que se valida. Para obtener más información sobre los contextos de validación, vea la sección "Contexto de validación" de este tema.

Para obtener más información sobre el AddSchema método, consulte la documentación de referencia de clases XmlSchemaValidator .

Validar elementos, atributos y contenido

La XmlSchemaValidator clase proporciona varios métodos usados para validar elementos, atributos y contenido en un conjunto de información XML con esquemas XML. En la tabla siguiente se describe cada uno de estos métodos.

Método	Descripción
ValidateElement	Valida el nombre del elemento en el contexto actual.
ValidateAttribute	Valida el atributo en el contexto del elemento actual o con el objeto XmlSchemaAttribute que se pasa como parámetro al método Initialize.
ValidateEndOfAttributes	Comprueba si todos los atributos necesarios del contexto de elemento están presentes y prepara el XmlSchemaValidator objeto para validar el contenido secundario del elemento.
ValidateText	Valida si se permite texto en el contexto del elemento actual y acumula el texto para la validación si el elemento actual tiene contenido simple.
ValidateWhitespace	Valida si se permite el espacio en blanco en el contexto del elemento actual y acumula el espacio en blanco para validar si el elemento actual tiene contenido simple.
ValidateEndElement	Comprueba si el contenido de texto del elemento es válido según su tipo de datos para los elementos con contenido simple y comprueba si el contenido del elemento actual está completo para los elementos con contenido complejo.
SkipToEndElement	Omite la validación del contenido del elemento actual y prepara el objeto para validar el XmlSchemaValidator contenido en el contexto del elemento primario.
EndValidation	Finaliza la validación y comprueba las restricciones de identidad para todo el documento XML si se establece la ProcessIdentityConstraints opción de validación.

Nota:

La XmlSchemaValidator clase tiene una transición de estado definida que impone la secuencia y la ocurrencia de las llamadas realizadas a cada uno de los métodos descritos en la tabla anterior. La transición de estado específica de la XmlSchemaValidator clase se describe en la sección "Transición de estado xmlSchemaValidator" de este tema.

Para obtener un ejemplo de los métodos usados para validar elementos, atributos y contenido en un conjunto de información XML, vea el ejemplo de la sección anterior. Para obtener más información sobre estos métodos, consulte la documentación de referencia de clases XmlSchemaValidator .

Validación de contenido mediante xmlValueGetter

XmlValueGetter delegate se puede utilizar para pasar el valor de los nodos de atributos, textos o espacios en blanco como tipos Common Language Runtime (CLR) compatibles con el tipo del lenguaje de definición de esquema XML (XSD) del nodo de atributos, textos o espacios en blanco. XmlValueGetter delegate es útil si el valor CLR de un nodo de atributos, textos o espacios en blanco ya está disponible y evita el costo de convertirlo en un valor string y luego volver a analizarlo para validarlo.

Los ValidateAttribute, ValidateText y ValidateWhitespace métodos se sobrecargan y aceptan el valor de los nodos de atributo, texto o espacio en blanco como un string o XmlValueGetterdelegate.

Los siguientes métodos de la clase XmlSchemaValidator aceptan un XmlValueGetterdelegate como parámetro.

A continuación, se ofrece un ejemplo de un XmlValueGetterdelegate tomado del ejemplo de la clase XmlSchemaValidator de la introducción. XmlValueGetter delegate devuelve el valor de un atributo como un DateTime objeto . Para validar este DateTime objeto devuelto por XmlValueGetter, el XmlSchemaValidator objeto lo convierte primero en ValueType (ValueType es la asignación CLR predeterminada para el tipo XSD) para el tipo de datos del atributo y, a continuación, comprueba las facetas en el valor convertido.

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

Para obtener un ejemplo completo de XmlValueGetterdelegate, vea el ejemplo de la introducción. Para obtener más información sobre XmlValueGetterdelegate, vea la documentación de referencia de las clases XmlValueGetter y XmlSchemaValidator.

Información posterior a la validación del esquema

La clase XmlSchemaInfo representa parte del post-esquemaValidation-Information de un nodo XML validado por la clase XmlSchemaValidator. Varios métodos de la XmlSchemaValidator clase aceptan un XmlSchemaInfo objeto como parámetro opcional (null ). out

Tras la validación correcta, las propiedades del XmlSchemaInfo objeto se establecen con los resultados de la validación. Por ejemplo, tras la validación correcta de un atributo mediante el método ValidateAttribute, las propiedades XmlSchemaInfo, SchemaAttribute, SchemaType, y MemberType del objeto Validity se establecen con los resultados de la validación.

Los métodos de clase siguientes XmlSchemaValidator aceptan un XmlSchemaInfo objeto como parámetro out.

Para obtener un ejemplo completo de la XmlSchemaInfo clase , vea el ejemplo de la introducción. Para obtener más información sobre la XmlSchemaInfo clase, consulte la documentación de referencia de clases XmlSchemaInfo .

Recuperación de partículas y atributos esperados y atributos predeterminados no especificados

La XmlSchemaValidator clase proporciona los GetExpectedAttributesmétodos , GetExpectedParticlesy GetUnspecifiedDefaultAttributes para recuperar las partículas, atributos y atributos predeterminados no especificados esperados en el contexto de validación actual.

Recuperación de partículas esperadas

El GetExpectedParticles método devuelve una matriz de XmlSchemaParticle objetos que contienen las partículas esperadas en el contexto del elemento actual. Las partículas válidas que el método puede devolver GetExpectedParticles son instancias de las XmlSchemaElement clases y XmlSchemaAny .

Cuando el compositor del modelo de contenido es xs:sequence, solo se devuelve la siguiente partícula de la secuencia. Si el compositor del modelo de contenido es un xs:all o un xs:choice, se devuelven todas las partículas válidas que podrían seguir en el contexto del elemento actual.

Nota:

Si se llama al GetExpectedParticles método inmediatamente después de llamar al Initialize método , el GetExpectedParticles método devuelve todos los elementos globales.

Por ejemplo, en el esquema del lenguaje de definición de esquemas XML (XSD) y en el documento XML que sigue, después de validar el book elemento, el book elemento es el contexto del elemento actual. El GetExpectedParticles método devuelve una matriz que contiene un único XmlSchemaElement objeto que representa el title elemento . Cuando el contexto de validación es el title elemento , el GetExpectedParticles método devuelve una matriz vacía. Si se llama al GetExpectedParticles método después de validar el title elemento, pero antes de que se haya validado el description elemento, devuelve una matriz que contiene un único XmlSchemaElement objeto que representa el description elemento. Si se llama al GetExpectedParticles método después de validar el description elemento, devuelve una matriz que contiene un único XmlSchemaAny objeto que representa el carácter comodín.

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

En el ejemplo se toma el siguiente XML como entrada:

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

En el ejemplo se toma el siguiente esquema XSD como entrada:

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

Nota:

Los resultados de los GetExpectedParticlesmétodos , GetExpectedAttributesy AddSchema de la XmlSchemaValidator clase dependen del contexto actual que se valida. Para obtener más información, vea la sección "Contexto de validación" de este tema.

Para obtener un ejemplo del GetExpectedParticles método , vea el ejemplo de la introducción. Para obtener más información sobre el GetExpectedParticles método, consulte la documentación de referencia de clases XmlSchemaValidator .

Recuperación de atributos esperados

El GetExpectedAttributes método devuelve una matriz de XmlSchemaAttribute objetos que contiene los atributos esperados en el contexto del elemento actual.

Por ejemplo, en el ejemplo de la introducción, el GetExpectedAttributes método se usa para recuperar todos los atributos del book elemento.

Si llama al GetExpectedAttributes método inmediatamente después del ValidateElement método , se devuelven todos los atributos que podrían aparecer en el documento XML. Sin embargo, si llama al GetExpectedAttributes método después de una o varias llamadas al ValidateAttribute método , se devuelven los atributos que aún no se han validado para el elemento actual.

Nota:

Para obtener un ejemplo del GetExpectedAttributes método , vea el ejemplo de la introducción. Para obtener más información sobre el GetExpectedAttributes método, consulte la documentación de referencia de clases XmlSchemaValidator .

Recuperación de atributos predeterminados no especificados

El método GetUnspecifiedDefaultAttributes rellena el ArrayList, que se especifica, con XmlSchemaAttribute objetos para los atributos con valores predeterminados que no se han validado previamente mediante el método ValidateAttribute en el contexto del elemento. El método GetUnspecifiedDefaultAttributes se debería llamar después de llamar al método ValidateAttribute en cada atributo del contexto del elemento. El GetUnspecifiedDefaultAttributes método debe usarse para determinar qué atributos predeterminados se van a insertar en el documento XML que se va a validar.

Para obtener más información sobre el GetUnspecifiedDefaultAttributes método, consulte la documentación de referencia de clases XmlSchemaValidator .

Control de eventos de validación de esquema

Las advertencias y errores de validación de esquemas detectados durante la validación se controlan mediante el ValidationEventHandler evento de la XmlSchemaValidator clase .

Las advertencias de validación de esquemas tienen un valor XmlSeverityType de Warning y los errores de validación de esquemas tienen un valor XmlSeverityType de Error. Si no se ha asignado ningún ValidationEventHandler, se inicia una XmlSchemaValidationException para todos los errores de validación de esquemas con un valor XmlSeverityType de Error. Sin embargo, no se inicia una XmlSchemaValidationException para las advertencias de validación de esquemas con un valor XmlSeverityType de Warning.

A continuación se muestra un ejemplo de que ValidationEventHandler recibe advertencias de validación de esquema y errores detectados durante la validación de esquema tomada del ejemplo de la introducción.

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

Para obtener un ejemplo completo de ValidationEventHandler, vea el ejemplo de la introducción. Para más información, consulte la documentación de referencia de la clase XmlSchemaInfo.

Transición de estado de XmlSchemaValidator

La XmlSchemaValidator clase tiene una transición de estado definida que aplica la secuencia y repetición de llamadas realizadas a cada uno de los métodos usados para validar elementos, atributos y contenido en un conjunto de información XML.

En la tabla siguiente se describe la transición de estado de la XmlSchemaValidator clase y la secuencia y repetición de llamadas de método que se pueden realizar en cada estado.

Estado	Transición
Validación	Initialize (ValidateAttribute \| TopLevel*) EndValidation
TopLevel	ValidateWhitespace \| ValidateText \| Elemento
Elemento	ValidateElement ValidateAttribute* (ValidateEndOfAttributes Contenido)? ValidateEndElement \| ValidateElement ValidateAttribute SkipToEndElement \| ValidateElement ValidateAttribute * ValidateEndOfAttributes Contenido* SkipToEndElement \|
Contenido	ValidateWhitespace \| ValidateText \| Elemento

Nota:

Cada uno de los métodos de la tabla anterior inicia una InvalidOperationException cuando se realiza la llamada al método en la secuencia incorrecta de acuerdo con el estado actual de un objeto XmlSchemaValidator.

La tabla de transición de estado anterior usa símbolos de puntuación para describir los métodos y otros estados a los que se puede llamar para cada estado de la transición de estado de la XmlSchemaValidator clase. Los símbolos usados son los mismos símbolos que se encuentran en la referencia de estándares XML para la definición de tipo de documento (DTD).

En la tabla siguiente se describe cómo afectan los símbolos de puntuación que se encuentran en la tabla de transición de estado anterior a los métodos y otros estados a los que se puede llamar para cada estado de la transición de estado de la XmlSchemaValidator clase.

Símbolo	Descripción
\|	Se puede llamar al método o al estado (al que está antes o después de la barra).
?	El método o el estado que precede al signo de interrogación es opcional, pero si se llama solo se puede llamar una vez.
*	El método o el estado que precede al símbolo * es opcional y puede ser llamado más de una vez.

Contexto de validación

Los métodos de la XmlSchemaValidator clase que se usan para validar elementos, atributos y contenido en un conjunto de información XML, cambian el contexto de validación de un XmlSchemaValidator objeto. Por ejemplo, el método SkipToEndElement omite la validación del contenido del elemento actual y prepara el objeto XmlSchemaValidator para validar contenido en el contexto del elemento primario; es equivalente a la omisión de la validación para todos los elementos secundarios del elemento actual y luego a la llamada del método ValidateEndElement.

Los resultados de los GetExpectedParticlesmétodos , GetExpectedAttributesy AddSchema de la XmlSchemaValidator clase dependen del contexto actual que se valida.

En la tabla siguiente se describen los resultados de llamar a estos métodos después de llamar a uno de los métodos de la XmlSchemaValidator clase que se usan para validar elementos, atributos y contenido en un conjunto de información XML.

Método	GetExpectedParticles	ObtenerAtributosEsperados	AñadirEsquema
Initialize	Si se llama al método predeterminado Initialize , GetExpectedParticles devuelve una matriz que contiene todos los elementos globales. Si se llama al método sobrecargado Initialize que toma como XmlSchemaObject parámetro para inicializar la validación parcial de un elemento, GetExpectedParticles devuelve solo el elemento al que se inicializó el XmlSchemaValidator objeto.	Si se llama al método predeterminado Initialize , GetExpectedAttributes devuelve una matriz vacía. Si se llama a la sobrecarga del método Initialize que toma un XmlSchemaObject como parámetro para inicializar la validación parcial de un atributo, GetExpectedAttributes devuelve solo el atributo en el cual se ha inicializado el objeto XmlSchemaValidator.	Agrega el esquema al XmlSchemaSet del XmlSchemaValidator objeto si no tiene errores de preprocesamiento.
ValidateElement	Si el elemento de contexto es válido, GetExpectedParticles devuelve la secuencia de elementos esperados como elementos secundarios del elemento de contexto. Si el elemento de contexto no es válido, GetExpectedParticles devuelve una matriz vacía.	Si el elemento de contexto es válido y si no se ha realizado ninguna llamada a ValidateAttribute , GetExpectedAttributes devuelve una lista de todos los atributos definidos en el elemento de contexto. Si ya se han validado algunos atributos, GetExpectedAttributes devuelve una lista de los atributos restantes que se van a validar. Si el elemento de contexto no es válido, GetExpectedAttributes devuelve una matriz vacía.	Igual que antes.
ValidateAttribute	Si el atributo de contexto es un atributo de nivel superior, GetExpectedParticles devuelve una matriz vacía. De lo contrario, GetExpectedParticles devuelve la secuencia de elementos esperados como primer hijo del elemento de contexto.	Si el atributo de contexto es un atributo de nivel superior, GetExpectedAttributes devuelve una matriz vacía. De lo contrario, GetExpectedAttributes devuelve la lista de atributos restantes que se van a validar.	Igual que antes.
GetUnspecifiedDefaultAttributes	GetExpectedParticles devuelve la secuencia de elementos previstos como primer hijo del elemento de contexto.	GetExpectedAttributes devuelve una lista de los atributos obligatorios y opcionales que todavía se van a validar para el elemento de contexto.	Igual que antes.
ValidateEndOfAttributes	GetExpectedParticles devuelve la secuencia de elementos previstos como primer hijo del elemento de contexto.	GetExpectedAttributes devuelve una matriz vacía.	Igual que antes.
ValidateText	Si contentType del elemento de contexto es Mixed, GetExpectedParticles devuelve la secuencia de elementos esperados en la siguiente posición. Si el contentType del elemento de contexto es TextOnly o Empty, GetExpectedParticles devuelve una matriz vacía. Si el contentType del elemento de contexto es ElementOnly, GetExpectedParticles devuelve la secuencia de elementos esperados en la siguiente posición, pero ya se ha producido un error de validación.	GetExpectedAttributes devuelve la lista de atributos del elemento de contexto no validado.	Igual que antes.
ValidateWhitespace	Si el espacio en blanco del contexto es espacio en blanco de nivel superior, GetExpectedParticles devuelve una matriz vacía. De lo contrario, el GetExpectedParticles comportamiento del método es el mismo que en ValidateText.	Si el espacio en blanco del contexto es espacio en blanco de nivel superior, GetExpectedAttributes devuelve una matriz vacía. De lo contrario, el GetExpectedAttributes comportamiento del método es el mismo que en ValidateText.	Igual que antes.
ValidateEndElement	GetExpectedParticles devuelve la secuencia de elementos esperados después del elemento de contexto (posibles elementos del mismo nivel).	GetExpectedAttributes devuelve la lista de atributos del elemento de contexto no validado. Si el elemento de contexto no tiene ningún elemento primario, GetExpectedAttributes devuelve una lista vacía (el elemento de contexto es el elemento primario del elemento actual en el que ValidateEndElement se llamó).	Igual que antes.
SkipToEndElement	Igual a ValidateEndElement.	Igual a ValidateEndElement.	Igual que antes.
EndValidation	Devuelve una matriz vacía.	Devuelve una matriz vacía.	Igual que antes.

Nota:

Los valores devueltos por las distintas propiedades de la XmlSchemaValidator clase no se modifican llamando a ninguno de los métodos de la tabla anterior.

Consulte también

XmlSchemaValidator

Compartir a través de

Validación de XmlSchemaValidator Push-Based

Validación de datos XML mediante XmlSchemaValidator

Inicialización de la validación

Validación parcial

Agregar esquemas adicionales

Validar elementos, atributos y contenido

Validación de contenido mediante xmlValueGetter

Información posterior a la validación del esquema

Recuperación de partículas y atributos esperados y atributos predeterminados no especificados

Recuperación de partículas esperadas

Recuperación de atributos esperados

Recuperación de atributos predeterminados no especificados

Control de eventos de validación de esquema

Transición de estado de XmlSchemaValidator

Contexto de validación

Consulte también

Comentarios

Recursos adicionales