XmlDocument Klasa

Definicja

Reprezentuje dokument XML.Represents an XML document. Za pomocą tej klasy można ładować, weryfikować, edytować, dodawać i pozycjonować XML w dokumencie.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
Dziedziczenie
XmlDocument
Pochodne

Uwagi

Klasa XmlDocument to reprezentacja dokumentu XML w pamięci.The XmlDocument class is an in-memory representation of an XML document. Implementuje on Document Object Model W3C XML (dom) Level 1 rdzeń i podstawowy poziom dom 2.It implements the W3C XML Document Object Model (DOM) Level 1 Core and the Core DOM Level 2.

Dom dla modelu obiektowego dokumentu.DOM stands for document object model. Aby dowiedzieć się więcej na ten temat, zobacz XML Document Object Model (dom).To read more about it, see XML Document Object Model (DOM).

Możesz załadować XML do modelu DOM przy użyciu klasy XmlDocument, a następnie programowo odczytywać, modyfikować i usuwać XML w dokumencie.You can load XML into the DOM by using the XmlDocument class, and then programmatically read, modify, and remove XML in the document.

Jeśli chcesz pry otworzyć klasę XmlDocument i zobaczyć, jak została ona zaimplementowana, zobacz Źródło odwołania.If you want to pry open the XmlDocument class and see how it's implemented, see the Reference Source.

ZadaniaTasks

Załaduj kod XML do modelu obiektów dokumentuLoad XML into the document object model

Zacznij od dokumentu XML, takiego jak ten, który zawiera kilka książek w kolekcji.Start with an XML document like this one that has a few books in a collection. Zawiera podstawowe elementy, które znajdują się w dowolnym dokumencie XML, włącznie z przestrzenią nazw, elementami reprezentującymi dane i atrybutami opisującymi dane.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>  

Następnie załaduj te dane do modelu DOM, aby można było korzystać z niego w pamięci.Next, load this data into the DOM so that you can work with it in memory. Najbardziej popularnym sposobem wykonania tej czynności jest zalogowanie się do pliku na komputerze lokalnym lub w sieci.The most popular way to do this is refer to a file on your local computer or on a network.

Ten przykład ładuje kod XML z pliku.This example loads XML from a file. Jeśli plik nie istnieje, po prostu generuje pewne XML i ładuje.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

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Dowiedz się więcej: odczytywanie dokumentu XML w modelu domLearn more: Reading an XML Document into the DOM

Sprawdzanie poprawności względem schematuValidate it against a schema

Zacznij od schematu XML, takiego jak ten.Start with an XML schema like this one. Ten schemat definiuje typy danych w kodzie XML i wymagane atrybuty.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>  

Utwórz obiekt XmlReader przy użyciu schematu, a następnie załaduj ten obiekt do modelu DOM.Create an XmlReader object by using your schema, and then load that object into the DOM. Utwórz procedurę obsługi zdarzeń, która jest wykonywana, gdy kod próbuje zmodyfikować plik XML w sposób naruszający reguły schematu.Create an event handler that executes when code attempts to modify your XML file in ways that violate the rules of the schema.

Te bloki kodu pokazują metody pomocnika, które wykonują wszystkie te czynności.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

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Dowiedz się więcej: Sprawdzanie poprawności dokumentu XML w modelu domLearn more: Validating an XML Document in the DOM

Możesz użyć właściwości, aby nawigować po dokumencie XML.You can use properties to navigate around an XML document. Ale przed użyciem któregoś z nich można szybko przejrzeć kilka warunków.But before you use any of them, let's quickly review a few terms. Dokument składa się z węzłów.Your document is composed of nodes. Każdy węzeł ma jako pojedynczy węzeł nadrzędny bezpośrednio nad nim.Each node has as single parent node directly above it. Jedynym węzłem, który nie ma węzła nadrzędnego, jest katalog główny dokumentu, ponieważ jest to węzeł najwyższego poziomu.The only node that does not have a parent node is the document root, as it is the top-level node. Większość węzłów może mieć węzły podrzędne , które są węzłami bezpośrednio poniżej.Most nodes can have child nodes, which are nodes directly below them. Węzły, które znajdują się na tym samym poziomie, są równorzędne.Nodes that are at the same level are siblings.

W poniższych przykładach pokazano, jak uzyskać węzeł główny, przejść do pierwszego węzła podrzędnego węzła głównego, uzyskać dostęp do dowolnego z jego węzłów podrzędnych, wrócić do węzła nadrzędnego, a następnie przejść między węzłami elementów równorzędnych.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.

Rozpoczynanie pracy z węzłem głównymStart with the root node

Ten przykład pobiera węzeł główny, a następnie używa tego węzła do wyprowadzania zawartości dokumentu do konsoli programu.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

Pobierz węzły podrzędneGet child nodes

Ten przykład przechodzi do pierwszego węzła podrzędnego węzła głównego, a następnie wykonuje iterację w węzłach podrzędnych tego węzła, jeśli istnieje.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

Wróć do węzła nadrzędnegoGet back to the parent node

Użyj właściwości ParentNode.Use the ParentNode property.

Zapoznaj się z ostatnim węzłem podrzędnymRefer to the last child node

Ten przykład umożliwia zapisanie ceny książki w konsoli programu.This example writes the price of a book to the console. Węzeł cena jest ostatnim elementem podrzędnym węzła księgi.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

Przejdź do przodu między elementami równorzędnymiNavigate forward across siblings

Ten przykład przenosi do przodu z książki do książki.This example moves forward from book to book. Węzły książek są równorzędne ze sobą.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

Przejdź wstecz do tyłu między elementami równorzędnymiNavigate backwards across siblings

Ten przykład przenosi do tyłu z książki do książki.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

Znajdź węzłyFind nodes

Najpopularniejszym sposobem znalezienia jednego lub kilku węzłów danych jest użycie ciągu zapytania XPath, ale istnieją również metody, które nie wymagają takiego wystąpienia.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.

Pobierz pojedynczy węzełGet a single node

Ten przykład lokalizuje książkę przy użyciu numeru 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

Ciąg używany w tym przykładzie jest kwerendą XPath.The string used in this example is an Xpath query. Więcej przykładów można znaleźć tutaj: przykłady XPath.You can find more examples of them here: XPath examples.

Możesz również użyć GetElementById, aby pobrać węzły.You can also use the GetElementById to retrieve nodes. Aby skorzystać z tej metody, należy zdefiniować identyfikator w deklaracjach definicji typu dokumentu pliku XML.To use this approach, you'll have to define ID's in the document type definition declarations of your XML file.

Po otrzymaniu węzła uzyskasz wartość atrybutów lub węzłów podrzędnych.After you get a node, you get the value of attributes or child nodes. W tym przykładzie jest to z węzłem książki.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

Pobieranie kolekcji węzłówGet a collection of nodes

Ten przykład wybiera wszystkie książki, w których nazwisko autora to Austen, a następnie zmienia cenę tych ksiąg.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

Możesz również uzyskać kolekcję węzłów przy użyciu nazwy węzła.You can also get a collection of nodes by using the name of the node. Na przykład ten przykład pobiera kolekcję wszystkich tytułów książek.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

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Dowiedz się więcej: Wybierz węzły przy użyciu nawigacji XPathLearn more: Select Nodes Using XPath Navigation

Edytuj węzłyEdit nodes

Ten przykład edytuje węzeł książki i jego atrybuty.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

Dowiedz się więcej: Modyfikowanie węzłów, zawartości i wartości w dokumencie XMLLearn more: Modifying Nodes, Content, and Values in an XML Document

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Dodaj węzłyAdd nodes

Aby dodać węzeł, użyj metody CreateElement lub metody CreateNode.To add a node, use the CreateElement method or the CreateNode method.

Aby dodać węzeł danych, taki jak książka, użyj metody CreateElement.To add a data node such as a book, use the CreateElement method.

W przypadku każdego innego typu węzła, takiego jak komentarz, węzeł odstępu lub węzeł CDATA, użyj metody CreateNode.For any other type of node such as a comment, whitespace node, or CDATA node, use the CreateNode method.

Ten przykład tworzy węzeł książka, dodaje do niego atrybuty, a następnie dodaje ten węzeł do dokumentu.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

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Dowiedz się więcej: Wstawianie węzłów do dokumentu XMLLearn more: Inserting Nodes into an XML Document

Usuń węzłyRemove nodes

Aby usunąć węzeł, użyj metody RemoveChild.To remove a node, use the RemoveChild method.

Ten przykład usuwa książkę z dokumentu i wszystkie odstępy, które pojawiają się tuż przed węzłem książki.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

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Dowiedz się więcej: usuwanie węzłów, zawartości i wartości z dokumentu XMLLearn more: Removing Nodes, Content, and Values from an XML Document

Węzły położeniaPosition nodes

Możesz wybrać, gdzie węzeł ma być wyświetlany w dokumencie przy użyciu metod InsertBefore i InsertAfter.You can choose where you want a node to appear in your document by using the InsertBefore and InsertAfter methods.

Ten przykład przedstawia dwie metody pomocnika.This example shows two helper methods. Jeden z nich przenosi węzeł wyżej na liście.One of them moves a node higher in a list. Druga z nich przenosi węzeł w dół.The other one moves a node lower.

Metody te mogą być używane w aplikacji, która umożliwia użytkownikom przenoszenie ksiąg w górę i w dół na liście książek.These methods could be used in an application that enables users to move books up and down in a list of books. Gdy użytkownik wybierze książkę i naciśnie przycisk w górę lub w dół, kod może wywoływać metody, takie jak te, aby umieścić odpowiedni węzeł książki przed lub po innych węzłach.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

Kończenie przykładu: manipulowanie XML w pamięci za pomocą klasy XmlDocument i innych powiązanych typówComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Konstruktory

XmlDocument()

Inicjuje nowe wystąpienie klasy XmlDocument klasy.Initializes a new instance of the XmlDocument class.

XmlDocument(XmlImplementation)

Inicjuje nowe wystąpienie klasy XmlDocument z określonym XmlImplementation.Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

XmlDocument(XmlNameTable)

Inicjuje nowe wystąpienie klasy XmlDocument z określonym XmlNameTable.Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

Właściwości

Attributes

Pobiera XmlAttributeCollection zawierający atrybuty tego węzła.Gets an XmlAttributeCollection containing the attributes of this node.

(Odziedziczone po XmlNode)
BaseURI

Pobiera podstawowy identyfikator URI bieżącego węzła.Gets the base URI of the current node.

ChildNodes

Pobiera wszystkie węzły podrzędne węzła.Gets all the child nodes of the node.

(Odziedziczone po XmlNode)
DocumentElement

Pobiera XmlElement głównego dokumentu.Gets the root XmlElement for the document.

DocumentType

Pobiera węzeł zawierający deklarację DOCTYPE.Gets the node containing the DOCTYPE declaration.

FirstChild

Pobiera pierwszy element podrzędny węzła.Gets the first child of the node.

(Odziedziczone po XmlNode)
HasChildNodes

Pobiera wartość wskazującą, czy ten węzeł ma wszystkie węzły podrzędne.Gets a value indicating whether this node has any child nodes.

(Odziedziczone po XmlNode)
Implementation

Pobiera XmlImplementation obiekt dla bieżącego dokumentu.Gets the XmlImplementation object for the current document.

InnerText

Zgłasza InvalidOperationException we wszystkich przypadkach.Throws an InvalidOperationException in all cases.

InnerXml

Pobiera lub ustawia adiustację reprezentującą elementy podrzędne bieżącego węzła.Gets or sets the markup representing the children of the current node.

IsReadOnly

Pobiera wartość wskazującą, czy bieżący węzeł jest tylko do odczytu.Gets a value indicating whether the current node is read-only.

Item[String, String]

Pobiera pierwszy element podrzędny o określonym LocalName i NamespaceURI.Gets the first child element with the specified LocalName and NamespaceURI.

(Odziedziczone po XmlNode)
Item[String]

Pobiera pierwszy element podrzędny o określonym Name.Gets the first child element with the specified Name.

(Odziedziczone po XmlNode)
LastChild

Pobiera ostatni element podrzędny węzła.Gets the last child of the node.

(Odziedziczone po XmlNode)
LocalName

Pobiera lokalną nazwę węzła.Gets the local name of the node.

Name

Pobiera kwalifikowaną nazwę węzła.Gets the qualified name of the node.

NamespaceURI

Pobiera identyfikator URI przestrzeni nazw tego węzła.Gets the namespace URI of this node.

(Odziedziczone po XmlNode)
NameTable

Pobiera XmlNameTable skojarzoną z tą implementacją.Gets the XmlNameTable associated with this implementation.

NextSibling

Pobiera węzeł zaraz po tym węźle.Gets the node immediately following this node.

(Odziedziczone po XmlNode)
NodeType

Pobiera typ bieżącego węzła.Gets the type of the current node.

OuterXml

Pobiera znaczniki zawierające ten węzeł i wszystkie jego węzły podrzędne.Gets the markup containing this node and all its child nodes.

(Odziedziczone po XmlNode)
OwnerDocument

Pobiera XmlDocument, do którego należy bieżący węzeł.Gets the XmlDocument to which the current node belongs.

ParentNode

Pobiera węzeł nadrzędny tego węzła (dla węzłów, które mogą mieć elementy nadrzędne).Gets the parent node of this node (for nodes that can have parents).

Prefix

Pobiera lub ustawia prefiks przestrzeni nazw tego węzła.Gets or sets the namespace prefix of this node.

(Odziedziczone po XmlNode)
PreserveWhitespace

Pobiera lub ustawia wartość wskazującą, czy ma być zachowywany biały znak w zawartości elementu.Gets or sets a value indicating whether to preserve white space in element content.

PreviousSibling

Pobiera węzeł bezpośrednio poprzedzający ten węzeł.Gets the node immediately preceding this node.

(Odziedziczone po XmlNode)
PreviousText

Pobiera węzeł tekstowy, który bezpośrednio poprzedza ten węzeł.Gets the text node that immediately precedes this node.

(Odziedziczone po XmlNode)
SchemaInfo

Zwraca wartość po schemacie walidacji-sprawdzonych (PSVI) węzła.Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

Schemas

Pobiera lub ustawia obiekt XmlSchemaSet skojarzony z tym XmlDocument.Gets or sets the XmlSchemaSet object associated with this XmlDocument.

Value

Pobiera lub ustawia wartość węzła.Gets or sets the value of the node.

(Odziedziczone po XmlNode)
XmlResolver

Ustawia XmlResolver używany do rozpoznawania zasobów zewnętrznych.Sets the XmlResolver to use for resolving external resources.

Metody

AppendChild(XmlNode)

Dodaje określony węzeł na końcu listy węzłów podrzędnych tego węzła.Adds the specified node to the end of the list of child nodes, of this node.

(Odziedziczone po XmlNode)
Clone()

Tworzy duplikat tego węzła.Creates a duplicate of this node.

(Odziedziczone po XmlNode)
CloneNode(Boolean)

Tworzy duplikat tego węzła.Creates a duplicate of this node.

CreateAttribute(String)

Tworzy XmlAttribute z określonym Name.Creates an XmlAttribute with the specified Name.

CreateAttribute(String, String)

Tworzy XmlAttribute z określoną kwalifikowaną nazwą i NamespaceURI.Creates an XmlAttribute with the specified qualified name and NamespaceURI.

CreateAttribute(String, String, String)

Tworzy XmlAttribute z określonym Prefix, LocalNamei NamespaceURI.Creates an XmlAttribute with the specified Prefix, LocalName, and NamespaceURI.

CreateCDataSection(String)

Tworzy XmlCDataSection zawierający określone dane.Creates an XmlCDataSection containing the specified data.

CreateComment(String)

Tworzy XmlComment zawierający określone dane.Creates an XmlComment containing the specified data.

CreateDefaultAttribute(String, String, String)

Tworzy atrybut domyślny z określonym prefiksem, nazwą lokalną i identyfikatorem URI przestrzeni nazw.Creates a default attribute with the specified prefix, local name and namespace URI.

CreateDocumentFragment()

Tworzy XmlDocumentFragment.Creates an XmlDocumentFragment.

CreateDocumentType(String, String, String, String)

Zwraca nowy obiekt XmlDocumentType.Returns a new XmlDocumentType object.

CreateElement(String)

Tworzy element o określonej nazwie.Creates an element with the specified name.

CreateElement(String, String)

Tworzy XmlElement przy użyciu kwalifikowanej nazwy i NamespaceURI.Creates an XmlElement with the qualified name and NamespaceURI.

CreateElement(String, String, String)

Tworzy element z określonym Prefix, LocalNamei NamespaceURI.Creates an element with the specified Prefix, LocalName, and NamespaceURI.

CreateEntityReference(String)

Tworzy XmlEntityReference o podanej nazwie.Creates an XmlEntityReference with the specified name.

CreateNavigator()

Tworzy nowy obiekt XPathNavigator na potrzeby nawigowania po tym dokumencie.Creates a new XPathNavigator object for navigating this document.

CreateNavigator(XmlNode)

Tworzy obiekt XPathNavigator na potrzeby nawigowania po tym dokumencie w określonym XmlNode.Creates an XPathNavigator object for navigating this document positioned on the XmlNode specified.

CreateNode(String, String, String)

Tworzy XmlNode z określonym typem węzła, Namei NamespaceURI.Creates an XmlNode with the specified node type, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String)

Tworzy XmlNode z określonym XmlNodeType, Namei NamespaceURI.Creates an XmlNode with the specified XmlNodeType, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String, String)

Tworzy XmlNode z określonym XmlNodeType, Prefix, Namei NamespaceURI.Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.

CreateProcessingInstruction(String, String)

Tworzy XmlProcessingInstruction z określoną nazwą i danymi.Creates an XmlProcessingInstruction with the specified name and data.

CreateSignificantWhitespace(String)

Tworzy węzeł XmlSignificantWhitespace.Creates an XmlSignificantWhitespace node.

CreateTextNode(String)

Tworzy XmlText z określonym tekstem.Creates an XmlText with the specified text.

CreateWhitespace(String)

Tworzy węzeł XmlWhitespace.Creates an XmlWhitespace node.

CreateXmlDeclaration(String, String, String)

Tworzy węzeł XmlDeclaration o określonych wartościach.Creates an XmlDeclaration node with the specified values.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetElementById(String)

Pobiera XmlElement o określonym IDENTYFIKATORze.Gets the XmlElement with the specified ID.

GetElementsByTagName(String)

Zwraca XmlNodeList zawierający listę wszystkich elementów podrzędnych, które pasują do określonego Name.Returns an XmlNodeList containing a list of all descendant elements that match the specified Name.

GetElementsByTagName(String, String)

Zwraca XmlNodeList zawierający listę wszystkich elementów podrzędnych, które pasują do określonej LocalName i NamespaceURI.Returns an XmlNodeList containing a list of all descendant elements that match the specified LocalName and NamespaceURI.

GetEnumerator()

Pobiera moduł wyliczający, który wykonuje iterację w węzłach podrzędnych w bieżącym węźle.Gets an enumerator that iterates through the child nodes in the current node.

(Odziedziczone po XmlNode)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetNamespaceOfPrefix(String)

Wyszukuje najbliższą deklarację xmlns dla danego prefiksu, który znajduje się w zakresie dla bieżącego węzła i zwraca identyfikator URI przestrzeni nazw w deklaracji.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.

(Odziedziczone po XmlNode)
GetPrefixOfNamespace(String)

Wyszukuje najbliższą deklarację xmlns dla danego identyfikatora URI przestrzeni nazw, który znajduje się w zakresie dla bieżącego węzła i zwraca prefiks zdefiniowany w tej deklaracji.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.

(Odziedziczone po XmlNode)
GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
ImportNode(XmlNode, Boolean)

Importuje węzeł z innego dokumentu do bieżącego dokumentu.Imports a node from another document to the current document.

InsertAfter(XmlNode, XmlNode)

Wstawia określony węzeł bezpośrednio po określonym węźle odniesienia.Inserts the specified node immediately after the specified reference node.

(Odziedziczone po XmlNode)
InsertBefore(XmlNode, XmlNode)

Wstawia określony węzeł bezpośrednio przed określonym węzłem referencyjnym.Inserts the specified node immediately before the specified reference node.

(Odziedziczone po XmlNode)
Load(Stream)

Ładuje dokument XML z określonego strumienia.Loads the XML document from the specified stream.

Load(String)

Ładuje dokument XML z podanego adresu URL.Loads the XML document from the specified URL.

Load(TextReader)

Ładuje dokument XML z określonego TextReader.Loads the XML document from the specified TextReader.

Load(XmlReader)

Ładuje dokument XML z określonego XmlReader.Loads the XML document from the specified XmlReader.

LoadXml(String)

Ładuje dokument XML z określonego ciągu.Loads the XML document from the specified string.

MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Normalize()

Umieszcza wszystkie węzły XmlText w pełnej głębokości poddrzewa poniżej tego elementu XmlNode w postaci "normal", w której tylko znaczniki (znaczniki, komentarze, instrukcje przetwarzania, sekcje CDATA i odwołania do jednostek) oddzielają węzły XmlText, czyli nie są przyległe Węzły 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.

(Odziedziczone po XmlNode)
PrependChild(XmlNode)

Dodaje określony węzeł na początku listy węzłów podrzędnych dla tego węzła.Adds the specified node to the beginning of the list of child nodes for this node.

(Odziedziczone po XmlNode)
ReadNode(XmlReader)

Tworzy obiekt XmlNode na podstawie informacji z XmlReader.Creates an XmlNode object based on the information in the XmlReader. Czytnik musi być umieszczony w węźle lub atrybucie.The reader must be positioned on a node or attribute.

RemoveAll()

Usuwa wszystkie węzły podrzędne i/lub atrybuty bieżącego węzła.Removes all the child nodes and/or attributes of the current node.

(Odziedziczone po XmlNode)
RemoveChild(XmlNode)

Usuwa określony węzeł podrzędny.Removes specified child node.

(Odziedziczone po XmlNode)
ReplaceChild(XmlNode, XmlNode)

Zamienia węzeł podrzędny oldChild z węzłem newChild.Replaces the child node oldChild with newChild node.

(Odziedziczone po XmlNode)
Save(Stream)

Zapisuje dokument XML do określonego strumienia.Saves the XML document to the specified stream.

Save(String)

Zapisuje dokument XML do określonego pliku.Saves the XML document to the specified file. Jeśli określony plik istnieje, ta metoda zastępuje ją.If the specified file exists, this method overwrites it.

Save(TextWriter)

Zapisuje dokument XML do określonego TextWriter.Saves the XML document to the specified TextWriter.

Save(XmlWriter)

Zapisuje dokument XML do określonego XmlWriter.Saves the XML document to the specified XmlWriter.

SelectNodes(String)

Wybiera listę węzłów pasujących do wyrażenia XPath.Selects a list of nodes matching the XPath expression.

(Odziedziczone po XmlNode)
SelectNodes(String, XmlNamespaceManager)

Wybiera listę węzłów pasujących do wyrażenia XPath.Selects a list of nodes matching the XPath expression. Wszystkie prefiksy Znalezione w wyrażeniu XPath są rozwiązywane przy użyciu podanej XmlNamespaceManager.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Odziedziczone po XmlNode)
SelectSingleNode(String)

Wybiera pierwszy XmlNode, który pasuje do wyrażenia XPath.Selects the first XmlNode that matches the XPath expression.

(Odziedziczone po XmlNode)
SelectSingleNode(String, XmlNamespaceManager)

Wybiera pierwszy XmlNode, który pasuje do wyrażenia XPath.Selects the first XmlNode that matches the XPath expression. Wszystkie prefiksy Znalezione w wyrażeniu XPath są rozwiązywane przy użyciu podanej XmlNamespaceManager.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Odziedziczone po XmlNode)
Supports(String, String)

Testuje, czy implementacja modelu DOM implementuje konkretną funkcję.Tests if the DOM implementation implements a specific feature.

(Odziedziczone po XmlNode)
ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
Validate(ValidationEventHandler)

Sprawdza poprawność XmlDocument względem schematów języka definicji schematu XML (XSD) zawartych we właściwości Schemas.Validates the XmlDocument against the XML Schema Definition Language (XSD) schemas contained in the Schemas property.

Validate(ValidationEventHandler, XmlNode)

Sprawdza poprawność obiektu XmlNode określonego w schematach języka definicji schematu XML (XSD) we właściwości Schemas.Validates the XmlNode object specified against the XML Schema Definition Language (XSD) schemas in the Schemas property.

WriteContentTo(XmlWriter)

Zapisuje wszystkie elementy podrzędne węzła XmlDocument do określonego XmlWriter.Saves all the children of the XmlDocument node to the specified XmlWriter.

WriteTo(XmlWriter)

Zapisuje węzeł XmlDocument do określonego XmlWriter.Saves the XmlDocument node to the specified XmlWriter.

Zdarzenia

NodeChanged

Występuje, gdy Value węzła należącego do tego dokumentu został zmieniony.Occurs when the Value of a node belonging to this document has been changed.

NodeChanging

Występuje, gdy Value węzła należącego do tego dokumentu zostanie zmieniony.Occurs when the Value of a node belonging to this document is about to be changed.

NodeInserted

Występuje, gdy węzeł należący do tego dokumentu został wstawiony do innego węzła.Occurs when a node belonging to this document has been inserted into another node.

NodeInserting

Występuje, gdy węzeł należący do tego dokumentu zostanie wstawiony do innego węzła.Occurs when a node belonging to this document is about to be inserted into another node.

NodeRemoved

Występuje, gdy węzeł należący do tego dokumentu został usunięty z jego elementu nadrzędnego.Occurs when a node belonging to this document has been removed from its parent.

NodeRemoving

Występuje, gdy węzeł należący do tego dokumentu zostanie usunięty z dokumentu.Occurs when a node belonging to this document is about to be removed from the document.

Jawne implementacje interfejsu

ICloneable.Clone()

Aby uzyskać opis tego elementu członkowskiego, zobacz Clone().For a description of this member, see Clone().

(Odziedziczone po XmlNode)
IEnumerable.GetEnumerator()

Aby uzyskać opis tego elementu członkowskiego, zobacz GetEnumerator().For a description of this member, see GetEnumerator().

(Odziedziczone po XmlNode)

Metody rozszerzania

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

Konwertuje IEnumerable na 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)

Dotyczy

Zobacz też