XmlDocument XmlDocument XmlDocument XmlDocument Class

Définition

Représente un document XML.Represents an XML document. Vous pouvez utiliser cette classe pour charger, valider, modifier, ajouter et positionner du contenu XML dans un document.You can use this class to load, validate, edit, add, and position XML in a document.

public ref class XmlDocument : System::Xml::XmlNode
public class XmlDocument : System.Xml.XmlNode
type XmlDocument = class
    inherit XmlNode
Public Class XmlDocument
Inherits XmlNode
Héritage
XmlDocumentXmlDocumentXmlDocumentXmlDocument
Dérivé

Remarques

Le XmlDocument classe est une représentation en mémoire d’un document XML.The XmlDocument class is an in-memory representation of an XML document. Il implémente le W3C modèle DOM (Document objet Model) XML Level 1 Core et le Core DOM Level 2.It implements the W3C XML Document Object Model (DOM) Level 1 Core and the Core DOM Level 2.

DOM est l’acronyme modèle objet de document.DOM stands for document object model. Pour plus d’informations, consultez modèle DOM (Document objet Model) XML.To read more about it, see XML Document Object Model (DOM).

Vous pouvez charger du code XML dans le DOM à l’aide de la XmlDocument classe et ensuite par programmation lire, modifier et supprimer le XML dans le document.You can load XML into the DOM by using the XmlDocument class, and then programmatically read, modify, and remove XML in the document.

Si vous souhaitez Dégagez ouvrir le XmlDocument classe et comment il est implémenté, consultez le Source de référence.If you want to pry open the XmlDocument class and see how it's implemented, see the Reference Source.

TâchesTasks

Charger des données XML dans le modèle d’objet de documentLoad XML into the document object model

Démarrez avec un document XML similaire à celle qui a quelques livres dans une collection.Start with an XML document like this one that has a few books in a collection. Il contient les fonctions de base que vous trouveriez dans un document XML, notamment un espace de noms, les éléments qui représentent les données et les attributs qui décrivent les données.It contains the basic things that you'd find in any XML document, including a namespace, elements that represent data, and attributes that describe the data.

<?xml version="1.0" encoding="utf-8"?>  
<books xmlns="http://www.contoso.com/books">  
  <book genre="novel" ISBN="1-861001-57-8" publicationdate="1823-01-28">  
    <title>Pride And Prejudice</title>  
    <price>24.95</price>  
  </book>  
  <book genre="novel" ISBN="1-861002-30-1" publicationdate="1985-01-01">  
    <title>The Handmaid's Tale</title>  
    <price>29.95</price>  
  </book>  
  <book genre="novel" ISBN="1-861001-45-3" publicationdate="1811-01-01">  
    <title>Sense and Sensibility</title>  
    <price>19.95</price>  
  </book>  
</books>  

Ensuite, charger ces données dans le DOM afin que vous puissiez travailler avec lui en mémoire.Next, load this data into the DOM so that you can work with it in memory. Le moyen le plus populaire pour ce faire est de faire référence à un fichier sur votre ordinateur local ou sur un réseau.The most popular way to do this is refer to a file on your local computer or on a network.

Cet exemple charge un document XML à partir d’un fichier.This example loads XML from a file. Si le fichier n’existe pas, il simplement génère du code XML et qui charge.If the file doesn't exist, it just generates some XML and loads that.

XmlDocument ^doc = gcnew XmlDocument();
doc->PreserveWhitespace = true;
try
{doc->Load("booksData.xml");}
catch (System::IO::FileNotFoundException ^e1)
{
	// If no book is found, generate some XML.

	doc->LoadXml("<?xml version=\"1.0\"?> \n" +
	"<books xmlns=\"http://www.contoso.com/books\"> \n" +
	"  <book genre=\"novel\" ISBN=\"1-861001-57-8\" publicationdate=\"1823-01-28\"> \n" +
	"    <title>Pride And Prejudice</title> \n" +
	"    <price>24.95</price> \n" +
	"  </book> \n" +
	"  <book genre=\"novel\" ISBN=\"1-861002-30-1\" publicationdate=\"1985-01-01\"> \n" +
	"    <title>The Handmaid's Tale</title> \n" +
	"    <price>29.95</price> \n" +
	"  </book> \n" +
	"</books>");
}
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
try { doc.Load("booksData.xml"); }
catch (System.IO.FileNotFoundException)
{
    doc.LoadXml("<?xml version=\"1.0\"?> \n" +
    "<books xmlns=\"http://www.contoso.com/books\"> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861001-57-8\" publicationdate=\"1823-01-28\"> \n" +
    "    <title>Pride And Prejudice</title> \n" +
    "    <price>24.95</price> \n" +
    "  </book> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861002-30-1\" publicationdate=\"1985-01-01\"> \n" +
    "    <title>The Handmaid's Tale</title> \n" +
    "    <price>29.95</price> \n" +
    "  </book> \n" +
    "</books>");             
}
Dim doc As XmlDocument = New XmlDocument
doc.PreserveWhitespace = True
Try
    doc.Load("booksData.xml")
Catch ex As System.IO.FileNotFoundException
    ' If no file is found, generate some XML.
    doc.LoadXml("<?xml version=""1.0""?> " & ControlChars.NewLine & _
        "<books xmlns=""http://www.contoso.com/books""> " & ControlChars.NewLine & _
        "  <book genre=""novel"" ISBN=""1-861001-57-8"" publicationdate=""1823-01-28""> " & ControlChars.NewLine & _
        "    <title>Pride And Prejudice</title> " & ControlChars.NewLine & _
        "    <price>24.95</price> " & ControlChars.NewLine & _
        "  </book> " & ControlChars.NewLine & _
        "  <book genre=""novel"" ISBN=""1-861002-30-1"" publicationdate=""1985-01-01""> " & ControlChars.NewLine & _
        "    <title>The Handmaid's Tale</title> " & ControlChars.NewLine & _
        "    <price>29.95</price> " & ControlChars.NewLine & _
        "  </book> " & ControlChars.NewLine & _
        "</books>")
End Try

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

En savoir plus : Lecture d’un document XML dans le DOMLearn more: Reading an XML Document into the DOM

Valider par rapport à un schémaValidate it against a schema

Démarrez avec un schéma XML comme celle-ci.Start with an XML schema like this one. Ce schéma définit les types de données dans le code XML et les attributs qui sont requis.This schema defines the data types in the XML and which attributes are required.

<?xml version="1.0" encoding="utf-8"?>  
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  
  attributeFormDefault="unqualified"   
  elementFormDefault="qualified"  
  targetNamespace="http://www.contoso.com/books">   
  <xs:element name="books">  
    <xs:complexType>  
      <xs:sequence>  
        <xs:element maxOccurs="unbounded" name="book">  
          <xs:complexType>  
            <xs:sequence>  
              <xs:element name="title" type="xs:string" />  
              <xs:element name="price" type="xs:decimal" />  
            </xs:sequence>  
            <xs:attribute name="genre" type="xs:string" use="required" />  
            <xs:attribute name="ISBN" type="xs:string" use="required" />  
            <xs:attribute name="publicationdate" type="xs:date" use="required" />  
          </xs:complexType>  
        </xs:element>  
      </xs:sequence>  
    </xs:complexType>  
  </xs:element>  
</xs:schema>  

Créer un XmlReader de l’objet à l’aide de votre schéma et charger ensuite cet objet dans le DOM.Create an XmlReader object by using your schema, and then load that object into the DOM. Créer un gestionnaire d’événements qui s’exécute lorsque le code tente de modifier votre fichier XML de façons qui violent les règles du schéma.Create an event handler that executes when code attempts to modify your XML file in ways that violate the rules of the schema.

Ces blocs de code montrent des méthodes d’assistance qui faire tout cela.These blocks of code show helper methods that do all of this.

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************

XmlDocument ^XMLDOMProcessing::XMLHelperMethods::LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
	XmlReader ^reader;

	XmlReaderSettings ^settings = gcnew XmlReaderSettings();

	// Helper method to retrieve schema.
	XmlSchema ^schema = getSchema(generateSchema);
	
	if (schema == nullptr)
	{
		return nullptr;
	}

	settings->Schemas->Add(schema);
	settings->ValidationEventHandler +=
		gcnew System::Xml::Schema::ValidationEventHandler
		(this, &XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler);
	settings->ValidationFlags = settings->ValidationFlags | XmlSchemaValidationFlags::ReportValidationWarnings;
	settings->ValidationType = ValidationType::Schema;

	try
	{
		reader = XmlReader::Create("booksData.xml", settings);
	}
	catch (System::IO::FileNotFoundException ^e1)
	{
		if (generateXML)
		{
			String ^xml = generateXMLString();
			array<Byte> ^byteArray = Encoding::UTF8->GetBytes(xml);
			MemoryStream ^stream = gcnew MemoryStream(byteArray);
			reader = XmlReader::Create(stream, settings);
		}
		else
		{
			return nullptr;
		}

	}

	XmlDocument ^doc = gcnew XmlDocument();
	doc->PreserveWhitespace = true;
	doc->Load(reader);
	reader->Close();

	return doc;
}

//************************************************************************************
//
//  Helper method that generates an XML Schema.
//
//************************************************************************************

String ^XMLDOMProcessing::XMLHelperMethods::generateXMLSchema()
{
	String ^xmlSchema = "<?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=\"books\"> " + 
		"<xs:complexType> " + "<xs:sequence> " + "<xs:element maxOccurs=\"unbounded\" name=\"book\"> " + 
		"<xs:complexType> " + "<xs:sequence> " + "<xs:element name=\"title\" type=\"xs:string\" /> " + 
		"<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> ";
	
	return xmlSchema;
}

//************************************************************************************
//
//  Helper method that gets a schema
//
//************************************************************************************

XmlSchema ^XMLDOMProcessing::XMLHelperMethods::getSchema(bool generateSchema)
{
	XmlSchemaSet ^xs = gcnew XmlSchemaSet();
	XmlSchema ^schema;
	try
	{
		schema = xs->Add("http://www.contoso.com/books", "booksData.xsd");
	}
	catch (System::IO::FileNotFoundException ^e1)
	{
		if (generateSchema)
		{
			String ^xmlSchemaString = generateXMLSchema();
			array<Byte> ^byteArray = Encoding::UTF8->GetBytes(xmlSchemaString);
			MemoryStream ^stream = gcnew MemoryStream(byteArray);
			XmlReader ^reader = XmlReader::Create(stream);
			schema = xs->Add("http://www.contoso.com/books", reader);
		}
		else
		{
			return nullptr;
		}

	}
	return schema;
}
//************************************************************************************
//
//  Helper method to validate the XML against the schema.
//
//************************************************************************************
bool XMLDOMProcessing::XMLHelperMethods::validateXML(bool generateSchema, XmlDocument ^doc)
{
	if (doc->Schemas->Count == 0)
	{
		// Helper method to retrieve schema.
		XmlSchema ^schema = getSchema(generateSchema);
		doc->Schemas->Add(schema);
	}

	ValidationEventHandler^ eventHandler = gcnew System::Xml::Schema::ValidationEventHandler
		(this, &XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler);

	// Use an event handler to validate the XML node against the schema.
	doc->Validate(eventHandler);

	if (_IsValid == false)
	{
		_IsValid = true;
		return false;
	}
	else
	{
		return true;
	}

}
//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************

void XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler(System::Object ^sender, System::Xml::Schema::ValidationEventArgs ^e)
{
	if (e->Severity == XmlSeverityType::Warning)
	{
		// do nothing.
	}
	else if (e->Severity == XmlSeverityType::Error)
	{
		// set some global variables.
		_IsValid = false;
		ValidationError = e->Message;
	}
}

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************
public XmlDocument LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader reader;

    XmlReaderSettings settings = new XmlReaderSettings();

    // Helper method to retrieve schema.
    XmlSchema schema = getSchema(generateSchema);

    if (schema == null)
    {
        return null;
    }

    settings.Schemas.Add(schema);

    settings.ValidationEventHandler += settings_ValidationEventHandler;
    settings.ValidationFlags =
        settings.ValidationFlags | XmlSchemaValidationFlags.ReportValidationWarnings;
    settings.ValidationType = ValidationType.Schema;

    try
    {
        reader = XmlReader.Create("booksData.xml", settings);
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateXML)
        {
            string xml = generateXMLString();
            byte[] byteArray = Encoding.UTF8.GetBytes(xml);
            MemoryStream stream = new MemoryStream(byteArray);
            reader = XmlReader.Create(stream, settings);
        }
        else
        {
            return null;
        }

    }

    XmlDocument doc = new XmlDocument();
    doc.PreserveWhitespace = true;
    doc.Load(reader);
    reader.Close();

    return doc;
}

//************************************************************************************
//
//  Helper method that generates an XML Schema.
//
//************************************************************************************
private string generateXMLSchema()
{
    string xmlSchema =
        "<?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=\"books\"> " +
        "<xs:complexType> " +
        "<xs:sequence> " +
        "<xs:element maxOccurs=\"unbounded\" name=\"book\"> " +
        "<xs:complexType> " +
        "<xs:sequence> " +
        "<xs:element name=\"title\" type=\"xs:string\" /> " +
        "<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> ";
    return xmlSchema;
}

//************************************************************************************
//
//  Helper method that gets a schema
//
//************************************************************************************
private XmlSchema getSchema(bool generateSchema)
{
    XmlSchemaSet xs = new XmlSchemaSet();
    XmlSchema schema;
    try
    {
        schema = xs.Add("http://www.contoso.com/books", "booksData.xsd");
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateSchema)
        {
            string xmlSchemaString = generateXMLSchema();
            byte[] byteArray = Encoding.UTF8.GetBytes(xmlSchemaString);
            MemoryStream stream = new MemoryStream(byteArray);
            XmlReader reader = XmlReader.Create(stream);
            schema = xs.Add("http://www.contoso.com/books", reader);
        }
        else
        {
            return null;
        }

    }
    return schema;
}

//************************************************************************************
//
//  Helper method to validate the XML against the schema.
//
//************************************************************************************
private void validateXML(bool generateSchema, XmlDocument doc)
{
    if (doc.Schemas.Count == 0)
    {
        // Helper method to retrieve schema.
        XmlSchema schema = getSchema(generateSchema);
        doc.Schemas.Add(schema);
    }

    // Use an event handler to validate the XML node against the schema.
    doc.Validate(settings_ValidationEventHandler);

}

//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************
void settings_ValidationEventHandler(object sender,
    System.Xml.Schema.ValidationEventArgs e)
{
    if (e.Severity == XmlSeverityType.Warning)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following validation warning occurred: " + e.Message);
    }
    else if (e.Severity == XmlSeverityType.Error)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following critical validation errors occurred: " + e.Message);
        Type objectType = sender.GetType();
    }

}
'************************************************************************************
'
'  Associate the schema with XML. Then, load the XML and validate it against
'  the schema.
'
'************************************************************************************
Public Function LoadDocumentWithSchemaValidation(ByVal generateXML As Boolean, ByVal generateSchema As Boolean) As XmlDocument
    Dim reader As XmlReader
    Dim settings As XmlReaderSettings = New XmlReaderSettings
    ' Helper method to retrieve schema.
    Dim schema As XmlSchema = getSchema(generateSchema)
    If (schema Is Nothing) Then
        Return Nothing
    End If
    settings.Schemas.Add(schema)
    AddHandler settings.ValidationEventHandler, AddressOf settings_ValidationEventHandler
    settings.ValidationFlags = (settings.ValidationFlags Or XmlSchemaValidationFlags.ReportValidationWarnings)
    settings.ValidationType = ValidationType.Schema
    Try
        reader = XmlReader.Create("booksData.xml", settings)
    Catch ex As System.IO.FileNotFoundException
        If generateXML Then
            Dim xml As String = generateXMLString()
            Dim byteArray() As Byte = Encoding.UTF8.GetBytes(xml)
            Dim stream As MemoryStream = New MemoryStream(byteArray)
            reader = XmlReader.Create(stream, settings)
        Else
            Return Nothing
        End If
    End Try
    Dim doc As XmlDocument = New XmlDocument
    doc.PreserveWhitespace = True
    doc.Load(reader)
    reader.Close()
    Return doc
End Function

'************************************************************************************
'
'  Helper method that generates an XML Schema.
'
'************************************************************************************
Private Function generateXMLSchema() As String

    Dim generatedXmlSchema As String = "<?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=""books""> " & _
            "<xs:complexType> " & _
            "<xs:sequence> " & _
            "<xs:element maxOccurs=""unbounded"" name=""book""> " & _
            "<xs:complexType> " & _
            "<xs:sequence> " & _
            "<xs:element name=""title"" type=""xs:string"" /> " & _
            "<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> "


    Return generatedXmlSchema

End Function

'************************************************************************************
'
'  Helper method that gets a schema
'
'************************************************************************************
Private Function getSchema(ByVal generateSchema As Boolean) As XmlSchema
    Dim xs As XmlSchemaSet = New XmlSchemaSet
    Dim schema As XmlSchema
    Try
        schema = xs.Add("http://www.contoso.com/books", "booksData.xsd")
    Catch ex As System.IO.FileNotFoundException
        If generateSchema Then
            Dim xmlSchemaString As String = generateXMLSchema()
            Dim byteArray() As Byte = Encoding.UTF8.GetBytes(xmlSchemaString)
            Dim stream As MemoryStream = New MemoryStream(byteArray)
            Dim reader As XmlReader = XmlReader.Create(stream)
            schema = xs.Add("http://www.contoso.com/books", reader)
        Else
            Return Nothing
        End If
    End Try
    Return schema
End Function

'************************************************************************************
'
'  Helper method to validate the XML against the schema.
'
'************************************************************************************
Private Sub validateXML(ByVal generateSchema As Boolean, ByVal doc As XmlDocument)
    If (doc.Schemas.Count = 0) Then
        ' Helper method to retrieve schema.
        Dim schema As XmlSchema = getSchema(generateSchema)
        doc.Schemas.Add(schema)
    End If
    ' Use an event handler to validate the XML node against the schema.
    doc.Validate(AddressOf settings_ValidationEventHandler)
End Sub

'************************************************************************************
'
'  Event handler that is raised when XML doesn't validate against the schema.
'
'************************************************************************************
Private Sub settings_ValidationEventHandler(ByVal sender As Object, ByVal e As System.Xml.Schema.ValidationEventArgs)
    If (e.Severity = XmlSeverityType.Warning) Then
        System.Windows.Forms.MessageBox.Show(("The following validation warning occurred: " & e.Message))
    ElseIf (e.Severity = XmlSeverityType.Error) Then
        System.Windows.Forms.MessageBox.Show(("The following critical validation errors occurred: " & e.Message))
        Dim objectType As Type = sender.GetType
    End If
End Sub

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

En savoir plus : Validation d’un document XML dans le DOMLearn more: Validating an XML Document in the DOM

Vous pouvez utiliser des propriétés pour naviguer dans un document XML.You can use properties to navigate around an XML document. Mais avant d’utiliser une d'entre elles, passons rapidement en revue quelques termes.But before you use any of them, let's quickly review a few terms. Votre document est composé de nœuds.Your document is composed of nodes. Chaque nœud a comme seul parent nœud directement au-dessus de lui.Each node has as single parent node directly above it. Le seul nœud qui n’a pas d’un nœud parent est la racine du document, comme c’est le nœud de niveau supérieur.The only node that does not have a parent node is the document root, as it is the top-level node. La plupart des nœuds peuvent avoir enfant nœuds, qui sont des nœuds situés directement sous eux.Most nodes can have child nodes, which are nodes directly below them. Les nœuds situés au même niveau sont frères.Nodes that are at the same level are siblings.

Les exemples suivants montrent comment obtenir le nœud racine, atteindre le premier nœud enfant du nœud racine, accéder à tous ses nœuds enfants, extraire à nouveau vers le nœud parent, puis naviguez entre les nœuds frères.The following examples show you how to obtain the root node, jump to the first child node of the root node, access any of its child nodes, get back out to the parent node, and then navigate across sibling nodes.

Démarrer avec le nœud racineStart with the root node

Cet exemple obtient le nœud racine, puis utilise ce nœud pour afficher le contenu du document à la console.This example gets the root node and then uses that node to output the contents of the document to the console.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   
   //Create the XmlDocument.
   XmlDocument^ doc = gcnew XmlDocument;
   doc->LoadXml( "<?xml version='1.0' ?><book genre='novel' ISBN='1-861001-57-5'><title>Pride And Prejudice</title></book>" );
   
   //Display the document element.
   Console::WriteLine( doc->DocumentElement->OuterXml );
}

using System;
using System.IO;
using System.Xml;

public class Sample
{
  public static void Main()
  {
    //Create the XmlDocument.
    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<?xml version='1.0' ?>" +
                "<book genre='novel' ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "</book>");

    //Display the document element.
    Console.WriteLine(doc.DocumentElement.OuterXml);
 }
}
Option Strict
Option Explicit

Imports System
Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        'Create the XmlDocument.
        Dim doc As New XmlDocument()
        doc.LoadXml("<?xml version='1.0' ?>" & _
                    "<book genre='novel' ISBN='1-861001-57-5'>" & _
                    "<title>Pride And Prejudice</title>" & _
                    "</book>")
        
        'Display the document element.
        Console.WriteLine(doc.DocumentElement.OuterXml)
    End Sub 'Main
End Class 'Sample

Obtenir les nœuds enfantsGet child nodes

Cet exemple passe vers le premier nœud enfant du nœud racine et puis effectue une itération au sein des nœuds enfants de ce nœud s’il en existe.This example jumps to the first child node of the root node and then iterates through the child nodes of that node if any exist.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;

int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->LoadXml( "<book ISBN='1-861001-57-5'>"
   "<title>Pride And Prejudice</title>"
   "<price>19.95</price>"
   "</book>" );
   XmlNode^ root = doc->FirstChild;
   
   //Display the contents of the child nodes.
   if ( root->HasChildNodes )
   {
      for ( int i = 0; i < root->ChildNodes->Count; i++ )
      {
         Console::WriteLine( root->ChildNodes[ i ]->InnerText );
      }
   }
}
using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<book ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "<price>19.95</price>" +
                "</book>");

    XmlNode root = doc.FirstChild;

    //Display the contents of the child nodes.
    if (root.HasChildNodes)
    {
      for (int i=0; i<root.ChildNodes.Count; i++)
      {
        Console.WriteLine(root.ChildNodes[i].InnerText);
      }
    }
  }
}
Option Strict
Option Explicit

Imports System
Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        
        Dim doc As New XmlDocument()
        doc.LoadXml("<book ISBN='1-861001-57-5'>" & _
                    "<title>Pride And Prejudice</title>" & _
                    "<price>19.95</price>" & _
                    "</book>")
        
        Dim root As XmlNode = doc.FirstChild
        
        'Display the contents of the child nodes.
        If root.HasChildNodes Then
            Dim i As Integer
            For i = 0 To root.ChildNodes.Count - 1
                Console.WriteLine(root.ChildNodes(i).InnerText)
            Next i
        End If
    End Sub 'Main
End Class 'Sample

Revenir au nœud parentGet back to the parent node

Utilisez la propriété ParentNode.Use the ParentNode property.

Reportez-vous au dernier nœud enfantRefer to the last child node

Cet exemple écrit le prix d’un livre dans la console.This example writes the price of a book to the console. Le nœud de prix est le dernier enfant d’un nœud book.The price node is the last child of a book node.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->LoadXml( "<book ISBN='1-861001-57-5'>"
   "<title>Pride And Prejudice</title>"
   "<price>19.95</price>"
   "</book>" );
   XmlNode^ root = doc->FirstChild;
   Console::WriteLine( "Display the price element..." );
   Console::WriteLine( root->LastChild->OuterXml );
}

using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<book ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "<price>19.95</price>" +
                "</book>");

    XmlNode root = doc.FirstChild;

    Console.WriteLine("Display the price element...");
    Console.WriteLine(root.LastChild.OuterXml);
  }
}
Option Explicit
Option Strict

Imports System
Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        
        Dim doc As New XmlDocument()
        doc.LoadXml("<book ISBN='1-861001-57-5'>" & _
                    "<title>Pride And Prejudice</title>" & _
                    "<price>19.95</price>" & _
                    "</book>")
        
        Dim root As XmlNode = doc.FirstChild
        
        Console.WriteLine("Display the price element...")
        Console.WriteLine(root.LastChild.OuterXml)
    End Sub 'Main
End Class 'Sample

Naviguer vers l’avant entre frèresNavigate forward across siblings

Cet exemple fait avancer à partir de livres.This example moves forward from book to book. Nœuds book sont des frères de l’autre.Book nodes are siblings to one another.

#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "books.xml" );
   XmlNode^ currNode = doc->DocumentElement->FirstChild;
   Console::WriteLine( "First book..." );
   Console::WriteLine( currNode->OuterXml );
   XmlNode^ nextNode = currNode->NextSibling;
   Console::WriteLine( "\r\nSecond book..." );
   Console::WriteLine( nextNode->OuterXml );
}

using System;
using System.Xml;

public class Sample {

  public static void Main() {

      XmlDocument doc = new XmlDocument();
      doc.Load("books.xml");

      XmlNode currNode = doc.DocumentElement.FirstChild;
      Console.WriteLine("First book...");
      Console.WriteLine(currNode.OuterXml);

      XmlNode nextNode = currNode.NextSibling;
      Console.WriteLine("\r\nSecond book...");
      Console.WriteLine(nextNode.OuterXml); 

  }
}
Imports System
Imports System.Xml
Imports Microsoft.VisualBasic

public class Sample 

  public shared sub Main() 

      Dim doc as XmlDocument = new XmlDocument()
      doc.Load("books.xml")

      Dim currNode as XmlNode = doc.DocumentElement.FirstChild
      Console.WriteLine("First book...")
      Console.WriteLine(currNode.OuterXml)

      Dim nextNode as XmlNode = currNode.NextSibling
      Console.WriteLine(ControlChars.LF + "Second book...")
      Console.WriteLine(nextNode.OuterXml) 

  end sub
end class

Naviguez vers l’arrière dans les frèresNavigate backwards across siblings

Cet exemple se déplace vers l’arrière à partir de livres.This example moves backwards from book to book.

#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "books.xml" );
   XmlNode^ lastNode = doc->DocumentElement->LastChild;
   Console::WriteLine( "Last book..." );
   Console::WriteLine( lastNode->OuterXml );
   XmlNode^ prevNode = lastNode->PreviousSibling;
   Console::WriteLine( "\r\nPrevious book..." );
   Console::WriteLine( prevNode->OuterXml );
}

using System;
using System.Xml;

public class Sample {

  public static void Main() {

      XmlDocument doc = new XmlDocument();
      doc.Load("books.xml");

      XmlNode lastNode = doc.DocumentElement.LastChild;
      Console.WriteLine("Last book...");
      Console.WriteLine(lastNode.OuterXml);

      XmlNode prevNode = lastNode.PreviousSibling;
      Console.WriteLine("\r\nPrevious book...");
      Console.WriteLine(prevNode.OuterXml);  
  }
}
Imports System
Imports System.Xml
Imports Microsoft.VisualBasic

public class Sample 

  public shared sub Main() 

      Dim doc as XmlDocument = new XmlDocument()
      doc.Load("books.xml")

      Dim lastNode as XmlNode = doc.DocumentElement.LastChild
      Console.WriteLine("Last book...")
      Console.WriteLine(lastNode.OuterXml)

      Dim prevNode as XmlNode = lastNode.PreviousSibling
      Console.WriteLine(ControlChars.LF + "Previous book...")
      Console.WriteLine(prevNode.OuterXml)  
  end sub
end class

Rechercher des nœudsFind nodes

Le moyen le plus populaire pour rechercher un ou plusieurs nœuds de données consiste à utiliser une chaîne de requête XPath, mais il existe également des méthodes qui ne nécessitent pas une.The most popular way to find one or more nodes of data is to use an XPath query string, but there are also methods that don't require one.

Obtenir un seul nœudGet a single node

Cet exemple localise un livre en utilisant le numéro ISBN.This example locates a book by using the ISBN number.

XmlNode ^XMLDOMProcessing::XMLHelperMethods::GetBook(String ^uniqueAttribute, XmlDocument ^doc)
{
	XmlNamespaceManager ^nsmgr = gcnew XmlNamespaceManager(doc->NameTable);
	nsmgr->AddNamespace("bk", "http://www.contoso.com/books");
	String ^xPathString = "//bk:books/bk:book[@ISBN='" + uniqueAttribute + "']";
	XmlNode ^xmlNode = doc->DocumentElement->SelectSingleNode(xPathString, nsmgr);
	return xmlNode;
}
public XmlNode GetBook(string uniqueAttribute, XmlDocument doc)
{
    XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books");
    string xPathString = "//bk:books/bk:book[@ISBN='" + uniqueAttribute + "']";
    XmlNode xmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr);
   return xmlNode;
}
Public Function GetBook(ByVal uniqueAttribute As String, ByVal doc As XmlDocument) As XmlNode
    Dim nsmgr As XmlNamespaceManager = New XmlNamespaceManager(doc.NameTable)
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books")
    Dim xPathString As String = ("//bk:books/bk:book[@ISBN='" _
                & (uniqueAttribute & "']"))
    Dim xmlNode As XmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr)
    Return xmlNode
End Function

La chaîne utilisée dans cet exemple est une requête Xpath.The string used in this example is an Xpath query. Vous trouverez des exemples plus d'entre eux ici : Exemples de XPath.You can find more examples of them here: XPath examples.

Vous pouvez également utiliser le GetElementById pour récupérer des nœuds.You can also use the GetElementById to retrieve nodes. Pour utiliser cette approche, vous devrez définir ID dans les déclarations de définition de type de document de votre fichier XML.To use this approach, you'll have to define ID's in the document type definition declarations of your XML file.

Une fois que vous obtenez un nœud, vous obtenez la valeur des attributs ou des nœuds enfants.After you get a node, you get the value of attributes or child nodes. Cet exemple fait avec un nœud book.This example does that with a book node.

void XMLDOMProcessing::XMLHelperMethods::GetBookInformation
(String ^%title, String ^%ISBN, String ^%publicationDate, String ^%price, String ^%genre, XmlNode ^book)
{
	XmlElement ^bookElement = safe_cast<XmlElement^>(book);

	// Get the attributes of a book.        
	XmlAttribute ^attr = bookElement->GetAttributeNode("ISBN");
	ISBN = attr->InnerXml;

	attr = bookElement->GetAttributeNode("genre");
	genre = attr->InnerXml;

	attr = bookElement->GetAttributeNode("publicationdate");
	publicationDate = attr->InnerXml;

	// Get the values of child elements of a book.
	title = bookElement["title"]->InnerText;
	price = bookElement["price"]->InnerText;
}
public void GetBookInformation(ref string title, ref string ISBN, ref string publicationDate,
    ref string price, ref string genre, XmlNode book)
{
    XmlElement bookElement = (XmlElement)book;

    // Get the attributes of a book.        
    XmlAttribute attr = bookElement.GetAttributeNode("ISBN");
    ISBN = attr.InnerXml;

    attr = bookElement.GetAttributeNode("genre");
    genre = attr.InnerXml;

    attr = bookElement.GetAttributeNode("publicationdate");
    publicationDate = attr.InnerXml;

    // Get the values of child elements of a book.
    title = bookElement["title"].InnerText;
    price = bookElement["price"].InnerText;
}
Public Sub GetBookInformation(ByRef title As String, ByRef ISBN As String, ByRef publicationDate As String, ByRef price As String, ByRef genre As String, ByVal book As XmlNode)
    Dim bookElement As XmlElement = CType(book, XmlElement)
    ' Get the attributes of a book.        
    Dim attr As XmlAttribute = bookElement.GetAttributeNode("ISBN")
    ISBN = attr.InnerXml
    attr = bookElement.GetAttributeNode("genre")
    genre = attr.InnerXml
    attr = bookElement.GetAttributeNode("publicationdate")
    publicationDate = attr.InnerXml
    ' Get the values of child elements of a book.
    title = bookElement("title").InnerText
    price = bookElement("price").InnerText
End Sub

Obtenir une collection de nœudsGet a collection of nodes

Cet exemple sélectionne tous les livres où le nom de l’auteur est Austen, puis modifie le prix de ces livres.This example selects all books where the author's last name is Austen, and then changes the price of those books.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "booksort.xml" );
   XmlNodeList^ nodeList;
   XmlNode^ root = doc->DocumentElement;
   nodeList = root->SelectNodes( "descendant::book[author/last-name='Austen']" );
   
   //Change the price on the books.
   System::Collections::IEnumerator^ myEnum = nodeList->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      XmlNode^ book = safe_cast<XmlNode^>(myEnum->Current);
      book->LastChild->InnerText = "15.95";
   }

   Console::WriteLine( "Display the modified XML document...." );
   doc->Save( Console::Out );
}

using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.Load("booksort.xml");

    XmlNodeList nodeList;
    XmlNode root = doc.DocumentElement;

    nodeList=root.SelectNodes("descendant::book[author/last-name='Austen']");
 
    //Change the price on the books.
    foreach (XmlNode book in nodeList)
    {
      book.LastChild.InnerText="15.95";
    }

    Console.WriteLine("Display the modified XML document....");
    doc.Save(Console.Out);
    
  }
}
Imports System
Imports System.IO
Imports System.Xml

public class Sample

  public shared sub Main()

    'Create the XmlDocument.
    Dim doc as XmlDocument = new XmlDocument()
    doc.Load("booksort.xml")
           
    Dim book as XmlNode
    Dim nodeList as XmlNodeList 
    Dim root as XmlNode = doc.DocumentElement

    nodeList=root.SelectNodes("descendant::book[author/last-name='Austen']")
 
    'Change the price on the books.
    for each book in nodeList      
      book.LastChild.InnerText="15.95"
    next 

    Console.WriteLine("Display the modified XML document....")
    doc.Save(Console.Out)
    
  end sub
end class

Vous pouvez également obtenir une collection de nœuds en utilisant le nom du nœud.You can also get a collection of nodes by using the name of the node. Par exemple, cet exemple obtient une collection de tous les titres de livres.For example, this example gets a collection of all book titles.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;

int main()
{
   //Create the XmlDocument.
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "books.xml" );
   
   //Display all the book titles.
   XmlNodeList^ elemList = doc->GetElementsByTagName( "title" );
   for ( int i = 0; i < elemList->Count; i++ )
   {
      Console::WriteLine( elemList[ i ]->InnerXml );
   }
}
using System;
using System.IO;
using System.Xml;

public class Sample
{
  public static void Main()
  {
    //Create the XmlDocument.
    XmlDocument doc = new XmlDocument();
    doc.Load("books.xml");

    //Display all the book titles.
    XmlNodeList elemList = doc.GetElementsByTagName("title");
    for (int i=0; i < elemList.Count; i++)
    {   
      Console.WriteLine(elemList[i].InnerXml);
    }  

  }
}
Option Explicit
Option Strict

Imports System
Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        'Create the XmlDocument.
        Dim doc As New XmlDocument()
        doc.Load("books.xml")
        
        'Display all the book titles.
        Dim elemList As XmlNodeList = doc.GetElementsByTagName("title")
        Dim i As Integer
        For i = 0 To elemList.Count - 1
            Console.WriteLine(elemList(i).InnerXml)
        Next i
    End Sub 'Main 
End Class 'Sample

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

En savoir plus : Sélection de nœuds à l’aide de la navigation XPathLearn more: Select Nodes Using XPath Navigation

Modifier des nœudsEdit nodes

Cet exemple modifie un nœud book et ses attributs.This example edits a book node and its attributes.

bool XMLDOMProcessing::XMLHelperMethods::editBook(String ^title, String ^ISBN, String ^publicationDate, String ^genre, String ^price, XmlNode ^book, bool validateNode, bool generateSchema)
{

	XmlElement ^bookElement = safe_cast<XmlElement^>(book);

	// Get the attributes of a book.        
	bookElement->SetAttribute("ISBN", ISBN);
	bookElement->SetAttribute("genre", genre);
	bookElement->SetAttribute("publicationdate", publicationDate);

	// Get the values of child elements of a book.
	bookElement["title"]->InnerText = title;
	bookElement["price"]->InnerText = price;

	if (validateNode)
	{
		if (validateXML(generateSchema, bookElement->OwnerDocument))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	return true;
}
public void editBook(string title, string ISBN, string publicationDate,
    string genre, string price, XmlNode book, bool validateNode, bool generateSchema)
{

    XmlElement bookElement = (XmlElement)book;

    // Get the attributes of a book.        
    bookElement.SetAttribute("ISBN", ISBN);
    bookElement.SetAttribute("genre", genre);
    bookElement.SetAttribute("publicationdate", publicationDate);

    // Get the values of child elements of a book.
    bookElement["title"].InnerText = title;
    bookElement["price"].InnerText = price;

    if (validateNode)
    {
        validateXML(generateSchema, bookElement.OwnerDocument);
    }
}
Public Sub editBook(ByVal title As String, ByVal ISBN As String,
                    ByVal publicationDate As String, ByVal genre As String,
                    ByVal price As String, ByVal book As XmlNode, ByVal validateNode As Boolean,
                    ByVal generateSchema As Boolean)

    Dim bookElement As XmlElement = CType(book, XmlElement)

    ' Get the attributes of a book.        
    bookElement.SetAttribute("ISBN", ISBN)
    bookElement.SetAttribute("genre", genre)
    bookElement.SetAttribute("publicationdate", publicationDate)

    ' Get the values of child elements of a book.
    bookElement("title").InnerText = title
    bookElement("price").InnerText = price
    If validateNode Then
        validateXML(generateSchema, bookElement.OwnerDocument)
    End If

End Sub

En savoir plus : Modification de nœuds, de contenu et de valeurs dans un document XMLLearn more: Modifying Nodes, Content, and Values in an XML Document

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Ajouter des nœudsAdd nodes

Pour ajouter un nœud, utilisez le CreateElement méthode ou le CreateNode (méthode).To add a node, use the CreateElement method or the CreateNode method.

Pour ajouter un nœud de données comme un livre, utilisez le CreateElement (méthode).To add a data node such as a book, use the CreateElement method.

Pour tout autre type de nœud comme un commentaire, nœud whitespace ou nœud CDATA, utilisez le CreateNode (méthode).For any other type of node such as a comment, whitespace node, or CDATA node, use the CreateNode method.

Cet exemple crée un nœud book, ajoute des attributs à ce nœud, puis ajoute ce nœud au document.This example creates a book node, adds attributes to that node, and then adds that node to the document.

XmlElement ^XMLDOMProcessing::XMLHelperMethods::AddNewBook(String ^genre, String ^ISBN, String ^misc, String ^title, String ^price, XmlDocument ^doc)
{
	// Create a new book element.
	XmlElement ^bookElement = doc->CreateElement("book", "http://www.contoso.com/books");

	// Create attributes for book and append them to the book element.
	XmlAttribute ^attribute = doc->CreateAttribute("genre");
	attribute->Value = genre;
	bookElement->Attributes->Append(attribute);

	attribute = doc->CreateAttribute("ISBN");
	attribute->Value = ISBN;
	bookElement->Attributes->Append(attribute);

	attribute = doc->CreateAttribute("publicationdate");
	attribute->Value = misc;
	bookElement->Attributes->Append(attribute);

	// Create and append a child element for the title of the book.
	XmlElement ^titleElement = doc->CreateElement("title");
	titleElement->InnerText = title;
	bookElement->AppendChild(titleElement);

	// Introduce a newline character so that XML is nicely formatted.
	bookElement->InnerXml = bookElement->InnerXml->Replace(titleElement->OuterXml, "\n    " + titleElement->OuterXml + " \n    ");

	// Create and append a child element for the price of the book.
	XmlElement ^priceElement = doc->CreateElement("price");
	priceElement->InnerText = price;
	bookElement->AppendChild(priceElement);

	// Introduce a newline character so that XML is nicely formatted.
	bookElement->InnerXml = bookElement->InnerXml->Replace(priceElement->OuterXml, priceElement->OuterXml + "   \n  ");

	return bookElement;

}
public XmlElement AddNewBook(string genre, string ISBN, string misc, 
    string title, string price, XmlDocument doc)
{
    // Create a new book element.
    XmlElement bookElement = doc.CreateElement("book", "http://www.contoso.com/books");

    // Create attributes for book and append them to the book element.
    XmlAttribute attribute = doc.CreateAttribute("genre");
    attribute.Value = genre;
    bookElement.Attributes.Append(attribute);

    attribute = doc.CreateAttribute("ISBN");
    attribute.Value = ISBN;
    bookElement.Attributes.Append(attribute);

    attribute = doc.CreateAttribute("publicationdate");
    attribute.Value = misc;
    bookElement.Attributes.Append(attribute);

    // Create and append a child element for the title of the book.
    XmlElement titleElement = doc.CreateElement("title");
    titleElement.InnerText = title;
    bookElement.AppendChild(titleElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = 
        bookElement.InnerXml.Replace(titleElement.OuterXml, 
        "\n    " + titleElement.OuterXml + " \n    ");
    
    // Create and append a child element for the price of the book.
    XmlElement priceElement = doc.CreateElement("price");
    priceElement.InnerText= price;
    bookElement.AppendChild(priceElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml =
        bookElement.InnerXml.Replace(priceElement.OuterXml, priceElement.OuterXml + "   \n  ");

    return bookElement;
     
}
Public Function AddNewBook(ByVal genre As String, ByVal ISBN As String, ByVal misc As String, ByVal title As String, ByVal price As String, ByVal doc As XmlDocument) As XmlElement
    ' Create a new book element.
    Dim bookElement As XmlElement = doc.CreateElement("book", "http://www.contoso.com/books")

    ' Create attributes for book and append them to the book element.
    Dim attribute As XmlAttribute = doc.CreateAttribute("genre")
    attribute.Value = genre
    bookElement.Attributes.Append(attribute)

    attribute = doc.CreateAttribute("ISBN")
    attribute.Value = ISBN
    bookElement.Attributes.Append(attribute)

    attribute = doc.CreateAttribute("publicationdate")
    attribute.Value = misc
    bookElement.Attributes.Append(attribute)

    ' Create and append a child element for the title of the book.
    Dim titleElement As XmlElement = doc.CreateElement("title")
    titleElement.InnerText = title
    bookElement.AppendChild(titleElement)

    ' Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = bookElement.InnerXml.Replace(titleElement.OuterXml, _
                           "\n   " & titleElement.OuterXml & " " & ControlChars.NewLine + "    ")
    ' Create and append a child element for the price of the book.
    Dim priceElement As XmlElement = doc.CreateElement("price")
    priceElement.InnerText = price
    bookElement.AppendChild(priceElement)

    ' Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = bookElement.InnerXml.Replace(priceElement.OuterXml,
                                                        (priceElement.OuterXml & "   " & ControlChars.NewLine & "  "))
    Return bookElement
End Function

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

En savoir plus : Insertion de nœuds dans un document XMLLearn more: Inserting Nodes into an XML Document

Supprimer des nœudsRemove nodes

Pour supprimer un nœud, utilisez le RemoveChild (méthode).To remove a node, use the RemoveChild method.

Cet exemple supprime un livre à partir du document et de tout espace blanc qui s’affiche juste avant le nœud book.This example removes a book from the document and any whitespace that appears just before the book node.

void XMLDOMProcessing::XMLHelperMethods::deleteBook(XmlNode ^book)
{
	XmlNode ^prevNode = book->PreviousSibling;

	book->OwnerDocument->DocumentElement->RemoveChild(book);


	if (prevNode->NodeType == XmlNodeType::Whitespace || prevNode->NodeType == XmlNodeType::SignificantWhitespace)
	{
		prevNode->OwnerDocument->DocumentElement->RemoveChild(prevNode);
	}
}
public void deleteBook(XmlNode book)
{
    XmlNode prevNode = book.PreviousSibling;
    
    book.OwnerDocument.DocumentElement.RemoveChild(book);


    if (prevNode.NodeType == XmlNodeType.Whitespace || 
        prevNode.NodeType == XmlNodeType.SignificantWhitespace)
    {
        prevNode.OwnerDocument.DocumentElement.RemoveChild(prevNode);
    }
}
Public Sub deleteBook(ByVal book As XmlNode)

    Dim prevNode As XmlNode = book.PreviousSibling
    book.OwnerDocument.DocumentElement.RemoveChild(book)

    If ((prevNode.NodeType = XmlNodeType.Whitespace) _
                OrElse (prevNode.NodeType = XmlNodeType.SignificantWhitespace)) Then
        prevNode.OwnerDocument.DocumentElement.RemoveChild(prevNode)

    End If
End Sub

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

En savoir plus : Suppression de nœuds, de contenu et de valeurs d’un document XMLLearn more: Removing Nodes, Content, and Values from an XML Document

Nœuds de positionPosition nodes

Vous pouvez choisir où vous souhaitez un nœud apparaissent dans votre document en utilisant le InsertBefore et InsertAfter méthodes.You can choose where you want a node to appear in your document by using the InsertBefore and InsertAfter methods.

Cet exemple montre deux méthodes d’assistance.This example shows two helper methods. Un d’eux déplace un nœud supérieur dans une liste.One of them moves a node higher in a list. Autres celui déplace un nœud inférieur.The other one moves a node lower.

Ces méthodes peuvent être utilisés dans une application qui permet aux utilisateurs de la documentation haut et bas dans une liste de livres.These methods could be used in an application that enables users to move books up and down in a list of books. Lorsqu’un utilisateur choisit un livre et appuie sur le haut ou vers le bas de bouton, votre code peut appeler des méthodes comme celles-ci pour positionner le nœud book correspondant avant ou après les autres nœuds du livre.When a user chooses a book and presses an up or down button, your code could call methods like these to position the corresponding book node before or after other book nodes.

//************************************************************************************
//
//  Summary: Move elements up in the XML.
//  
//
//************************************************************************************
void XMLDOMProcessing::XMLHelperMethods::MoveElementUp(XmlNode ^book)
{
	XmlNode ^previousNode = book->PreviousSibling;
	while (previousNode != nullptr && (previousNode->NodeType != XmlNodeType::Element))
	{
		previousNode = previousNode->PreviousSibling;
	}
	if (previousNode != nullptr)
	{
		XmlNode ^newLineNode = book->NextSibling;
		book->OwnerDocument->DocumentElement->RemoveChild(book);
		if (newLineNode->NodeType == XmlNodeType::Whitespace || newLineNode->NodeType == XmlNodeType::SignificantWhitespace)
		{
			newLineNode->OwnerDocument->DocumentElement->RemoveChild(newLineNode);
		}
		InsertBookElement(safe_cast<XmlElement^>(book), Constants::positionAbove, previousNode, false, false);
	}
}

//************************************************************************************
//
//  Summary: Move elements down in the XML.
//  
//
//************************************************************************************
void XMLDOMProcessing::XMLHelperMethods::MoveElementDown(XmlNode ^book)
{
	// Walk backwards until we find an element - ignore text nodes
	XmlNode ^NextNode = book->NextSibling;
	while (NextNode != nullptr && (NextNode->NodeType != XmlNodeType::Element))
	{
		NextNode = NextNode->NextSibling;
	}
	if (NextNode != nullptr)
	{
		XmlNode ^newLineNode = book->PreviousSibling;
		book->OwnerDocument->DocumentElement->RemoveChild(book);
		if (newLineNode->NodeType == XmlNodeType::Whitespace || newLineNode->NodeType == XmlNodeType::SignificantWhitespace)
		{
			newLineNode->OwnerDocument->DocumentElement->RemoveChild(newLineNode);
		}

		InsertBookElement(safe_cast<XmlElement^>(book), Constants::positionBelow, NextNode, false, false);
	}

}
//************************************************************************************
//
//  Summary: Move elements up in the XML.
//  
//
//************************************************************************************

public void MoveElementUp(XmlNode book)
{
    XmlNode previousNode = book.PreviousSibling;
    while (previousNode != null && (previousNode.NodeType != XmlNodeType.Element))
    {
        previousNode = previousNode.PreviousSibling;
    }
    if (previousNode != null)
    {
        XmlNode newLineNode = book.NextSibling;
        book.OwnerDocument.DocumentElement.RemoveChild(book);
        if (newLineNode.NodeType == XmlNodeType.Whitespace | 
            newLineNode.NodeType == XmlNodeType.SignificantWhitespace)
        {
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode);
        }
        InsertBookElement((XmlElement)book, Constants.positionAbove, 
            previousNode, false, false);
    }
}


//************************************************************************************
//
//  Summary: Move elements down in the XML.
//  
//
//************************************************************************************
public void MoveElementDown(XmlNode book)
{
    // Walk backwards until we find an element - ignore text nodes
    XmlNode NextNode = book.NextSibling;
    while (NextNode != null && (NextNode.NodeType != XmlNodeType.Element))
    {
        NextNode = NextNode.NextSibling;
    }
    if (NextNode != null)
    {
        XmlNode newLineNode = book.PreviousSibling;
        book.OwnerDocument.DocumentElement.RemoveChild(book);
        if (newLineNode.NodeType == XmlNodeType.Whitespace |
            newLineNode.NodeType == XmlNodeType.SignificantWhitespace)
        {
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode);
        }

        InsertBookElement((XmlElement)book, Constants.positionBelow, 
            NextNode, false, false);
    }

}
'************************************************************************************
'
'  Summary: Move elements up in the XML.
'  
'
'************************************************************************************
Public Sub MoveElementUp(ByVal book As XmlNode)
    Dim previousNode As XmlNode = book.PreviousSibling

    While ((Not (previousNode) Is Nothing) _
                AndAlso (previousNode.NodeType <> XmlNodeType.Element))
        previousNode = previousNode.PreviousSibling

    End While
    If (Not (previousNode) Is Nothing) Then
        Dim newLineNode As XmlNode = book.NextSibling
        book.OwnerDocument.DocumentElement.RemoveChild(book)

        If ((newLineNode.NodeType = XmlNodeType.Whitespace) _
                    Or (newLineNode.NodeType = XmlNodeType.SignificantWhitespace)) Then
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode)
        End If

        InsertBookElement(CType(book, XmlElement), Constants.positionAbove,
                          previousNode, False, False)
    End If
End Sub

'************************************************************************************
'
'  Summary: Move elements down in the XML.
'  
'
'************************************************************************************
Public Sub MoveElementDown(ByVal book As XmlNode)
    ' Walk backwards until we find an element - ignore text nodes
    Dim NextNode As XmlNode = book.NextSibling

    While ((Not (NextNode) Is Nothing) _
                AndAlso (NextNode.NodeType <> XmlNodeType.Element))
        NextNode = NextNode.NextSibling

    End While

    If (Not (NextNode) Is Nothing) Then
        Dim newLineNode As XmlNode = book.PreviousSibling
        book.OwnerDocument.DocumentElement.RemoveChild(book)

        If ((newLineNode.NodeType = XmlNodeType.Whitespace) _
                    Or (newLineNode.NodeType = XmlNodeType.SignificantWhitespace)) Then
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode)
        End If

        InsertBookElement(CType(book, XmlElement), Constants.positionBelow,
                          NextNode, False, False)
    End If
End Sub

Exemple complet : Manipuler XML en mémoire à l’aide de la classe XmlDocument et autres types connexesComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Constructeurs

XmlDocument() XmlDocument() XmlDocument() XmlDocument()

Initialise une nouvelle instance de la classe XmlDocument.Initializes a new instance of the XmlDocument class.

XmlDocument(XmlImplementation) XmlDocument(XmlImplementation) XmlDocument(XmlImplementation) XmlDocument(XmlImplementation)

Initialise une nouvelle instance de la classe XmlDocument avec le XmlImplementation spécifié.Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

XmlDocument(XmlNameTable) XmlDocument(XmlNameTable) XmlDocument(XmlNameTable) XmlDocument(XmlNameTable)

Initialise une nouvelle instance de la classe XmlDocument avec le XmlNameTable spécifié.Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

Propriétés

Attributes Attributes Attributes Attributes

Obtient un XmlAttributeCollection contenant les attributs du nœud.Gets an XmlAttributeCollection containing the attributes of this node.

(Inherited from XmlNode)
BaseURI BaseURI BaseURI BaseURI

Obtient l'URI de base du nœud actuel.Gets the base URI of the current node.

ChildNodes ChildNodes ChildNodes ChildNodes

Obtient tous les nœuds enfants du nœud.Gets all the child nodes of the node.

(Inherited from XmlNode)
DocumentElement DocumentElement DocumentElement DocumentElement

Obtient l'élément XmlElement racine pour le document.Gets the root XmlElement for the document.

DocumentType DocumentType DocumentType DocumentType

Obtient le nœud contenant la déclaration DOCTYPE.Gets the node containing the DOCTYPE declaration.

FirstChild FirstChild FirstChild FirstChild

Obtient le premier enfant du nœud.Gets the first child of the node.

(Inherited from XmlNode)
HasChildNodes HasChildNodes HasChildNodes HasChildNodes

Obtient une valeur indiquant si ce nœud possède des nœuds enfants.Gets a value indicating whether this node has any child nodes.

(Inherited from XmlNode)
Implementation Implementation Implementation Implementation

Obtient l'objet XmlImplementation pour le document actif.Gets the XmlImplementation object for the current document.

InnerText InnerText InnerText InnerText

Lève une exception InvalidOperationException dans tous les cas.Throws an InvalidOperationException in all cases.

InnerXml InnerXml InnerXml InnerXml

Obtient ou définit le balisage représentant les enfants du nœud actuel.Gets or sets the markup representing the children of the current node.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtient une valeur indiquant si le nœud actuel est en lecture seule.Gets a value indicating whether the current node is read-only.

Item[String, String] Item[String, String] Item[String, String] Item[String, String]

Obtient le premier élément enfant avec le LocalName et le NamespaceURI spécifiés.Gets the first child element with the specified LocalName and NamespaceURI.

(Inherited from XmlNode)
Item[String] Item[String] Item[String] Item[String]

Obtient le premier élément enfant avec le Name spécifié.Gets the first child element with the specified Name.

(Inherited from XmlNode)
LastChild LastChild LastChild LastChild

Obtient le dernier enfant du nœud.Gets the last child of the node.

(Inherited from XmlNode)
LocalName LocalName LocalName LocalName

Obtient le nom local du nœud.Gets the local name of the node.

Name Name Name Name

Obtient le nom qualifié du nœud.Gets the qualified name of the node.

NamespaceURI NamespaceURI NamespaceURI NamespaceURI

Obtient l'URI de l'espace de noms de ce nœud.Gets the namespace URI of this node.

(Inherited from XmlNode)
NameTable NameTable NameTable NameTable

Obtient l'élément XmlNameTable associé à cette implémentation.Gets the XmlNameTable associated with this implementation.

NextSibling NextSibling NextSibling NextSibling

Obtient le nœud qui suit immédiatement ce nœud.Gets the node immediately following this node.

(Inherited from XmlNode)
NodeType NodeType NodeType NodeType

Obtient le type du nœud actuel.Gets the type of the current node.

OuterXml OuterXml OuterXml OuterXml

Obtient la marque contenant ce nœud et tous ses nœuds enfants.Gets the markup containing this node and all its child nodes.

(Inherited from XmlNode)
OwnerDocument OwnerDocument OwnerDocument OwnerDocument

Obtient l'élément XmlDocument auquel le nœud actif appartient.Gets the XmlDocument to which the current node belongs.

ParentNode ParentNode ParentNode ParentNode

Obtient le nœud parent de ce nœud (pour les nœuds qui peuvent avoir des parents).Gets the parent node of this node (for nodes that can have parents).

Prefix Prefix Prefix Prefix

Obtient ou définit le préfixe de l'espace de noms de ce nœud.Gets or sets the namespace prefix of this node.

(Inherited from XmlNode)
PreserveWhitespace PreserveWhitespace PreserveWhitespace PreserveWhitespace

Obtient ou définit une valeur indiquant si les espaces blancs doivent être conservés dans le contenu d'élément.Gets or sets a value indicating whether to preserve white space in element content.

PreviousSibling PreviousSibling PreviousSibling PreviousSibling

Obtient le nœud qui précède immédiatement ce nœud.Gets the node immediately preceding this node.

(Inherited from XmlNode)
PreviousText PreviousText PreviousText PreviousText

Obtient le nœud de texte qui précède immédiatement ce nœud.Gets the text node that immediately precedes this node.

(Inherited from XmlNode)
SchemaInfo SchemaInfo SchemaInfo SchemaInfo

Retourne le jeu d’informations postérieures à la validation du schéma (PSVI, Post-Schema-Validation-Infoset) pour le nœud.Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

Schemas Schemas Schemas Schemas

Obtient ou définit l'objet XmlSchemaSet associé à cet élément XmlDocument.Gets or sets the XmlSchemaSet object associated with this XmlDocument.

Value Value Value Value

Obtient ou définit la valeur du nœud.Gets or sets the value of the node.

(Inherited from XmlNode)
XmlResolver XmlResolver XmlResolver XmlResolver

Définit l'élément XmlResolver à utiliser pour résoudre les ressources externes.Sets the XmlResolver to use for resolving external resources.

Méthodes

AppendChild(XmlNode) AppendChild(XmlNode) AppendChild(XmlNode) AppendChild(XmlNode)

Ajoute le nœud spécifié à la fin de la liste des nœuds enfants de ce nœud.Adds the specified node to the end of the list of child nodes, of this node.

(Inherited from XmlNode)
Clone() Clone() Clone() Clone()

Crée un doublon de ce nœud.Creates a duplicate of this node.

(Inherited from XmlNode)
CloneNode(Boolean) CloneNode(Boolean) CloneNode(Boolean) CloneNode(Boolean)

Crée un doublon de ce nœud.Creates a duplicate of this node.

CreateAttribute(String) CreateAttribute(String) CreateAttribute(String) CreateAttribute(String)

Crée un élément XmlAttribute avec la valeur Name spécifiée.Creates an XmlAttribute with the specified Name.

CreateAttribute(String, String) CreateAttribute(String, String) CreateAttribute(String, String) CreateAttribute(String, String)

Crée un élément XmlAttribute avec le nom qualifié et l'élément NamespaceURI spécifiés.Creates an XmlAttribute with the specified qualified name and NamespaceURI.

CreateAttribute(String, String, String) CreateAttribute(String, String, String) CreateAttribute(String, String, String) CreateAttribute(String, String, String)

Crée un élément XmlAttribute avec les éléments Prefix, LocalName et NamespaceURI spécifiés.Creates an XmlAttribute with the specified Prefix, LocalName, and NamespaceURI.

CreateCDataSection(String) CreateCDataSection(String) CreateCDataSection(String) CreateCDataSection(String)

Crée un élément XmlCDataSection contenant les données spécifiées.Creates an XmlCDataSection containing the specified data.

CreateComment(String) CreateComment(String) CreateComment(String) CreateComment(String)

Crée un élément XmlComment contenant les données spécifiées.Creates an XmlComment containing the specified data.

CreateDefaultAttribute(String, String, String) CreateDefaultAttribute(String, String, String) CreateDefaultAttribute(String, String, String) CreateDefaultAttribute(String, String, String)

Crée un attribut par défaut avec le préfixe, le nom local et l'URI de l'espace de noms spécifiés.Creates a default attribute with the specified prefix, local name and namespace URI.

CreateDocumentFragment() CreateDocumentFragment() CreateDocumentFragment() CreateDocumentFragment()

Crée un objet XmlDocumentFragment.Creates an XmlDocumentFragment.

CreateDocumentType(String, String, String, String) CreateDocumentType(String, String, String, String) CreateDocumentType(String, String, String, String) CreateDocumentType(String, String, String, String)

Retourne un nouvel objet XmlDocumentType.Returns a new XmlDocumentType object.

CreateElement(String) CreateElement(String) CreateElement(String) CreateElement(String)

Crée un élément avec le nom spécifié.Creates an element with the specified name.

CreateElement(String, String) CreateElement(String, String) CreateElement(String, String) CreateElement(String, String)

Crée un élément XmlElement avec le nom qualifié et l'élément NamespaceURI.Creates an XmlElement with the qualified name and NamespaceURI.

CreateElement(String, String, String) CreateElement(String, String, String) CreateElement(String, String, String) CreateElement(String, String, String)

Crée un élément avec les éléments Prefix, LocalName et NamespaceURI spécifiés.Creates an element with the specified Prefix, LocalName, and NamespaceURI.

CreateEntityReference(String) CreateEntityReference(String) CreateEntityReference(String) CreateEntityReference(String)

Crée un élément XmlEntityReference avec le nom spécifié.Creates an XmlEntityReference with the specified name.

CreateNavigator() CreateNavigator() CreateNavigator() CreateNavigator()

Crée un objet XPathNavigator pour naviguer dans ce document.Creates a new XPathNavigator object for navigating this document.

CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode)

Crée un objet XPathNavigator pour naviguer dans ce document, positionné sur l'élément XmlNode spécifié.Creates an XPathNavigator object for navigating this document positioned on the XmlNode specified.

CreateNode(String, String, String) CreateNode(String, String, String) CreateNode(String, String, String) CreateNode(String, String, String)

Crée un élément XmlNode avec le type de nœud, l'élément Name et l'élément NamespaceURI spécifiés.Creates an XmlNode with the specified node type, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String) CreateNode(XmlNodeType, String, String) CreateNode(XmlNodeType, String, String) CreateNode(XmlNodeType, String, String)

Crée un élément XmlNode avec les éléments XmlNodeType, Name et NamespaceURI spécifiés.Creates an XmlNode with the specified XmlNodeType, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String, String) CreateNode(XmlNodeType, String, String, String) CreateNode(XmlNodeType, String, String, String) CreateNode(XmlNodeType, String, String, String)

Crée un élément XmlNode avec les éléments XmlNodeType, Prefix, Name et NamespaceURI spécifiés.Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.

CreateProcessingInstruction(String, String) CreateProcessingInstruction(String, String) CreateProcessingInstruction(String, String) CreateProcessingInstruction(String, String)

Crée un élément XmlProcessingInstruction avec le nom et les données spécifiés.Creates an XmlProcessingInstruction with the specified name and data.

CreateSignificantWhitespace(String) CreateSignificantWhitespace(String) CreateSignificantWhitespace(String) CreateSignificantWhitespace(String)

Crée un nœud XmlSignificantWhitespace.Creates an XmlSignificantWhitespace node.

CreateTextNode(String) CreateTextNode(String) CreateTextNode(String) CreateTextNode(String)

Crée un élément XmlText avec le texte spécifié.Creates an XmlText with the specified text.

CreateWhitespace(String) CreateWhitespace(String) CreateWhitespace(String) CreateWhitespace(String)

Crée un nœud XmlWhitespace.Creates an XmlWhitespace node.

CreateXmlDeclaration(String, String, String) CreateXmlDeclaration(String, String, String) CreateXmlDeclaration(String, String, String) CreateXmlDeclaration(String, String, String)

Crée un nœud XmlDeclaration avec les valeurs spécifiées.Creates an XmlDeclaration node with the specified values.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetElementById(String) GetElementById(String) GetElementById(String) GetElementById(String)

Obtient l'élément XmlElement avec l'ID spécifié.Gets the XmlElement with the specified ID.

GetElementsByTagName(String) GetElementsByTagName(String) GetElementsByTagName(String) GetElementsByTagName(String)

Retourne un élément XmlNodeList contenant la liste de tous les éléments descendants qui correspondent à l'élément Name spécifié.Returns an XmlNodeList containing a list of all descendant elements that match the specified Name.

GetElementsByTagName(String, String) GetElementsByTagName(String, String) GetElementsByTagName(String, String) GetElementsByTagName(String, String)

Retourne un élément XmlNodeList contenant la liste de tous les éléments descendants qui correspondent aux éléments LocalName et NamespaceURI spécifiés.Returns an XmlNodeList containing a list of all descendant elements that match the specified LocalName and NamespaceURI.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Obtient un énumérateur qui effectue les itérations au sein des nœuds enfants du nœud en cours.Gets an enumerator that iterates through the child nodes in the current node.

(Inherited from XmlNode)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetNamespaceOfPrefix(String) GetNamespaceOfPrefix(String) GetNamespaceOfPrefix(String) GetNamespaceOfPrefix(String)

Recherche la déclaration xmlns la plus proche du préfixe spécifié qui se trouve dans la portée du nœud actuel, puis retourne l’URI de l’espace de noms dans la déclaration.Looks up the closest xmlns declaration for the given prefix that is in scope for the current node and returns the namespace URI in the declaration.

(Inherited from XmlNode)
GetPrefixOfNamespace(String) GetPrefixOfNamespace(String) GetPrefixOfNamespace(String) GetPrefixOfNamespace(String)

Recherche la déclaration xmlns la plus proche de l’URI de l’espace de noms spécifié qui se trouve dans la portée du nœud actuel, puis retourne le préfixe défini dans cette déclaration.Looks up the closest xmlns declaration for the given namespace URI that is in scope for the current node and returns the prefix defined in that declaration.

(Inherited from XmlNode)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
ImportNode(XmlNode, Boolean) ImportNode(XmlNode, Boolean) ImportNode(XmlNode, Boolean) ImportNode(XmlNode, Boolean)

Importe un nœud d'un autre document vers le document actif.Imports a node from another document to the current document.

InsertAfter(XmlNode, XmlNode) InsertAfter(XmlNode, XmlNode) InsertAfter(XmlNode, XmlNode) InsertAfter(XmlNode, XmlNode)

Insère le nœud spécifié immédiatement après le nœud de référence spécifié.Inserts the specified node immediately after the specified reference node.

(Inherited from XmlNode)
InsertBefore(XmlNode, XmlNode) InsertBefore(XmlNode, XmlNode) InsertBefore(XmlNode, XmlNode) InsertBefore(XmlNode, XmlNode)

Insère le nœud spécifié immédiatement avant le nœud de référence spécifié.Inserts the specified node immediately before the specified reference node.

(Inherited from XmlNode)
Load(Stream) Load(Stream) Load(Stream) Load(Stream)

Charge le document XML à partir du flux spécifié.Loads the XML document from the specified stream.

Load(String) Load(String) Load(String) Load(String)

Charge le document XML à partir de l'URL spécifiée.Loads the XML document from the specified URL.

Load(TextReader) Load(TextReader) Load(TextReader) Load(TextReader)

Charge le document XML à partir de l'élément TextReader spécifié.Loads the XML document from the specified TextReader.

Load(XmlReader) Load(XmlReader) Load(XmlReader) Load(XmlReader)

Charge le document XML à partir de l'élément XmlReader spécifié.Loads the XML document from the specified XmlReader.

LoadXml(String) LoadXml(String) LoadXml(String) LoadXml(String)

Charge le document XML à partir de la chaîne spécifiée.Loads the XML document from the specified string.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Place tous les nœuds XmlText dans la profondeur du sous-arbre sous XmlNode dans un formulaire « normal », où seul le balisage (c’est-à-dire les étiquettes, les commentaires, les instructions de traitement, les sections CDATA et les références d’entité) sépare les nœuds XmlText ; en d’autres termes, il n’existe pas de nœuds XmlText adjacents.Puts all XmlText nodes in the full depth of the sub-tree underneath this XmlNode into a "normal" form where only markup (that is, tags, comments, processing instructions, CDATA sections, and entity references) separates XmlText nodes, that is, there are no adjacent XmlText nodes.

(Inherited from XmlNode)
PrependChild(XmlNode) PrependChild(XmlNode) PrependChild(XmlNode) PrependChild(XmlNode)

Ajoute le nœud spécifié au début de la liste des nœuds enfants de ce nœud.Adds the specified node to the beginning of the list of child nodes for this node.

(Inherited from XmlNode)
ReadNode(XmlReader) ReadNode(XmlReader) ReadNode(XmlReader) ReadNode(XmlReader)

Crée un objet XmlNode sur la base des informations de l'élément XmlReader.Creates an XmlNode object based on the information in the XmlReader. Le lecteur doit être positionné sur un nœud ou sur un attribut.The reader must be positioned on a node or attribute.

RemoveAll() RemoveAll() RemoveAll() RemoveAll()

Supprime tous les nœuds enfants et/ou d'attributs du nœud actuel.Removes all the child nodes and/or attributes of the current node.

(Inherited from XmlNode)
RemoveChild(XmlNode) RemoveChild(XmlNode) RemoveChild(XmlNode) RemoveChild(XmlNode)

Supprime le nœud enfant spécifié.Removes specified child node.

(Inherited from XmlNode)
ReplaceChild(XmlNode, XmlNode) ReplaceChild(XmlNode, XmlNode) ReplaceChild(XmlNode, XmlNode) ReplaceChild(XmlNode, XmlNode)

Remplace le nœud enfant oldChild par le nœud newChild.Replaces the child node oldChild with newChild node.

(Inherited from XmlNode)
Save(Stream) Save(Stream) Save(Stream) Save(Stream)

Enregistre le document XML dans le flux spécifié.Saves the XML document to the specified stream.

Save(String) Save(String) Save(String) Save(String)

Enregistre le document XML dans le fichier spécifié.Saves the XML document to the specified file. Si le fichier spécifié existe, cette méthode le remplace.If the specified file exists, this method overwrites it.

Save(TextWriter) Save(TextWriter) Save(TextWriter) Save(TextWriter)

Enregistre le document XML dans l'élément TextWriter spécifié.Saves the XML document to the specified TextWriter.

Save(XmlWriter) Save(XmlWriter) Save(XmlWriter) Save(XmlWriter)

Enregistre le document XML dans l'élément XmlWriter spécifié.Saves the XML document to the specified XmlWriter.

SelectNodes(String) SelectNodes(String) SelectNodes(String) SelectNodes(String)

Sélectionne une liste de nœuds correspondant à l'expression XPath.Selects a list of nodes matching the XPath expression.

(Inherited from XmlNode)
SelectNodes(String, XmlNamespaceManager) SelectNodes(String, XmlNamespaceManager) SelectNodes(String, XmlNamespaceManager) SelectNodes(String, XmlNamespaceManager)

Sélectionne une liste de nœuds correspondant à l'expression XPath.Selects a list of nodes matching the XPath expression. Tous les préfixes trouvés dans l'expression XPath sont résolus à l'aide du XmlNamespaceManager fourni.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Inherited from XmlNode)
SelectSingleNode(String) SelectSingleNode(String) SelectSingleNode(String) SelectSingleNode(String)

Sélectionne le premier XmlNode correspondant à l'expression XPath.Selects the first XmlNode that matches the XPath expression.

(Inherited from XmlNode)
SelectSingleNode(String, XmlNamespaceManager) SelectSingleNode(String, XmlNamespaceManager) SelectSingleNode(String, XmlNamespaceManager) SelectSingleNode(String, XmlNamespaceManager)

Sélectionne le premier XmlNode correspondant à l'expression XPath.Selects the first XmlNode that matches the XPath expression. Tous les préfixes trouvés dans l'expression XPath sont résolus à l'aide du XmlNamespaceManager fourni.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Inherited from XmlNode)
Supports(String, String) Supports(String, String) Supports(String, String) Supports(String, String)

Teste si l'implémentation DOM implémente une fonctionnalité spécifique.Tests if the DOM implementation implements a specific feature.

(Inherited from XmlNode)
ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
Validate(ValidationEventHandler) Validate(ValidationEventHandler) Validate(ValidationEventHandler) Validate(ValidationEventHandler)

Valide l'élément XmlDocument par rapport aux schémas XSD contenus dans la propriété Schemas.Validates the XmlDocument against the XML Schema Definition Language (XSD) schemas contained in the Schemas property.

Validate(ValidationEventHandler, XmlNode) Validate(ValidationEventHandler, XmlNode) Validate(ValidationEventHandler, XmlNode) Validate(ValidationEventHandler, XmlNode)

Valide l'objet XmlNode spécifié par rapport aux schémas XSD de la propriété Schemas.Validates the XmlNode object specified against the XML Schema Definition Language (XSD) schemas in the Schemas property.

WriteContentTo(XmlWriter) WriteContentTo(XmlWriter) WriteContentTo(XmlWriter) WriteContentTo(XmlWriter)

Enregistre tous les enfants du nœud XmlDocument dans l'élément XmlWriter spécifié.Saves all the children of the XmlDocument node to the specified XmlWriter.

WriteTo(XmlWriter) WriteTo(XmlWriter) WriteTo(XmlWriter) WriteTo(XmlWriter)

Enregistre le nœud XmlDocument dans l'élément XmlWriter spécifié.Saves the XmlDocument node to the specified XmlWriter.

Événements

NodeChanged NodeChanged NodeChanged NodeChanged

Se produit quand l'élément Value d'un nœud appartenant à ce document a été modifié.Occurs when the Value of a node belonging to this document has been changed.

NodeChanging NodeChanging NodeChanging NodeChanging

Se produit quand l'élément Value d'un nœud appartenant à ce document est sur le point d'être modifié.Occurs when the Value of a node belonging to this document is about to be changed.

NodeInserted NodeInserted NodeInserted NodeInserted

Se produit quand un nœud appartenant à ce document a été inséré dans un autre nœud.Occurs when a node belonging to this document has been inserted into another node.

NodeInserting NodeInserting NodeInserting NodeInserting

Se produit quand un nœud appartenant à ce document est sur le point d'être inséré dans un autre nœud.Occurs when a node belonging to this document is about to be inserted into another node.

NodeRemoved NodeRemoved NodeRemoved NodeRemoved

Se produit quand un nœud appartenant à ce document a été enlevé à son parent.Occurs when a node belonging to this document has been removed from its parent.

NodeRemoving NodeRemoving NodeRemoving NodeRemoving

Se produit quand un nœud appartenant à ce document est sur le point d'être supprimé du document.Occurs when a node belonging to this document is about to be removed from the document.

Implémentations d’interfaces explicites

ICloneable.Clone() ICloneable.Clone() ICloneable.Clone() ICloneable.Clone()

Pour obtenir une description de ce membre, consultez Clone().For a description of this member, see Clone().

(Inherited from XmlNode)
IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Pour obtenir une description de ce membre, consultez GetEnumerator().For a description of this member, see GetEnumerator().

(Inherited from XmlNode)

Méthodes d’extension

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

CreateNavigator(XmlDocument) CreateNavigator(XmlDocument) CreateNavigator(XmlDocument) CreateNavigator(XmlDocument)
CreateNavigator(XmlDocument, XmlNode) CreateNavigator(XmlDocument, XmlNode) CreateNavigator(XmlDocument, XmlNode) CreateNavigator(XmlDocument, XmlNode)
CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode)
SelectNodes(XmlNode, String) SelectNodes(XmlNode, String) SelectNodes(XmlNode, String) SelectNodes(XmlNode, String)
SelectNodes(XmlNode, String, XmlNamespaceManager) SelectNodes(XmlNode, String, XmlNamespaceManager) SelectNodes(XmlNode, String, XmlNamespaceManager) SelectNodes(XmlNode, String, XmlNamespaceManager)
SelectSingleNode(XmlNode, String) SelectSingleNode(XmlNode, String) SelectSingleNode(XmlNode, String) SelectSingleNode(XmlNode, String)
SelectSingleNode(XmlNode, String, XmlNamespaceManager) SelectSingleNode(XmlNode, String, XmlNamespaceManager) SelectSingleNode(XmlNode, String, XmlNamespaceManager) SelectSingleNode(XmlNode, String, XmlNamespaceManager)
ToXPathNavigable(XmlNode) ToXPathNavigable(XmlNode) ToXPathNavigable(XmlNode) ToXPathNavigable(XmlNode)

S’applique à

Voir aussi