Mappage de la hiérarchie d’objets en données XML

Lorsqu’un document XML est en mémoire, la représentation conceptuelle est une arborescence. Pour la programmation, vous disposez d’une hiérarchie d’objets pour accéder aux nœuds de l’arborescence. L’exemple suivant montre comment le contenu XML devient des nœuds.

À mesure que le code XML est lu dans le modèle DOM (Document Object Model), les éléments sont traduits en nœuds, et ces nœuds conservent des métadonnées supplémentaires sur elles-mêmes, telles que leur type de nœud et leurs valeurs. Le type de nœud est son objet et détermine quelles actions peuvent être effectuées et quelles propriétés peuvent être définies ou récupérées.

Si vous disposez du code XML simple suivant :

Entrée

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

L’entrée est représentée en mémoire en tant qu’arborescence de nœuds suivante avec la propriété de type de nœud affectée :

Représentation sous forme d’arborescence de nœuds book et title

L’élément book devient un objet XmlElement , l’élément suivant, titledevient également xmlElement, tandis que le contenu de l’élément devient un objet XmlText . En examinant les méthodes et propriétés XmlElement , les méthodes et propriétés sont différentes des méthodes et propriétés disponibles sur un objet XmlText . Il est donc essentiel de savoir en quel type de nœud le balisage XML se transforme, car cela détermine les actions qui peuvent être effectuées.

L’exemple suivant lit dans les données XML et écrit un texte différent, selon le type de nœud. À l’aide du fichier de données XML suivant comme entrée, items.xml:

Entrée

<?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’exemple de code suivant lit le fichier items.xml et affiche des informations pour chaque type de nœud.

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  

La sortie de l’exemple révèle le mappage des données aux types de nœuds.

Sortie

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

En traitant les entrées ligne par ligne et en utilisant les sorties générées par le code, vous pouvez utiliser le tableau suivant pour analyser quel test de nœud a généré quelles lignes de sortie, ce qui permet de comprendre comment les données XML ont été traduites en différents types de nœuds.

Vous devez savoir quel type de nœud est affecté, car le type de nœud contrôle les types d’actions valides et le type de propriétés que vous pouvez définir et récupérer.

La création de nœud pour l’espace blanc est contrôlée lorsque les données sont chargées dans le DOM par l’indicateur PreserveWhitespace . Pour plus d’informations, consultez Espace blanc et Gestion significative de l’espace blanc lors du chargement du DOM.

Pour ajouter de nouveaux nœuds au DOM, consultez Insertion de nœuds dans un document XML. Pour supprimer des nœuds du DOM, consultez Suppression de nœuds, de contenu et de valeurs d’un document XML. Pour modifier le contenu des nœuds dans le DOM, consultez Modification des nœuds, du contenu et des valeurs dans un document XML.

Voir aussi

• Modèle Objet Document XML (DOM)