Condividi tramite

Percorrere gli schemi XML

L'attraversamento di uno schema XML tramite l'API SOM (Schema Object Model) consente di accedere agli elementi, agli attributi e ai tipi archiviati in SOM. L'attraversamento di uno schema XML caricato in SOM è anche il primo passaggio per la modifica di un XML Schema tramite l'API SOM.

Attraversamento di uno schema XML

Le proprietà seguenti della classe XmlSchema forniscono l'accesso alla raccolta di tutti gli elementi globali aggiunti allo schema XML.

Proprietà Tipo di oggetto archiviato nella raccolta o nella matrice
Elements XmlSchemaElement
Attributes XmlSchemaAttribute
AttributeGroups XmlSchemaAttributeGroup
Groups XmlSchemaGroup
Includes XmlSchemaExternal, XmlSchemaInclude, XmlSchemaImporto XmlSchemaRedefine
Items XmlSchemaObject (fornisce l'accesso a tutti gli elementi, gli attributi e i tipi globali).
Notations XmlSchemaNotation
SchemaTypes XmlSchemaType, XmlSchemaSimpleType, XmlSchemaComplexType
UnhandledAttributes XmlAttribute (fornisce l'accesso agli attributi che non appartengono allo spazio dei nomi dello schema)

Nota

Tutte le proprietà elencate nella tabella precedente, ad eccezione della proprietà Items, sono proprietà post-schema-Compilation-Infoset (PSCI) che non sono disponibili fino alla compilazione dello schema. La proprietà Items è una proprietà di pre-compilazione dello schema che può essere utilizzata prima della compilazione dello schema per accedere e modificare tutti gli elementi, gli attributi e i tipi a livello globale.

La proprietà UnhandledAttributes consente di accedere a tutti gli attributi che non appartengono allo spazio dei nomi dello schema. Questi attributi non vengono elaborati dal processore dello schema.

Nell'esempio di codice seguente viene illustrato l'attraversamento dello schema del cliente creato nell'argomento Compilazione di XML Schema . Nell'esempio di codice viene illustrato l'attraversamento dello schema usando le raccolte descritte in precedenza e vengono scritti tutti gli elementi e gli attributi nello schema nella console.

L'esempio attraversa lo schema del cliente nei passaggi seguenti.

  1. Aggiunge lo schema del cliente a un nuovo oggetto XmlSchemaSet e quindi lo compila. Eventuali avvisi ed errori di convalida dello schema rilevati durante la lettura o la compilazione dello schema vengono gestiti dal delegato ValidationEventHandler.

  2. Recupera l'oggetto XmlSchema compilato dal XmlSchemaSet eseguendo l'iterazione sulla proprietà Schemas. Poiché lo schema viene compilato, le proprietà post-schema-Compilation-Infoset (PSCI) sono accessibili.

  3. Scorre ogni XmlSchemaElement nella raccolta Values della raccolta di post-compilazione dello schema XmlSchema.Elements che scrive il nome di ogni elemento nella console.

  4. Ottiene il tipo complesso dell'elemento Customer utilizzando la classe XmlSchemaComplexType.

  5. Se il tipo complesso contiene attributi, ottiene un IDictionaryEnumerator per enumerare ogni XmlSchemaAttribute e scriverne il nome nella console.

  6. Ottiene la particella di sequenza del tipo complesso utilizzando la classe XmlSchemaSequence.

  7. Itera su ogni XmlSchemaElement nella raccolta XmlSchemaSequence.Items scrivendo il nome di ciascun elemento figlio nella console.

Di seguito è riportato l'esempio di codice completo.

using System;
using System.Collections;
using System.Xml;
using System.Xml.Schema;

class XmlSchemaTraverseExample
{
    static void Main()
    {
        // Add the customer schema to a new XmlSchemaSet and compile it.
        // Any schema validation warnings and errors encountered reading or
        // compiling the schema are handled by the ValidationEventHandler delegate.
        XmlSchemaSet schemaSet = new XmlSchemaSet();
        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
        schemaSet.Add("http://www.tempuri.org", "customer.xsd");
        schemaSet.Compile();

        // Retrieve the compiled XmlSchema object from the XmlSchemaSet
        // by iterating over the Schemas property.
        XmlSchema customerSchema = null;
        foreach (XmlSchema schema in schemaSet.Schemas())
        {
            customerSchema = schema;
        }

        // Iterate over each XmlSchemaElement in the Values collection
        // of the Elements property.
        foreach (XmlSchemaElement element in customerSchema.Elements.Values)
        {

            Console.WriteLine($"Element: {element.Name}");

            // Get the complex type of the Customer element.
            XmlSchemaComplexType complexType = element.ElementSchemaType as XmlSchemaComplexType;

            // If the complex type has any attributes, get an enumerator
            // and write each attribute name to the console.
            if (complexType.AttributeUses.Count > 0)
            {
                IDictionaryEnumerator enumerator =
                    complexType.AttributeUses.GetEnumerator();

                while (enumerator.MoveNext())
                {
                    XmlSchemaAttribute attribute =
                        (XmlSchemaAttribute)enumerator.Value;

                    Console.WriteLine($"Attribute: {attribute.Name}");
                }
            }

            // Get the sequence particle of the complex type.
            XmlSchemaSequence sequence = complexType.ContentTypeParticle as XmlSchemaSequence;

            // Iterate over each XmlSchemaElement in the Items collection.
            foreach (XmlSchemaElement childElement in sequence.Items)
            {
                Console.WriteLine($"Element: {childElement.Name}");
            }
        }
    }

    static void ValidationCallback(object sender, ValidationEventArgs args)
    {
        if (args.Severity == XmlSeverityType.Warning)
            Console.Write("WARNING: ");
        else if (args.Severity == XmlSeverityType.Error)
            Console.Write("ERROR: ");

        Console.WriteLine(args.Message);
    }
}

Imports System.Collections
Imports System.Xml
Imports System.Xml.Schema

Class XmlSchemaTraverseExample

    Shared Sub Main()

        ' Add the customer schema to a new XmlSchemaSet and compile it.
        ' Any schema validation warnings and errors encountered reading or 
        ' compiling the schema are handled by the ValidationEventHandler delegate.
        Dim schemaSet As XmlSchemaSet = New XmlSchemaSet()
        AddHandler schemaSet.ValidationEventHandler, AddressOf ValidationCallback
        schemaSet.Add("http://www.tempuri.org", "customer.xsd")
        schemaSet.Compile()

        ' Retrieve the compiled XmlSchema object from the XmlSchemaSet
        ' by iterating over the Schemas property.
        Dim customerSchema As XmlSchema = Nothing
        For Each schema As XmlSchema In schemaSet.Schemas()
            customerSchema = schema
        Next

        ' Iterate over each XmlSchemaElement in the Values collection
        ' of the Elements property.
        For Each element As XmlSchemaElement In customerSchema.Elements.Values

            Console.WriteLine("Element: {0}", element.Name)

            ' Get the complex type of the Customer element.
            Dim complexType As XmlSchemaComplexType = CType(element.ElementSchemaType, XmlSchemaComplexType)

            ' If the complex type has any attributes, get an enumerator 
            ' and write each attribute name to the console.
            If complexType.AttributeUses.Count > 0 Then

                Dim enumerator As IDictionaryEnumerator = _
                    complexType.AttributeUses.GetEnumerator()

                While enumerator.MoveNext()

                    Dim attribute As XmlSchemaAttribute = _
                        CType(enumerator.Value, XmlSchemaAttribute)

                    Console.WriteLine("Attribute: {0}", Attribute.Name)
                End While
            End If

            ' Get the sequence particle of the complex type.
            Dim sequence As XmlSchemaSequence = CType(complexType.ContentTypeParticle, XmlSchemaSequence)

            For Each childElement As XmlSchemaElement In sequence.Items
                Console.WriteLine("Element: {0}", childElement.Name)
            Next
        Next

    End Sub

    Shared Sub ValidationCallback(ByVal sender As Object, ByVal args As ValidationEventArgs)
        If args.Severity = XmlSeverityType.Warning Then
            Console.Write("WARNING: ")
        Else
            If args.Severity = XmlSeverityType.Error Then
                Console.Write("ERROR: ")
            End If
        End If
        Console.WriteLine(args.Message)
    End Sub

End Class

La proprietà XmlSchemaElement.ElementSchemaType può essere XmlSchemaSimpleTypeo XmlSchemaComplexType se si tratta di un tipo semplice definito dall'utente o di un tipo complesso. Può anche essere XmlSchemaDatatype se è uno dei tipi di dati predefiniti definiti nella raccomandazione W3C XML Schema. Nello schema del cliente, il ElementSchemaType dell'elemento Customer è XmlSchemaComplexTypee gli elementi FirstName e LastName sono XmlSchemaSimpleType.

Nell'argomento Compilazione di XML Schemas, è stata utilizzata la raccolta XmlSchemaComplexType.Attributes nell'esempio di codice per aggiungere l'attributo CustomerId all'elemento Customer. Si tratta di una proprietà di pre-compilazione dello schema. La proprietà Post-Schema-Compilation-Infoset corrispondente è l'insieme XmlSchemaComplexType.AttributeUses, che contiene tutti gli attributi del tipo complesso, inclusi quelli ereditati tramite derivazione del tipo.

Vedere anche

  • Last updated on