XmlDocument XmlDocument XmlDocument XmlDocument Class

Definição

Representa um documento XML.Represents an XML document. Você pode usar essa classe para carregar, validar, editar, adicionar e posicionar o XML em um documento.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
Herança
XmlDocumentXmlDocumentXmlDocumentXmlDocument
Derivado

Comentários

O XmlDocument classe é uma representação na memória de um documento XML.The XmlDocument class is an in-memory representation of an XML document. Ele implementa o W3C modelo de objeto de documento (DOM) XML principal do nível 1 e o nível 2 do DOM principal.It implements the W3C XML Document Object Model (DOM) Level 1 Core and the Core DOM Level 2.

DOM signifca modelo de objeto do documento.DOM stands for document object model. Para ler mais sobre isso, consulte modelo de objeto de documento (DOM) XML.To read more about it, see XML Document Object Model (DOM).

Você pode carregar o XML no DOM usando o XmlDocument de classe e, em seguida, por meio de programação ler, modificar e remover o XML no documento.You can load XML into the DOM by using the XmlDocument class, and then programmatically read, modify, and remove XML in the document.

Se você quiser forçar abrir o XmlDocument de classe e como ele é implementado, consulte a fonte de referência.If you want to pry open the XmlDocument class and see how it's implemented, see the Reference Source.

TarefasTasks

Carregar XML no modelo de objeto do documentoLoad XML into the document object model

Comece com um documento XML como esta.Start with an XML document like this one. ele é apenas alguns livros em uma coleção.it's just a few books in a collection. Mas ele contém as coisas básicas que você encontraria em qualquer documento XML; um namespace, elementos que representam os dados e atributos que descrevem os dados.But it does contain the basic things that you'd find in any XML document; 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>  

Em seguida, carregar esses dados no DOM, para que você pode trabalhar com ele na memória.Next, load this data into the DOM so that you can work with it in memory. A maneira mais popular para fazer isso é se referir a um arquivo em seu computador local ou em uma rede.The most popular way to do this is refer to a file on your local computer or on a network.

Este exemplo carrega o XML de um arquivo.This example loads XML from a file. Se o arquivo não existir, ele apenas gera algum XML e o carrega.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

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Saiba mais: Ler um documento XML no DOMLearn more: Reading an XML Document into the DOM

Validá-la em um esquemaValidate it against a schema

Comece com um esquema XML como esta.Start with an XML schema like this one. Esse esquema define os tipos de dados no XML e quais atributos são necessários.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>  

Criar um XmlReader usando seu esquema de objeto e, em seguida, carregar esse objeto no DOM.Create an XmlReader object by using your schema, and then load that object into the DOM. Crie um manipulador de eventos que é executado quando o código tenta modificar o arquivo XML de maneiras que violam as regras do esquema.Create an event handler that executes when code attempts to modify your XML file in ways that violate the rules of the schema.

Esses blocos de código mostram os métodos auxiliares que fazem tudo isso.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

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Saiba mais: Validando um documento XML no DOMLearn more: Validating an XML Document in the DOM

Você pode usar propriedades para navegar em torno de um documento XML.You can use properties to navigate around an XML document. Mas, antes de usar qualquer um deles, vamos analisar rapidamente alguns termos.But before you use any of them, let's quickly review a few terms. O documento é composto de nós.Your document is composed of nodes. Cada nó tem como único pai nó diretamente acima dele.Each node has as single parent node directly above it. O único nó que não tem um nó pai é a raiz do documento, pois é o nó de nível superior.The only node that does not have a parent node is the document root, as it is the top-level node. A maioria de nós podem ter filho nós, que são nós diretamente abaixo deles.Most nodes can have child nodes, which are nodes directly below them. Os nós que estão no mesmo nível são irmãos.Nodes that are at the same level are siblings.

Os exemplos a seguir mostram como obter o nó raiz, vá para o primeiro nó filho do nó raiz, acessar qualquer um dos seus nós filho, receber de volta para o nó pai e, em seguida, navegar entre nós irmãos.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.

Iniciar com o nó raizStart with the root node

Este exemplo obtém o nó raiz e, em seguida, usa esse nó para o conteúdo do documento para o console de saída.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

Obter nós filhoGet child nodes

Este exemplo salta para o primeiro nó filho do nó raiz e, em seguida, itera por nós filho do nó, se existir alguma.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

Voltar para o nó paiGet back to the parent node

Use a propriedade ParentNode.Use the ParentNode property.

Fazer referência ao último nó filhoRefer to the last child node

Este exemplo grava o preço de um livro para o console (que é o último nó filho de um nó de livro).This example writes the price of a book to the console (which is the last child node 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

Navegar para frente entre irmãosNavigate forward across siblings

Este exemplo move para frente de um catálogo para o catálogo.This example moves forward from book to book. Nós de catálogo são irmãos umas às outras.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

Navegar para trás entre irmãosNavigate backwards across siblings

Este exemplo move para trás de um catálogo para o catálogo.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

Localizar nósFind nodes

A maneira mais popular para localizar um ou mais nós de dados é usar uma cadeia de caracteres de consulta do XPath, mas também há métodos que não exigem um.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.

Obter um único nóGet a single node

Este exemplo localiza um catálogo usando o número 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

A cadeia de caracteres usada nesse exemplo é uma consulta Xpath.The string used in this example is an Xpath query. Você pode encontrar mais exemplos deles aqui: Exemplos de XPath.You can find more examples of them here: XPath examples.

Você também pode usar o GetElementById para recuperar os nós.You can also use the GetElementById to retrieve nodes. Para usar essa abordagem, você precisa definir IDs nas declarações de definição de tipo de documento do arquivo XML.To use this approach, you'll have to define ID's in the document type definition declarations of your XML file.

Depois de obter um nó, você pode obter o valor dos atributos ou nós filho.After you get a node, you get the value of attributes or child nodes. Este exemplo faz isso com um nó de livro.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

Obtém uma coleção de nósGet a collection of nodes

Este exemplo seleciona todos os livros em que é o nome do autor última Austene, em seguida, altera o preço desses livros.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

Você também pode obter uma coleção de nós usando o nome do nó.You can also get a collection of nodes by using the name of the node. Por exemplo, este exemplo obtém uma coleção de todos os títulos de livro.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

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Saiba mais: Selecionar nós usando a navegação XPathLearn more: Select Nodes Using XPath Navigation

Upravit uzlyEdit nodes

Este exemplo edita um nó de catálogo e seus atributos.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

Saiba mais: Modificando nós, conteúdo e os valores em um documento XMLLearn more: Modifying Nodes, Content, and Values in an XML Document

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Adicionar nósAdd nodes

Para adicionar um nó, use o CreateElement método ou o CreateNode método.To add a node, use the CreateElement method or the CreateNode method.

Para adicionar um nó de dados como um livro, use o CreateElement método.To add a data node such as a book, use the CreateElement method.

Para qualquer outro tipo de nó como um comentário, espaço em branco ou CDATA nó, use o CreateNode método.For any other type of node such as a comment, whitespace node, or CDATA node, use the CreateNode method.

Este exemplo cria um nó de catálogo, adiciona atributos para esse nó e, em seguida, adiciona esse nó no documento.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

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Saiba mais: Inserção de nós em um documento XMLLearn more: Inserting Nodes into an XML Document

Remover nósRemove nodes

Para remover um nó, use o RemoveChild método.To remove a node, use the RemoveChild method.

Este exemplo remove um livro do documento e nenhum espaço em branco que aparece antes do nó de livro.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

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Saiba mais: Removendo nós, conteúdo e os valores de um documento XMLLearn more: Removing Nodes, Content, and Values from an XML Document

Nós de posiçãoPosition nodes

Você pode escolher onde deseja que um nó apareçam em seu documento usando o InsertBefore e InsertAfter métodos.You can choose where you want a node to appear in your document by using the InsertBefore and InsertAfter methods.

Este exemplo mostra dois métodos auxiliares.This example shows two helper methods. Um deles move um nó mais alto em uma lista.One of them moves a node higher in a list. O outro é move um nó inferior.The other one moves a node lower.

Esses métodos pode ser usados em um aplicativo que permite aos usuários mover os livros de cima para baixo em uma lista de livros.These methods could be used in an application that enables users to move books up and down in a list of books. Quando um usuário escolhe um livro e pressiona cima ou para baixo do botão, seu código pode chamar métodos como esses para posicionar o nó de catálogo correspondente antes ou depois de outros nós de catálogo.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

Exemplo completo: Manipular o XML na memória usando a classe XmlDocument e outros tipos relacionadosComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Construtores

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

Inicializa uma nova instância da classe XmlDocument.Initializes a new instance of the XmlDocument class.

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

Inicializa uma nova instância da classe XmlDocument com o XmlImplementation especificado.Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

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

Inicializa uma nova instância da classe XmlDocument com o XmlNameTable especificado.Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

Propriedades

Attributes Attributes Attributes Attributes

Obtém um XmlAttributeCollection que contém os atributos desse nó.Gets an XmlAttributeCollection containing the attributes of this node.

(Inherited from XmlNode)
BaseURI BaseURI BaseURI BaseURI

Obtém o URI base do nó atual.Gets the base URI of the current node.

ChildNodes ChildNodes ChildNodes ChildNodes

Obtém todos os nós filho do nó.Gets all the child nodes of the node.

(Inherited from XmlNode)
DocumentElement DocumentElement DocumentElement DocumentElement

Obtém a raiz XmlElement para o documento.Gets the root XmlElement for the document.

DocumentType DocumentType DocumentType DocumentType

Obtém o nó que contém a declaração DOCTYPE.Gets the node containing the DOCTYPE declaration.

FirstChild FirstChild FirstChild FirstChild

Obtém o primeiro filho do nó.Gets the first child of the node.

(Inherited from XmlNode)
HasChildNodes HasChildNodes HasChildNodes HasChildNodes

Obtém um valor que indica se este nó tem nós filho.Gets a value indicating whether this node has any child nodes.

(Inherited from XmlNode)
Implementation Implementation Implementation Implementation

Obtém o objeto XmlImplementation para o documento atual.Gets the XmlImplementation object for the current document.

InnerText InnerText InnerText InnerText

Aciona um InvalidOperationException em todos os casos.Throws an InvalidOperationException in all cases.

InnerXml InnerXml InnerXml InnerXml

Obtém ou define a marcação que representa os filhos do nó atual.Gets or sets the markup representing the children of the current node.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtém um valor que indica se o nó atual é somente leitura.Gets a value indicating whether the current node is read-only.

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

Obtém o primeiro elemento filho com o LocalName e o NamespaceURI especificados.Gets the first child element with the specified LocalName and NamespaceURI.

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

Obtém o primeiro elemento filho com o Name especificado.Gets the first child element with the specified Name.

(Inherited from XmlNode)
LastChild LastChild LastChild LastChild

Obtém o último filho do nó.Gets the last child of the node.

(Inherited from XmlNode)
LocalName LocalName LocalName LocalName

Obtém o nome local do nó.Gets the local name of the node.

Name Name Name Name

Obtém o nome qualificado do nó.Gets the qualified name of the node.

NamespaceURI NamespaceURI NamespaceURI NamespaceURI

Obtém o URI do namespace deste nó.Gets the namespace URI of this node.

(Inherited from XmlNode)
NameTable NameTable NameTable NameTable

Obtém o XmlNameTable associado à essa implementação.Gets the XmlNameTable associated with this implementation.

NextSibling NextSibling NextSibling NextSibling

Obtém o nó imediatamente posterior a este nó.Gets the node immediately following this node.

(Inherited from XmlNode)
NodeType NodeType NodeType NodeType

Obtém o tipo do nó atual.Gets the type of the current node.

OuterXml OuterXml OuterXml OuterXml

Obtém a marcação que contém esse nó e todos os nós filho.Gets the markup containing this node and all its child nodes.

(Inherited from XmlNode)
OwnerDocument OwnerDocument OwnerDocument OwnerDocument

Obtém o XmlDocument ao qual pertence o nó atual.Gets the XmlDocument to which the current node belongs.

ParentNode ParentNode ParentNode ParentNode

Obtém o nó pai desse nó (para os nós que podem ter pais).Gets the parent node of this node (for nodes that can have parents).

Prefix Prefix Prefix Prefix

Obtém ou define o prefixo de namespace desse nó.Gets or sets the namespace prefix of this node.

(Inherited from XmlNode)
PreserveWhitespace PreserveWhitespace PreserveWhitespace PreserveWhitespace

Obtém ou define um valor que indica se os espaços em branco devem ser preservados no conteúdo do elemento.Gets or sets a value indicating whether to preserve white space in element content.

PreviousSibling PreviousSibling PreviousSibling PreviousSibling

Obtém o nó imediatamente anterior a este nó.Gets the node immediately preceding this node.

(Inherited from XmlNode)
PreviousText PreviousText PreviousText PreviousText

Obtém o nó de texto que precede imediatamente este nó.Gets the text node that immediately precedes this node.

(Inherited from XmlNode)
SchemaInfo SchemaInfo SchemaInfo SchemaInfo

Retorna o PSVI (Post-Schema-Validation-Infoset) do nó.Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

Schemas Schemas Schemas Schemas

Obtém ou define o objeto XmlSchemaSet associado a esse XmlDocument.Gets or sets the XmlSchemaSet object associated with this XmlDocument.

Value Value Value Value

Obtém ou define o valor do nó.Gets or sets the value of the node.

(Inherited from XmlNode)
XmlResolver XmlResolver XmlResolver XmlResolver

Define o XmlResolver que será usado para resolver recursos externos.Sets the XmlResolver to use for resolving external resources.

Métodos

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

Adiciona o nó especificado ao final da lista de nós filho desse nó.Adds the specified node to the end of the list of child nodes, of this node.

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

Cria uma duplicação deste nó.Creates a duplicate of this node.

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

Cria uma duplicação deste nó.Creates a duplicate of this node.

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

Cria um XmlAttribute com o Name especificado.Creates an XmlAttribute with the specified Name.

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

Cria um XmlAttribute com o nome e dados especificados e NamespaceURI.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)

Cria um XmlAttribute com o Prefix, LocalName e NamespaceURI especificados.Creates an XmlAttribute with the specified Prefix, LocalName, and NamespaceURI.

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

Cria um XmlCDataSection que contém os dados especificados.Creates an XmlCDataSection containing the specified data.

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

Cria um XmlComment que contém os dados especificados.Creates an XmlComment containing the specified data.

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

Cria um atributo padrão com o prefixo especificado, o nome local e o URI de namespace.Creates a default attribute with the specified prefix, local name and namespace URI.

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

Cria um XmlDocumentFragment.Creates an XmlDocumentFragment.

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

Retorna um novo objeto XmlDocumentType.Returns a new XmlDocumentType object.

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

Cria um elemento com o nome especificado.Creates an element with the specified name.

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

Cria um XmlElement com o nome qualificado e 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)

Cria um elemento com o Prefix, LocalName e NamespaceURI especificados.Creates an element with the specified Prefix, LocalName, and NamespaceURI.

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

Cria um XmlEntityReference com o nome especificado.Creates an XmlEntityReference with the specified name.

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

Cria um novo objeto XPathNavigator para navegar nesse documento.Creates a new XPathNavigator object for navigating this document.

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

Cria um objeto XPathNavigator para navegar neste documento posicionado no XmlNode especificado.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)

Cria um XmlNode com o tipo de nó especificado, Name e NamespaceURI.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)

Cria um XmlNode com o XmlNodeType, Name e NamespaceURI especificados.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)

Cria um XmlNode com o XmlNodeType, Prefix, Name e NamespaceURI especificados.Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.

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

Cria um XmlProcessingInstruction com o nome e dados especificados.Creates an XmlProcessingInstruction with the specified name and data.

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

Cria um nó XmlSignificantWhitespace.Creates an XmlSignificantWhitespace node.

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

Cria um XmlText com o texto especificado.Creates an XmlText with the specified text.

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

Cria um nó XmlWhitespace.Creates an XmlWhitespace node.

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

Cria um nó XmlDeclaration com os valores especificados.Creates an XmlDeclaration node with the specified values.

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Obtém o XmlElement com a ID especificada.Gets the XmlElement with the specified ID.

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

Retorna um XmlNodeList que contém uma lista de todos os elementos descendentes que correspondem ao Name especificado.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)

Retorna um XmlNodeList que contém uma lista de todos os elementos descendentes que correspondem ao LocalName e NamespaceURI especificados.Returns an XmlNodeList containing a list of all descendant elements that match the specified LocalName and NamespaceURI.

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

Obtém um enumerador que itera pelos nós filhos do nó atual.Gets an enumerator that iterates through the child nodes in the current node.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Procura pela declaração xmlns mais próxima para o prefixo especificado no escopo para o nó atual e retorna o URI de namespace na declaração.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)

Procura pela declaração xmlns mais próxima para o URI do namespace determinado que esteja no escopo para o nó atual e retorna o prefixo definido nessa declaração.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()

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Importa um nó de outro documento para o documento atual.Imports a node from another document to the current document.

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

Insere o nó especificado imediatamente após o nó de referência especificado.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)

Insere o nó especificado imediatamente antes do nó de referência especificado.Inserts the specified node immediately before the specified reference node.

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

Carrega o documento XML do fluxo especificado.Loads the XML document from the specified stream.

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

Carrega o documento XML da URL especificada.Loads the XML document from the specified URL.

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

Carrega o documento XML da TextReader especificada.Loads the XML document from the specified TextReader.

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

Carrega o documento XML da XmlReader especificada.Loads the XML document from the specified XmlReader.

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

Carrega o documento XML da cadeia de caracteres especificada.Loads the XML document from the specified string.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Coloca todos os nós XmlText em toda a profundidade da subárvore sob esse XmlNode em uma forma "normal" em que somente a marcação (isto é, marcas, comentários, instruções de processamento, seções CDATA e referências de entidade) separa os nós XmlText, isto é, não existem nós XmlText adjacentes.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)

Adiciona o nó especificado ao início da lista de nós filho desse nó.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)

Cria um objeto XmlNode com base nas informações no XmlReader.Creates an XmlNode object based on the information in the XmlReader. O leitor deve ser posicionado em um nó ou atributo.The reader must be positioned on a node or attribute.

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

Remove todos os nós filho e/ou atributos do nó atual.Removes all the child nodes and/or attributes of the current node.

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

Remove o nó filho especificado.Removes specified child node.

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

Substitui o nó filho oldChild pelo nó newChild.Replaces the child node oldChild with newChild node.

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

Salva o documento XML no fluxo especificado.Saves the XML document to the specified stream.

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

Salva o documento XML no arquivo especificado.Saves the XML document to the specified file. Se o arquivo especificado existir, este método o substituirá.If the specified file exists, this method overwrites it.

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

Salva o documento XML no TextWriter especificado.Saves the XML document to the specified TextWriter.

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

Salva o documento XML no XmlWriter especificado.Saves the XML document to the specified XmlWriter.

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

Seleciona uma lista de nós que correspondem à expressão 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)

Seleciona uma lista de nós que correspondem à expressão XPath.Selects a list of nodes matching the XPath expression. Todos os prefixos encontrados na expressão XPath são resolvidos usando o XmlNamespaceManager fornecido.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

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

Seleciona o primeiro XmlNode que corresponde à expressão 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)

Seleciona o primeiro XmlNode que corresponde à expressão XPath.Selects the first XmlNode that matches the XPath expression. Todos os prefixos encontrados na expressão XPath são resolvidos usando o XmlNamespaceManager fornecido.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)

Testa se a implementação do DOM implementa um recurso específico.Tests if the DOM implementation implements a specific feature.

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

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

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

Valida o XmlDocument em relação aos esquemas XSD (Linguagem de Definição de Esquema XML) contidos na propriedade 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)

Valida o objeto XmlNode especificado para os esquemas de XSD (Linguagem de Definição de Esquema XML) contidos na propriedade 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)

Salva todos os filhos do nó XmlDocument para o XmlWriter especificado.Saves all the children of the XmlDocument node to the specified XmlWriter.

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

Salva o nó XmlDocument no XmlWriter especificado.Saves the XmlDocument node to the specified XmlWriter.

Eventos

NodeChanged NodeChanged NodeChanged NodeChanged

Ocorre quando o Value de um nó que pertence a este documento foi alterado.Occurs when the Value of a node belonging to this document has been changed.

NodeChanging NodeChanging NodeChanging NodeChanging

Ocorre quando o Value de um nó que pertence a este documento está prestes a ser alterado.Occurs when the Value of a node belonging to this document is about to be changed.

NodeInserted NodeInserted NodeInserted NodeInserted

Ocorre quando um nó que pertence a este documento foi inserido em outro nó.Occurs when a node belonging to this document has been inserted into another node.

NodeInserting NodeInserting NodeInserting NodeInserting

Ocorre quando um nó que pertence a este documento está prestes a ser inserido em outro nó.Occurs when a node belonging to this document is about to be inserted into another node.

NodeRemoved NodeRemoved NodeRemoved NodeRemoved

Ocorre quando um nó que pertence a este documento foi removido do pai dele.Occurs when a node belonging to this document has been removed from its parent.

NodeRemoving NodeRemoving NodeRemoving NodeRemoving

Ocorre quando um nó que pertence a este documento está prestes a ser removido do documento.Occurs when a node belonging to this document is about to be removed from the document.

Implantações explícitas de interface

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

Para obter uma descrição desse membro, consulte Clone().For a description of this member, see Clone().

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

Para obter uma descrição desse membro, consulte GetEnumerator().For a description of this member, see GetEnumerator().

(Inherited from XmlNode)

Extension Methods

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

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

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

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

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

Habilita a paralelização de uma consulta.Enables parallelization of a query.

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

Converte um IEnumerable em um 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)

Aplica-se a

Veja também