Mapping della gerarchia di oggetti in dati XMLMapping the Object Hierarchy to XML Data

Quando un documento XML è in memoria, la rappresentazione concettuale è un albero.When an XML document is in memory, the conceptual representation is a tree. Nella programmazione, è possibile accedere ai nodi dell'albero mediante una gerarchia di oggetti.For programming, you have an object hierarchy to access the nodes of the tree. Nell'esempio seguente viene illustrato come il contenuto XML viene convertito in nodi.The following example shows you how the XML content becomes nodes.

Mentre il codice XML viene letto nel DOM (Document Object Model) XML, i dati sono convertiti in nodi in cui vengono conservati metadati aggiuntivi, quali il tipo di nodo e i relativi valori.As the XML is read into the XML Document Object Model (DOM), the pieces are translated into nodes, and these nodes retain additional metadata about themselves, such as their node type and values. Il tipo di nodo corrisponde al relativo oggetto e determina le operazioni che possono essere eseguite e le proprietà che possono essere impostate o recuperate.The node type is its object and is what determines what actions can be performed and what properties can be set or retrieved.

Si consideri ad esempio il seguente codice XML:If you have the following simple XML:

InputInput

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

L'input è rappresentato in memoria come il seguente albero di nodi con la proprietà del tipo di nodo associata:The input is represented in memory as the following node tree with the assigned node type property:

Albero nodo esempioexample node tree
Rappresentazione dell'albero dei nodi Book e TitleBook and title node tree representation

L'elemento book viene convertito in un oggetto XmlElement, l'elemento successivo title viene convertito anch'esso in XmlElement, mentre il contenuto degli elementi viene convertito in un oggetto XmlText.The book element becomes an XmlElement object, the next element, title, also becomes an XmlElement, while the element content becomes an XmlText object. Osservando i metodi e le proprietà XmlElement, si può notare che questi sono diversi dai metodi e dalle proprietà disponibili in un oggetto XmlText.In looking at the XmlElement methods and properties, the methods and properties are different than the methods and properties available on an XmlText object. È quindi fondamentale sapere quale tipo di nodo diventerà il markup XML, perché in base a questo vengono determinate le operazioni che possono essere eseguite.So knowing what node type the XML markup becomes is vital, as its node type determines the actions that can be performed.

Nell'esempio seguente vengono letti i dati XML e viene scritto un testo diverso a seconda del tipo di nodo,The following example reads in XML data and writes out different text, depending on the node type. usando come input il file di dati XML items.xml:Using the following XML data file as input, items.xml:

InputInput

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

L'esempio di codice seguente legge il file items.xml e visualizza le informazioni per ogni tipo di nodo.The following code example reads the items.xml file and displays information for each node type.

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 consente di visualizzare il mapping dei dati nei tipi di nodo.The output from the example reveals the mapping of the data to the node types.

OutputOutput

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

Esaminando l'input riga per riga e usando l'output generato dal codice, è possibile usare la tabella seguente per analizzare quale verifica del nodo ha generato determinate righe di output e capire quindi quali dati XML sono stati convertiti in un determinato tipo di nodo.Taking the input one line at a time and using the output generated from the code, you can use the following table to analyze what node test generated which lines of output, thereby understanding what XML data became what kind of node type.

InputInput OutputOutput Verifica del tipo di nodoNode Type Test
<?xml version="1.0"?><?xml version="1.0"?> <?xml version='1.0'?><?xml version='1.0'?> XmlNodeType.XmlDeclarationXmlNodeType.XmlDeclaration
<!-- This is a sample XML document --><!-- This is a sample XML document --> <!--This is a sample XML document --><!--This is a sample XML document --> XmlNodeType.CommentXmlNodeType.Comment
<!DOCTYPE Items [<!ENTITY number "123">]><!DOCTYPE Items [<!ENTITY number "123">]> <!DOCTYPE Items [<!ENTITY number "123">]<!DOCTYPE Items [<!ENTITY number "123">] XmlNodeType.DocumentTypeXmlNodeType.DocumentType
<Items><Items> <Items><Items> XmlNodeType.ElementXmlNodeType.Element
<Item><Item> <Item><Item> XmlNodeType.ElementXmlNodeType.Element
Test with an entity: &number;Test with an entity: &number; Test with an entity: 123Test with an entity: 123 XmlNodeType.TextXmlNodeType.Text
</Item></Item> </Item></Item> XmlNodeType.EndElementXmlNodeType.EndElement
<Item><Item> <Item><Item> XmNodeType.ElementXmNodeType.Element
test with a child elementtest with a child element test with a child elementtest with a child element XmlNodeType.TextXmlNodeType.Text
<more><more> <more><more> XmlNodeType.ElementXmlNodeType.Element
stuffstuff stuffstuff XmlNodeType.TextXmlNodeType.Text
</Item></Item> </Item></Item> XmlNodeType.EndElementXmlNodeType.EndElement
<Item><Item> <Item><Item> XmlNodeType.ElementXmlNodeType.Element
test with a CDATA sectiontest with a CDATA section test with a CDATA sectiontest with a CDATA section XmlTest.TextXmlTest.Text
<![CDATA[<456>]]><![CDATA[<456>]]> <![CDATA[<456>]]><![CDATA[<456>]]> XmlTest.CDATAXmlTest.CDATA
defdef defdef XmlNodeType.TextXmlNodeType.Text
</Item></Item> </Item></Item> XmlNodeType.EndElementXmlNodeType.EndElement
<Item><Item> <Item><Item> XmlNodeType.ElementXmlNodeType.Element
Test with a char entity: &#65;Test with a char entity: &#65; Test with a char entity: ATest with a char entity: A XmlNodeType.TextXmlNodeType.Text
</Item></Item> </Item></Item> XmlNodeType.EndElementXmlNodeType.EndElement
<!-- Fourteen chars in this element.--><!-- Fourteen chars in this element.--> <--Fourteen chars in this element.--><--Fourteen chars in this element.--> XmlNodeType.CommentXmlNodeType.Comment
<Item><Item> <Item><Item> XmlNodeType.ElementXmlNodeType.Element
1234567890ABCD1234567890ABCD 1234567890ABCD1234567890ABCD XmlNodeType.TextXmlNodeType.Text
</Item></Item> </Item></Item> XmlNodeType.EndElementXmlNodeType.EndElement
</Items></Items> </Items></Items> XmlNodeType.EndElementXmlNodeType.EndElement

È necessario sapere quale tipo di nodo viene assegnato, poiché in base al tipo di nodo vengono determinate le operazioni valide e il tipo di proprietà che è possibile impostare e recuperare.You must know what node type is assigned, as the node type controls what kinds of actions are valid and what kind of properties you can set and retrieve.

La creazione di nodi per spazi vuoti viene controllata quando i dati sono caricati nel DOM dal flag PreserveWhitespace.Node creation for white space is controlled when the data is loaded into the DOM by the PreserveWhitespace flag. Per altre informazioni, vedere Gestione degli spazi vuoti e degli spazi vuoti significativi durante il caricamento del DOM.For more information, see White Space and Significant White Space Handling when Loading the DOM.

Per aggiungere nuovi nodi al DOM, vedere Inserimento di nodi in un documento XML.To add new nodes to the DOM, see Inserting Nodes into an XML Document. Per rimuovere nodi dal DOM, vedere Rimozione di nodi, contenuto e valori da un documento XML.To remove nodes from the DOM, see Removing Nodes, Content, and Values from an XML Document. Per modificare il contenuto dei nodi nel DOM, vedere Modifica di nodi, contenuto e valori in un documento XML.To modify the content of nodes in the DOM, see Modifying Nodes, Content, and Values in an XML Document.

Vedere ancheSee Also

Modello DOM (Document Object Mode) XMLXML Document Object Model (DOM)