XmlDocument Класс

Определение

Представляет XML-документ.Represents an XML document. Этот класс можно использовать для загрузки, проверки, изменения, добавления и размещения XML-кода в документе.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
Наследование
XmlDocument
Производный

Комментарии

XmlDocument Класс является представлением XML-документа в памяти.The XmlDocument class is an in-memory representation of an XML document. В нем реализованы W3C по стандарту XML модель DOM (DOM) уровня 1 и основной DOM уровня 2.It implements the W3C XML Document Object Model (DOM) Level 1 Core and the Core DOM Level 2.

DOM означает объектную модель документов.DOM stands for document object model. Дополнительные сведения см. в статье XML модель DOM (DOM).To read more about it, see XML Document Object Model (DOM).

Вы можете загрузить XML в модель DOM с помощью XmlDocument класса, а затем программно считывать, изменять и удалять XML-документы в документе.You can load XML into the DOM by using the XmlDocument class, and then programmatically read, modify, and remove XML in the document.

Если вы хотите при открыть XmlDocument класс и увидеть, как он реализован, см. Исходный Справочник.If you want to pry open the XmlDocument class and see how it's implemented, see the Reference Source.

ЗадачиTasks

Загрузка XML в объектную модель документаLoad XML into the document object model

Начните с XML-документа, такого как такой, который содержит несколько книг в коллекции.Start with an XML document like this one that has a few books in a collection. Он содержит основные вещи, которые можно найти в любом XML-документе, включая пространство имен, элементы, представляющие данные, и атрибуты, описывающие данные.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>  

Затем загрузите эти данные в модель DOM, чтобы вы могли работать с ними в памяти.Next, load this data into the DOM so that you can work with it in memory. Самый популярный способ сделать это — это ссылка на файл на локальном компьютере или в сети.The most popular way to do this is refer to a file on your local computer or on a network.

В этом примере загружается XML из файла.This example loads XML from a file. Если файл не существует, он просто создает некоторый XML-код и загружает его.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

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Дополнительные сведения: Считывание XML-документа в модели DOMLearn more: Reading an XML Document into the DOM

Проверка схемыValidate it against a schema

Начните с схемы XML, подобной этой.Start with an XML schema like this one. Эта схема определяет типы данных в XML и необходимые атрибуты.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>  

XmlReader Создайте объект с помощью схемы, а затем загрузите этот объект в модель DOM.Create an XmlReader object by using your schema, and then load that object into the DOM. Создание обработчика событий, который выполняется при попытке кода изменить XML-файл способами, нарушающими правила схемы.Create an event handler that executes when code attempts to modify your XML file in ways that violate the rules of the schema.

Эти блоки кода показывают вспомогательные методы, которые выполняют все эти действия.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

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Дополнительные сведения: Проверка XML-документа в модели DOMLearn more: Validating an XML Document in the DOM

Для перемещения по XML-документу можно использовать свойства.You can use properties to navigate around an XML document. Но прежде чем использовать их, давайте быстро рассмотрим несколько терминов.But before you use any of them, let's quickly review a few terms. Документ состоит из узлов.Your document is composed of nodes. Каждый узел имеет в качестве одного родительского узла, расположенного непосредственно над ним.Each node has as single parent node directly above it. Единственный узел, у которого нет родительского узла, — это корневой узел документа, так как он является узлом верхнего уровня.The only node that does not have a parent node is the document root, as it is the top-level node. У большинства узлов могут ** быть дочерние узлы, которые являются узлами непосредственно под ними.Most nodes can have child nodes, which are nodes directly below them. Узлы, находящиеся на одном уровне, являются одноуровневыми элементами.Nodes that are at the same level are siblings.

В следующих примерах показано, как получить корневой узел, перейти к первому дочернему узлу корневого узла, получить доступ к любому из его дочерних узлов, вернуться к родительскому узлу, а затем перемещаться по родственным узлам.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.

Начало работы с корневым узломStart with the root node

Этот пример получает корневой узел, а затем использует этот узел для вывода содержимого документа на консоль.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.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
End Class

Получение дочерних узловGet child nodes

Этот пример перейдет к первому дочернему узлу корневого узла, а затем просматривает дочерние узлы этого узла, если таковые имеются.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.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
End Class

Возврат к родительскому узлуGet back to the parent node

Используйте свойство ParentNode.Use the ParentNode property.

Ссылка на последний дочерний узелRefer to the last child node

Этот пример записывает цену книги на консоль.This example writes the price of a book to the console. Узел Price является последним дочерним элементом узла книги.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.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
End Class

Переход вперед между одноуровневыми элементамиNavigate forward across siblings

В этом примере перемещается вперед от Book к книге.This example moves forward from book to book. Узлы книг находятся на одном уровне с другими.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.Xml
 
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

Переход назад между одноуровневыми элементамиNavigate backwards across siblings

Этот пример перемещается назад из книги в книгу.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.Xml

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

Поиск узловFind nodes

Наиболее популярным способом поиска одного или нескольких узлов данных является использование строки запроса XPath, но существуют также методы, не требующие такой необходимости.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.

Получение одного узлаGet a single node

В этом примере найдется книга с номером 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

Строка, используемая в этом примере, является запросом XPath.The string used in this example is an Xpath query. Дополнительные примеры можно найти здесь: Примеры XPath.You can find more examples of them here: XPath examples.

GetElementById Для получения узлов также можно использовать.You can also use the GetElementById to retrieve nodes. Чтобы использовать этот подход, необходимо определить идентификатор в объявлениях определения типа документа XML-файла.To use this approach, you'll have to define ID's in the document type definition declarations of your XML file.

После получения узла можно получить значения атрибутов или дочерних узлов.After you get a node, you get the value of attributes or child nodes. В этом примере это делается с узлом книги.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

Получение коллекции узловGet a collection of nodes

В этом примере выбираются все книги, в которых фамилия автора — Аустен, а затем изменяются цены на эти книги.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.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

Также можно получить коллекцию узлов, используя имя узла.You can also get a collection of nodes by using the name of the node. Например, в этом примере возвращается коллекция всех названий книг.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.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
End Class

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Дополнительные сведения: Выбор узлов с помощью XPath-навигацииLearn more: Select Nodes Using XPath Navigation

Изменение узловEdit nodes

В этом примере изменяется узел книги и его атрибуты.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

Дополнительные сведения: Изменение узлов, содержимого и значений в XML-документеLearn more: Modifying Nodes, Content, and Values in an XML Document

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Добавление узловAdd nodes

Чтобы добавить узел, используйте CreateElement метод CreateNode или.To add a node, use the CreateElement method or the CreateNode method.

Чтобы добавить узел данных, например книгу, используйте CreateElement метод.To add a data node such as a book, use the CreateElement method.

Для любого другого типа узла, такого как комментарий, узел пробела или узел CDATA, используйте CreateNode метод.For any other type of node such as a comment, whitespace node, or CDATA node, use the CreateNode method.

В этом примере создается узел книги, добавляются атрибуты в этот узел, а затем этот узел добавляется в документ.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

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Дополнительные сведения: Вставка узлов в XML-документLearn more: Inserting Nodes into an XML Document

Удаление узловRemove nodes

Чтобы удалить узел, используйте RemoveChild метод.To remove a node, use the RemoveChild method.

В этом примере удаляется книга из документа и все пробелы, которые появляются непосредственно перед узлом книги.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

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Дополнительные сведения: Удаление узлов, содержимого и значений из XML-документаLearn more: Removing Nodes, Content, and Values from an XML Document

Размещение узловPosition nodes

Вы можете выбрать, где узел должен отображаться в документе, с помощью InsertBefore методов и. InsertAfterYou can choose where you want a node to appear in your document by using the InsertBefore and InsertAfter methods.

В этом примере показаны два вспомогательных метода.This example shows two helper methods. Один из них перемещает узел выше в списке.One of them moves a node higher in a list. Другой узел перемещается в нижнюю часть.The other one moves a node lower.

Эти методы можно использовать в приложении, которое позволяет пользователям перемещать книги вверх и вниз в списке книг.These methods could be used in an application that enables users to move books up and down in a list of books. Когда пользователь выбирает книгу и нажимает кнопку со стрелкой вверх или вниз, код может вызывать такие методы, как размещение соответствующего узла книги до или после других узлов книги.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

Полный пример: Обработка XML в памяти с помощью класса XmlDocument и других связанных типовComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Конструкторы

XmlDocument()

Инициализирует новый экземпляр класса XmlDocument.Initializes a new instance of the XmlDocument class.

XmlDocument(XmlImplementation)

Инициализирует новый экземпляр класса XmlDocument указанным значением XmlImplementation.Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

XmlDocument(XmlNameTable)

Инициализирует новый экземпляр класса XmlDocument указанным значением XmlNameTable.Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

Свойства

Attributes

Возвращает класс XmlAttributeCollection, содержащий атрибуты данного узла.Gets an XmlAttributeCollection containing the attributes of this node.

(Унаследовано от XmlNode)
BaseURI

Возвращает базовый URI текущего узла.Gets the base URI of the current node.

ChildNodes

Возвращает все дочерние узлы данного узла.Gets all the child nodes of the node.

(Унаследовано от XmlNode)
DocumentElement

Возвращает корень XmlElement для документа.Gets the root XmlElement for the document.

DocumentType

Возвращает узел, содержащий объявление DOCTYPE.Gets the node containing the DOCTYPE declaration.

FirstChild

Возвращает первый дочерний узел данного узла.Gets the first child of the node.

(Унаследовано от XmlNode)
HasChildNodes

Возвращает значение, свидетельствующее о наличии дочерних узлов у текущего узла.Gets a value indicating whether this node has any child nodes.

(Унаследовано от XmlNode)
Implementation

Возвращает объект XmlImplementation для текущего документа.Gets the XmlImplementation object for the current document.

InnerText

Во всех случаях вызывает исключение InvalidOperationException.Throws an InvalidOperationException in all cases.

InnerXml

Возвращает или задает разметку, отражающую дочерние узлы текущего узла.Gets or sets the markup representing the children of the current node.

IsReadOnly

Возвращает значение, определяющее, доступен ли текущий узел только для чтения.Gets a value indicating whether the current node is read-only.

Item[String, String]

Возвращает первый дочерний элемент с помощью указанного свойства LocalName и NamespaceURI.Gets the first child element with the specified LocalName and NamespaceURI.

(Унаследовано от XmlNode)
Item[String]

Возвращает первый дочерний элемент с помощью указанного свойства Name.Gets the first child element with the specified Name.

(Унаследовано от XmlNode)
LastChild

Возвращает последний дочерний узел данного узла.Gets the last child of the node.

(Унаследовано от XmlNode)
LocalName

Возвращает локальное имя узла.Gets the local name of the node.

Name

Возвращает полное имя узла.Gets the qualified name of the node.

NamespaceURI

Возвращает URI пространства имен данного узла.Gets the namespace URI of this node.

(Унаследовано от XmlNode)
NameTable

Возвращает класс XmlNameTable, связанный с данной реализацией.Gets the XmlNameTable associated with this implementation.

NextSibling

Возвращает узел, следующий сразу за данным узлом.Gets the node immediately following this node.

(Унаследовано от XmlNode)
NodeType

Возвращает тип текущего узла.Gets the type of the current node.

OuterXml

Возвращает разметку, содержащую данный узел и все его дочерние узлы.Gets the markup containing this node and all its child nodes.

(Унаследовано от XmlNode)
OwnerDocument

Возвращает XmlDocument, к которому принадлежит текущий узел.Gets the XmlDocument to which the current node belongs.

ParentNode

Возвращает родительский узел для данного узла (только узлов, у которых они могут быть).Gets the parent node of this node (for nodes that can have parents).

Prefix

Возвращает или задает префикс пространства имен данного узла.Gets or sets the namespace prefix of this node.

(Унаследовано от XmlNode)
PreserveWhitespace

Возвращает или задает значение, определяющее, будут ли сохранены знаки-разделители в содержимом элемента.Gets or sets a value indicating whether to preserve white space in element content.

PreviousSibling

Возвращает узел, непосредственно предшествующий данному узлу.Gets the node immediately preceding this node.

(Унаследовано от XmlNode)
PreviousText

Возвращает текстовый узел, непосредственно предшествующий данному.Gets the text node that immediately precedes this node.

(Унаследовано от XmlNode)
SchemaInfo

Возвращает информационный набор после проверки схемы (PSVI) для этого узла.Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

Schemas

Возвращает или задает объект XmlSchemaSet, связанный с данным объектом XmlDocument.Gets or sets the XmlSchemaSet object associated with this XmlDocument.

Value

Возвращает или задает значение узла.Gets or sets the value of the node.

(Унаследовано от XmlNode)
XmlResolver

Задает XmlResolver, используемый для разрешения внешних ресурсов.Sets the XmlResolver to use for resolving external resources.

Методы

AppendChild(XmlNode)

Добавляет указанный узел в конец списка дочерних узлов данного узла.Adds the specified node to the end of the list of child nodes, of this node.

(Унаследовано от XmlNode)
Clone()

Создает дубликат этого узла.Creates a duplicate of this node.

(Унаследовано от XmlNode)
CloneNode(Boolean)

Создает дубликат этого узла.Creates a duplicate of this node.

CreateAttribute(String)

Создает объект XmlAttribute с указанным Name.Creates an XmlAttribute with the specified Name.

CreateAttribute(String, String)

Создает XmlAttribute с помощью указанного полного имени и NamespaceURI.Creates an XmlAttribute with the specified qualified name and NamespaceURI.

CreateAttribute(String, String, String)

Создает объект XmlAttribute с помощью указанных значений Prefix, LocalName и NamespaceURI.Creates an XmlAttribute with the specified Prefix, LocalName, and NamespaceURI.

CreateCDataSection(String)

Создает объект XmlCDataSection, содержащий указанные данные.Creates an XmlCDataSection containing the specified data.

CreateComment(String)

Создает объект XmlComment, содержащий указанные данные.Creates an XmlComment containing the specified data.

CreateDefaultAttribute(String, String, String)

Создает атрибут по умолчанию с помощью указанного префикса, локального имени и URI пространства имен.Creates a default attribute with the specified prefix, local name and namespace URI.

CreateDocumentFragment()

Создает XmlDocumentFragment.Creates an XmlDocumentFragment.

CreateDocumentType(String, String, String, String)

Возвращает новый объект XmlDocumentType.Returns a new XmlDocumentType object.

CreateElement(String)

Создает элемент с указанным именем.Creates an element with the specified name.

CreateElement(String, String)

Создает XmlElement с помощью полного имени и NamespaceURI.Creates an XmlElement with the qualified name and NamespaceURI.

CreateElement(String, String, String)

Создает элемент с помощью указанных Prefix, LocalName и NamespaceURI.Creates an element with the specified Prefix, LocalName, and NamespaceURI.

CreateEntityReference(String)

Создает объект XmlEntityReference с указанным именем.Creates an XmlEntityReference with the specified name.

CreateNavigator()

Создает новый объект XPathNavigator для навигации в данном документе.Creates a new XPathNavigator object for navigating this document.

CreateNavigator(XmlNode)

Создает объект XPathNavigator для навигации в данном документе, расположенном в указанном узле XmlNode.Creates an XPathNavigator object for navigating this document positioned on the XmlNode specified.

CreateNode(String, String, String)

Создает XmlNode с помощью указанного типа узла, а также свойств Name и NamespaceURI.Creates an XmlNode with the specified node type, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String)

Создает объект XmlNode с помощью указанных значений XmlNodeType, Name и NamespaceURI.Creates an XmlNode with the specified XmlNodeType, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String, String)

Создает объект XmlNode с помощью указанных типов XmlNodeType, Prefix, Name и NamespaceURI.Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.

CreateProcessingInstruction(String, String)

Создает XmlProcessingInstruction с помощью указанного имени и данных.Creates an XmlProcessingInstruction with the specified name and data.

CreateSignificantWhitespace(String)

Создает узел XmlSignificantWhitespace.Creates an XmlSignificantWhitespace node.

CreateTextNode(String)

Создает объект XmlText с указанным текстом.Creates an XmlText with the specified text.

CreateWhitespace(String)

Создает узел XmlWhitespace.Creates an XmlWhitespace node.

CreateXmlDeclaration(String, String, String)

Создает узел XmlDeclaration с указанными значениями.Creates an XmlDeclaration node with the specified values.

Equals(Object)

Определяет, равен ли указанный объект текущему объекту.Determines whether the specified object is equal to the current object.

(Унаследовано от Object)
GetElementById(String)

Возвращает элемент XmlElement с указанным идентификатором.Gets the XmlElement with the specified ID.

GetElementsByTagName(String)

Возвращает значение XmlNodeList, содержащее список всех элементов-потомков, соответствующих указанному имени Name.Returns an XmlNodeList containing a list of all descendant elements that match the specified Name.

GetElementsByTagName(String, String)

Возвращает XmlNodeList, содержащий список всех элементов-потомков, соответствующих указанным значениям LocalName и NamespaceURI.Returns an XmlNodeList containing a list of all descendant elements that match the specified LocalName and NamespaceURI.

GetEnumerator()

Возвращает перечислитель, выполняющий итерацию дочерних узлов текущего узла.Gets an enumerator that iterates through the child nodes in the current node.

(Унаследовано от XmlNode)
GetHashCode()

Служит в качестве хэш-функции по умолчанию.Serves as the default hash function.

(Унаследовано от Object)
GetNamespaceOfPrefix(String)

Ищет наиболее точное объявление xmlns для заданного префикса, принадлежащее области действия текущего узла, и возвращает универсальный код ресурса (URI) пространства имен в объявлении.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.

(Унаследовано от XmlNode)
GetPrefixOfNamespace(String)

Ищет наиболее точное объявление xmlns для универсального кода ресурса (URI) пространства имен, принадлежащее области действия текущего узла, и возвращает префикс, определенный в этом объявлении.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.

(Унаследовано от XmlNode)
GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Унаследовано от Object)
ImportNode(XmlNode, Boolean)

Импортирует в текущий документ узел из другого документа.Imports a node from another document to the current document.

InsertAfter(XmlNode, XmlNode)

Вставляет заданный узел сразу после указанного узла ссылки.Inserts the specified node immediately after the specified reference node.

(Унаследовано от XmlNode)
InsertBefore(XmlNode, XmlNode)

Вставляет заданный узел сразу перед указанным узлом ссылки.Inserts the specified node immediately before the specified reference node.

(Унаследовано от XmlNode)
Load(Stream)

Загружает XML-документ из указанного потока.Loads the XML document from the specified stream.

Load(String)

Загружает XML-документ из указанного URL-адреса.Loads the XML document from the specified URL.

Load(TextReader)

Загружает XML-документ из указанного TextReader.Loads the XML document from the specified TextReader.

Load(XmlReader)

Загружает XML-документ из указанного XmlReader.Loads the XML document from the specified XmlReader.

LoadXml(String)

Загружает XML-документ из указанной строки.Loads the XML document from the specified string.

MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Унаследовано от Object)
Normalize()

Помещает все узлы XmlText на максимальную глубину поддерева, расположенного под данным узлом XmlNode, в обычную форму, где узлы XmlText разделяются только разметкой (теги, примечания, комментарии, инструкции по обработке, разделы CDATA и ссылки на сущности). Смежные узлы XmlText отсутствуют.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.

(Унаследовано от XmlNode)
PrependChild(XmlNode)

Добавляет указанный узел в начало списка дочерних узлов данного узла.Adds the specified node to the beginning of the list of child nodes for this node.

(Унаследовано от XmlNode)
ReadNode(XmlReader)

Создает объект XmlNode на основе данных из XmlReader.Creates an XmlNode object based on the information in the XmlReader. Средство чтения должно быть позиционировано на узел или атрибут.The reader must be positioned on a node or attribute.

RemoveAll()

Удаляет все дочерние узлы и (или) атрибуты текущего узла.Removes all the child nodes and/or attributes of the current node.

(Унаследовано от XmlNode)
RemoveChild(XmlNode)

Удаляет указанный дочерний узел.Removes specified child node.

(Унаследовано от XmlNode)
ReplaceChild(XmlNode, XmlNode)

Заменяет дочерний узел oldChild на узел newChild.Replaces the child node oldChild with newChild node.

(Унаследовано от XmlNode)
Save(Stream)

Сохраняет XML-документ в указанном потоке.Saves the XML document to the specified stream.

Save(String)

Сохраняет XML-документ в указанном файле.Saves the XML document to the specified file. Если указанный файл существует, метод перезаписывает его.If the specified file exists, this method overwrites it.

Save(TextWriter)

Сохраняет XML-документ в указанном TextWriter.Saves the XML document to the specified TextWriter.

Save(XmlWriter)

Сохраняет XML-документ в указанном XmlWriter.Saves the XML document to the specified XmlWriter.

SelectNodes(String)

Выбирает список узлов в соответствии с выражением XPath.Selects a list of nodes matching the XPath expression.

(Унаследовано от XmlNode)
SelectNodes(String, XmlNamespaceManager)

Выбирает список узлов в соответствии с выражением XPath.Selects a list of nodes matching the XPath expression. Префиксы, найденные в выражении XPath, разрешаются с помощью предоставленного XmlNamespaceManager.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Унаследовано от XmlNode)
SelectSingleNode(String)

Выделяет первый объект XmlNode, соответствующий выражению XPath.Selects the first XmlNode that matches the XPath expression.

(Унаследовано от XmlNode)
SelectSingleNode(String, XmlNamespaceManager)

Выделяет первый объект XmlNode, соответствующий выражению XPath.Selects the first XmlNode that matches the XPath expression. Префиксы, найденные в выражении XPath, разрешаются с помощью предоставленного XmlNamespaceManager.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Унаследовано от XmlNode)
Supports(String, String)

Проверяет, присутствует ли указанное средство в реализации DOM.Tests if the DOM implementation implements a specific feature.

(Унаследовано от XmlNode)
ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Унаследовано от Object)
Validate(ValidationEventHandler)

Проверяет XmlDocument по схемам языка XSD, содержащимся в свойстве Schemas.Validates the XmlDocument against the XML Schema Definition Language (XSD) schemas contained in the Schemas property.

Validate(ValidationEventHandler, XmlNode)

Проверяет указанный объект XmlNode по схемам языка XSD, содержащимся в свойстве Schemas.Validates the XmlNode object specified against the XML Schema Definition Language (XSD) schemas in the Schemas property.

WriteContentTo(XmlWriter)

Сохраняет все дочерние узлы узла XmlDocument в заданном XmlWriter.Saves all the children of the XmlDocument node to the specified XmlWriter.

WriteTo(XmlWriter)

Сохраняет узел XmlDocument в заданном XmlWriter.Saves the XmlDocument node to the specified XmlWriter.

События

NodeChanged

Возникает при изменении свойства Value узла, принадлежащего данному документу.Occurs when the Value of a node belonging to this document has been changed.

NodeChanging

Возникает при намерении изменить свойство Value узла, принадлежащего данному документу.Occurs when the Value of a node belonging to this document is about to be changed.

NodeInserted

Возникает после вставки узла, принадлежащего данному документу, в другой узел.Occurs when a node belonging to this document has been inserted into another node.

NodeInserting

Возникает перед вставкой узла, принадлежащего данному документу, в другой узел.Occurs when a node belonging to this document is about to be inserted into another node.

NodeRemoved

Возникает после удаления узла, принадлежащего данному документу, из родительского узла.Occurs when a node belonging to this document has been removed from its parent.

NodeRemoving

Возникает перед удалением узла из документа.Occurs when a node belonging to this document is about to be removed from the document.

Явные реализации интерфейса

ICloneable.Clone()

Описание этого члена см. в разделе Clone().For a description of this member, see Clone().

(Унаследовано от XmlNode)
IEnumerable.GetEnumerator()

Описание этого члена см. в разделе GetEnumerator().For a description of this member, see GetEnumerator().

(Унаследовано от XmlNode)

Методы расширения

Cast<TResult>(IEnumerable)

Приводит элементы объекта IEnumerable к заданному типу.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Выполняет фильтрацию элементов объекта IEnumerable по заданному типу.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Позволяет осуществлять параллельный запрос.Enables parallelization of a query.

AsQueryable(IEnumerable)

Преобразовывает коллекцию IEnumerable в объект IQueryable.Converts an IEnumerable to an IQueryable.

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

Применяется к

Дополнительно