Condividi tramite

Mapping della gerarchia degli oggetti in dati XML

Quando un documento XML è in memoria, la rappresentazione concettuale è un albero. Per la programmazione, è disponibile una gerarchia di oggetti per accedere ai nodi dell'albero. Nell'esempio seguente viene illustrato come il contenuto XML diventa nodi.

Poiché il codice XML viene letto nel DOM (Document Object Model) XML, le parti vengono convertite in nodi e questi nodi mantengono metadati aggiuntivi su se stessi, ad esempio il tipo di nodo e i valori. Il tipo di nodo è il relativo oggetto ed è ciò che determina quali azioni possono essere eseguite e quali proprietà possono essere impostate o recuperate.

Se si dispone del codice XML semplice seguente:

Inserimento

<book>  
    <title>The Handmaid's Tale</title>  
</book>

L'input è rappresentato in memoria come albero dei nodi seguente con la proprietà del tipo di nodo assegnato:

albero dei nodi di esempio
Rappresentazione dell'albero dei nodi di libro e di titolo

L'elemento book diventa un oggetto XmlElement , l'elemento successivo, title, diventa anche xmlElement, mentre il contenuto dell'elemento diventa un oggetto XmlText . Esaminando i metodi e le proprietà XmlElement , i metodi e le proprietà sono diversi dai metodi e dalle proprietà disponibili in un oggetto XmlText . Pertanto, è fondamentale conoscere il tipo di nodo in cui il markup XML diventa, poiché il tipo di nodo determina le azioni che è possibile eseguire.

L'esempio seguente legge i dati XML e scrive testo diverso, a seconda del tipo di nodo. Usando il file di dati XML seguente come input ,items.xml:

Inserimento

<?xml version="1.0"?>  
<!-- This is a sample XML document -->  
<!DOCTYPE Items [<!ENTITY number "123">]>  
<Items>  
  <Item>Test with an entity: &number;</Item>  
  <Item>test with a child element <more/> stuff</Item>  
  <Item>test with a CDATA section <![CDATA[<456>]]> def</Item>  
  <Item>Test with a char entity: A</Item>  
  <!-- Fourteen chars in this element.-->  
  <Item>1234567890ABCD</Item>  
</Items>

Nell'esempio di codice seguente viene letto il file items.xml e vengono visualizzate informazioni per ogni tipo di nodo.

Imports System  
Imports System.IO  
Imports System.Xml  
  
Public Class Sample  
    Private Const filename As String = "items.xml"  
  
    Public Shared Sub Main()  
  
        Dim reader As XmlTextReader = Nothing  
  
        Try  
            ' Load the reader with the data file and
            'ignore all white space nodes.
            reader = New XmlTextReader(filename)  
            reader.WhitespaceHandling = WhitespaceHandling.None  
  
            ' Parse the file and display each of the nodes.  
            While reader.Read()  
                Select Case reader.NodeType  
                    Case XmlNodeType.Element  
                        Console.Write("<{0}>", reader.Name)  
                    Case XmlNodeType.Text  
                        Console.Write(reader.Value)  
                    Case XmlNodeType.CDATA  
                        Console.Write("<![CDATA[{0}]]>", reader.Value)  
                    Case XmlNodeType.ProcessingInstruction  
                        Console.Write("<?{0} {1}?>", reader.Name, reader.Value)  
                    Case XmlNodeType.Comment  
                        Console.Write("<!--{0}-->", reader.Value)  
                    Case XmlNodeType.XmlDeclaration  
                        Console.Write("<?xml version='1.0'?>")  
                    Case XmlNodeType.Document  
                    Case XmlNodeType.DocumentType  
                        Console.Write("<!DOCTYPE {0} [{1}]", reader.Name, reader.Value)  
                    Case XmlNodeType.EntityReference  
                        Console.Write(reader.Name)  
                    Case XmlNodeType.EndElement  
                        Console.Write("</{0}>", reader.Name)  
                End Select  
            End While  
  
        Finally  
            If Not (reader Is Nothing) Then  
                reader.Close()  
            End If  
        End Try  
    End Sub 'Main ' End class  
End Class 'Sample  

using System;  
using System.IO;  
using System.Xml;  
  
public class Sample  
{  
    private const String filename = "items.xml";  
  
    public static void Main()  
    {  
        XmlTextReader reader = null;  
  
        try  
        {  
            // Load the reader with the data file and ignore
            // all white space nodes.  
            reader = new XmlTextReader(filename);  
            reader.WhitespaceHandling = WhitespaceHandling.None;  
  
            // Parse the file and display each of the nodes.  
            while (reader.Read())  
            {  
                switch (reader.NodeType)  
                {  
                    case XmlNodeType.Element:  
                        Console.Write("<{0}>", reader.Name);  
                        break;  
                    case XmlNodeType.Text:  
                        Console.Write(reader.Value);  
                        break;  
                    case XmlNodeType.CDATA:  
                        Console.Write("<![CDATA[{0}]]>", reader.Value);  
                        break;  
                    case XmlNodeType.ProcessingInstruction:  
                        Console.Write("<?{0} {1}?>", reader.Name, reader.Value);  
                        break;  
                    case XmlNodeType.Comment:  
                        Console.Write("<!--{0}-->", reader.Value);  
                        break;  
                    case XmlNodeType.XmlDeclaration:  
                        Console.Write("<?xml version='1.0'?>");  
                        break;  
                    case XmlNodeType.Document:  
                        break;  
                    case XmlNodeType.DocumentType:  
                        Console.Write("<!DOCTYPE {0} [{1}]", reader.Name, reader.Value);  
                        break;  
                    case XmlNodeType.EntityReference:  
                        Console.Write(reader.Name);  
                        break;  
                    case XmlNodeType.EndElement:  
                        Console.Write("</{0}>", reader.Name);  
                        break;  
                }  
            }  
        }  
  
        finally  
        {  
            if (reader != null)  
                reader.Close();  
        }  
    }  
} // End class

L'output dell'esempio rivela la mappatura dei dati ai tipi di nodo.

Risultato

<?xml version='1.0'?><!--This is a sample XML document --><!DOCTYPE Items [<!ENTITY number "123">]<Items><Item>Test with an entity: 123</Item><Item>test with a child element <more> stuff</Item><Item>test with a CDATA section <![CDATA[<456>]]> def</Item><Item>Test with a char entity: A</Item><--Fourteen chars in this element.--><Item>1234567890ABCD</Item></Items>

Accettando l'input una riga alla volta e usando l'output generato dal codice, è possibile usare la tabella seguente per analizzare quale test del nodo ha generato quali righe di output, comprendendo così quali dati XML sono diventati quale tipo di nodo.

Inserimento Risultato Test del tipo di nodo
<?xml version="1.0"?> <?xml version='1.0'?> XmlNodeType.XmlDeclaration
<-- Questo è un documento XML di esempio -> <--Questo è un documento XML di esempio -> XmlNodeType.Comment
<! Elementi DOCTYPE [<! Numero ENTITÀ "123">]> <! Elementi DOCTYPE [<! Numero ENTITÀ "123">] XmlNodeType.DocumentType
<Elementi> <Elementi> XmlNodeType.Element
<Articolo> <Articolo> XmlNodeType.Element
Testare con un'entità: &number; Prova con un'entità: 123 XmlNodeType.Text
</Articolo> </Articolo> XmlNodeType.EndElement
<Articolo> <Articolo> XmNodeType.Element
test con un elemento figlio test con un elemento figlio XmlNodeType.Text
<più> <più> XmlNodeType.Element
cose cose XmlNodeType.Text
</Articolo> </Articolo> XmlNodeType.EndElement
<Articolo> <Articolo> XmlNodeType.Element
test con una sezione CDATA test con una sezione CDATA XmlTest.Text
<! [CDATA[<456>]]> <! [CDATA[<456>]]> XmlTest.CDATA
def def XmlNodeType.Text
</Articolo> </Articolo> XmlNodeType.EndElement
<Articolo> <Articolo> XmlNodeType.Element
Testare con un'entità char: A Eseguire il test con un'entità char: A XmlNodeType.Text
</Articolo> </Articolo> XmlNodeType.EndElement (NodoTipoXML.ElementoDiChiusura)
<-- Quattordici caratteri in questo elemento.> <--Quattordici caratteri in questo elemento.--> XmlNodeType.Comment
<Articolo> <Articolo> XmlNodeType.Element
1234567890ABCD 1234567890ABCD XmlNodeType.Text
</Articolo> </Articolo> XmlNodeType.EndElement
</Elementi> </Elementi> XmlNodeType.EndElement

È necessario conoscere il tipo di nodo assegnato, perché il tipo di nodo controlla quali tipi di azioni sono validi e quali tipi di proprietà è possibile impostare e recuperare.

La creazione di nodi per spazi vuoti viene controllata quando i dati vengono caricati nel DOM dal flag PreserveWhitespace . Per altre informazioni, vedere Spazi vuoti e Gestione significativa dello spazio vuoto durante il caricamento del DOM.

Per aggiungere nuovi nodi al DOM, vedere Inserimento di nodi in un documento XML. Per rimuovere nodi dal DOM, vedere Rimozione di nodi, contenuto e valori da un documento XML. Per modificare il contenuto dei nodi nel DOM, vedere Modifica di nodi, contenuto e valori in un documento XML.

Vedere anche

  • Last updated on