XmlDocument Kelas

Definisi

Ruang nama:

System.Xml

Rakitan:

netstandard.dll, System.Xml.ReaderWriter.dll

Sumber:

XmlDocument.cs

Mewakili dokumen XML. Anda dapat menggunakan kelas ini untuk memuat, memvalidasi, mengedit, menambahkan, dan memposisikan XML dalam dokumen.

public ref class XmlDocument : System::Xml::XmlNode

public class XmlDocument : System.Xml.XmlNode

type XmlDocument = class
    inherit XmlNode

Public Class XmlDocument
Inherits XmlNode

Warisan

Object

XmlNode

XmlDocument

Turunan

System.Configuration.ConfigXmlDocument

System.Xml.XmlDataDocument

Keterangan

Kelas XmlDocument adalah representasi dalam memori dari dokumen XML. Ini mengimplementasikan W3C XML Document Object Model (DOM) Level 1 Core dan Core DOM Level 2.

DOM adalah singkatan dari model objek dokumen. Untuk membaca selengkapnya tentang hal itu, lihat Model Objek Dokumen XML (DOM).

Anda dapat memuat XML ke dalam DOM dengan menggunakan XmlDocument kelas , lalu membaca, memodifikasi, dan menghapus XML secara terprogram dalam dokumen.

Jika Anda ingin membuka XmlDocument kelas dan melihat cara penerapannya, lihat Sumber Referensi.

Memuat XML ke dalam model objek dokumen

Mulailah dengan dokumen XML seperti ini yang memiliki beberapa buku dalam koleksi. Ini berisi hal-hal dasar yang akan Anda temukan di dokumen XML apa pun, termasuk namespace, elemen yang mewakili data, dan atribut yang menjelaskan 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>

Selanjutnya, muat data ini ke dalam DOM sehingga Anda dapat bekerja dengannya dalam memori. Cara paling populer untuk melakukan ini adalah dengan merujuk ke file di komputer lokal Anda atau pada jaringan.

Contoh ini memuat XML dari file. Jika file tidak ada, file hanya menghasilkan beberapa XML dan memuatnya.

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

Untuk informasi selengkapnya, lihat Membaca Dokumen XML ke dalam DOM.

Memvalidasinya terhadap skema

Mulailah dengan skema XML seperti ini. Skema ini menentukan jenis data dalam XML dan atribut mana yang diperlukan.

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

Buat XmlReader objek dengan menggunakan skema Anda, lalu muat objek tersebut ke dalam DOM. Buat penanganan aktivitas yang dijalankan saat kode mencoba memodifikasi file XML Anda dengan cara yang melanggar aturan skema.

Blok kode ini menunjukkan metode pembantu yang melakukan semua ini.

//************************************************************************************
//
//  Helper method that generates an XML string.
//
//************************************************************************************
private string generateXMLString()
{
    string xml = "<?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" +
        "  <book genre=\"novel\" ISBN=\"1-861001-45-3\" publicationdate=\"1811-01-01\"> \n" +
        "    <title>Sense and Sensibility</title> \n" +
        "    <price>19.95</price> \n" +
        "  </book> \n" +
        "</books>";
    return xml;
}

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************
public XmlDocument LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader reader = null;
    XmlReaderSettings settings = new XmlReaderSettings();
    // Helper method to retrieve schema.
    XmlSchema schema = getSchema(generateSchema);

    settings.Schemas.Add(schema);
    settings.ValidationEventHandler += ValidationCallback;
    settings.ValidationFlags =
        settings.ValidationFlags | XmlSchemaValidationFlags.ReportValidationWarnings;
    settings.ValidationType = ValidationType.Schema;
    if (!generateXML)
    {
        try
        {
            reader = XmlReader.Create("booksData.xml", settings);
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine(
                $"XML file not found so generating: {ex.Message}");
            generateXML = true;
        }
    }

    if (generateXML)
    {
        string xml = generateXMLString();
        StringReader stringReader = new StringReader(xml);

        reader = XmlReader.Create(stringReader, settings);
    }

    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 = null;

    if (!generateSchema)
    {
        try
        {
            schema = xs.Add("http://www.contoso.com/books", "booksData.xsd");
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine(
                $"XSD file not found so generating: {ex.Message}");
            generateSchema = true;
        }
    }

    if (generateSchema)
    {
        string xmlSchemaString = generateXMLSchema();
        StringReader stringReader = new StringReader(xmlSchemaString);
        XmlReader reader = XmlReader.Create(stringReader);

        schema = xs.Add("http://www.contoso.com/books", reader);
    }

    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 a callback to validate the XML node against the schema.
    doc.Validate(ValidationCallback);
}

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

'************************************************************************************
'
'  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

Untuk informasi selengkapnya, lihat Memvalidasi Dokumen XML di DOM.

Menavigasi pohon dokumen

Anda dapat menggunakan properti untuk menavigasi di sekitar dokumen XML. Tetapi sebelum Anda menggunakan salah satu dari mereka, mari kita tinjau beberapa istilah dengan cepat. Dokumen Anda terdiri dari simpul. Setiap simpul memiliki satu simpul induk tepat di atasnya. Satu-satunya simpul yang tidak memiliki simpul induk adalah akar dokumen, karena merupakan simpul tingkat atas. Sebagian besar simpul dapat memiliki simpul anak , yang merupakan simpul tepat di bawahnya. Node yang berada di tingkat yang sama adalah saudara kandung.

Contoh berikut menunjukkan kepada Anda cara mendapatkan simpul akar, melompat ke simpul anak pertama dari simpul akar, mengakses salah satu simpul anaknya, kembali ke simpul induk, lalu menavigasi antar simpul-simpul saudara.

Mulai dengan simpul akar

Contoh ini mendapatkan simpul akar lalu menggunakan simpul tersebut untuk menghasilkan konten dokumen ke konsol.

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 On
Option Explicit On
Imports System.Xml

Public Class ElementSample
    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

Ambil simpul anak

Contoh ini melompat ke simpul anak pertama dari simpul akar dan kemudian melakukan iterasi melalui simpul anak dari simpul tersebut jika ada.

using System;
using System.Xml;

public class Sample2
{
    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

Kembali ke simpul induk

Gunakan properti ParentNode.

Rujuk ke simpul anak terakhir

Contoh ini menulis harga buku ke konsol. Simpul harga adalah anak terakhir dari simpul buku.

using System;
using System.Xml;

public class Sample3
{
    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 On
Option Strict On
Imports System.Xml

Public Class LastChildSample
    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

Menavigasi ke depan melalui komponen sejenis

Contoh ini beralih dari satu buku ke buku lainnya. Simpul buku adalah saudara kandung satu sama lain.

using System;
using System.Xml;

public class Sample4
{
    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 NextSiblingSample
    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

Menavigasi mundur melintasi saudara kandung

Contoh ini bergerak mundur dari satu buku ke buku lainnya.

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

Menemukan simpul

Cara paling populer untuk menemukan satu atau beberapa simpul data adalah dengan menggunakan string kueri XPath, tetapi ada juga metode yang tidak memerlukannya.

Dapatkan satu simpul

Contoh ini menemukan buku dengan menggunakan nomor ISBN.

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

String yang digunakan dalam contoh ini adalah kueri Xpath. Anda dapat menemukan lebih banyak contohnya di contoh XPath.

Anda juga dapat menggunakan GetElementById untuk mengambil simpul. Untuk menggunakan pendekatan ini, Anda harus menentukan ID dalam deklarasi definisi jenis dokumen file XML Anda.

Setelah Anda mendapatkan simpul, Anda memperoleh nilai atribut atau simpul anak. Contoh ini melakukannya dengan simpul dari sebuah buku.

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

Dapatkan koleksi simpul

Contoh ini memilih semua buku di mana nama belakang penulis adalah Austen, lalu mengubah harga buku-buku tersebut.

using System;
using System.Xml;

public class Sample6
{
    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

Anda juga bisa mendapatkan koleksi simpul dengan menggunakan nama simpul. Misalnya, contoh ini bisa memperoleh koleksi semua judul buku.

using System;
using System.Xml;

public class Sample1
{
    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 On
Option Strict On
Imports System.Xml

Public Class TagSample

    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

Untuk informasi selengkapnya, lihat Memilih Simpul Menggunakan Navigasi XPath.

Mengedit elemen

Contoh ini mengedit node buku dan atributnya.

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

Untuk informasi selengkapnya, lihat Memodifikasi Simpul, Konten, dan Nilai dalam Dokumen XML.

Tambah node

Untuk menambahkan simpul, gunakan CreateElement metode atau CreateNode metode .

Untuk menambahkan simpul data seperti buku, gunakan metode .CreateElement

Untuk jenis node lain seperti komentar, node spasi kosong, atau node CDATA, gunakan metode .CreateNode

Contoh ini membuat simpul buku, menambahkan atribut ke simpul tersebut, lalu menambahkan simpul tersebut ke dokumen.

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

Untuk informasi selengkapnya, lihat Menyisipkan Simpul ke dalam Dokumen XML.

Menghapus simpul

Untuk menghapus simpul, gunakan RemoveChild metode .

Contoh ini menghapus buku dari dokumen dan spasi kosong apa pun yang muncul tepat sebelum simpul buku.

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

Untuk informasi selengkapnya, lihat Menghapus Simpul, Konten, dan Nilai dari Dokumen XML.

Simpul-simpul posisi

Anda dapat memilih di mana Anda ingin node muncul di dokumen Anda dengan menggunakan InsertBefore metode dan InsertAfter .

Contoh ini menunjukkan dua metode pembantu. Salah satunya memindahkan simpul ke posisi yang lebih tinggi dalam daftar. Yang lainnya memindahkan node ke posisi yang lebih rendah.

Metode ini dapat digunakan dalam aplikasi yang memungkinkan pengguna untuk memindahkan buku ke atas dan ke bawah dalam daftar buku. Ketika pengguna memilih buku dan menekan tombol atas atau bawah, kode Anda dapat memanggil metode seperti ini untuk memposisikan node buku yang sesuai sebelum atau setelah node buku lainnya.

//************************************************************************************
//
//  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

Konstruktor

Nama	Deskripsi
XmlDocument()	Menginisialisasi instans baru dari kelas XmlDocument.
XmlDocument(XmlImplementation)	Menginisialisasi instans XmlDocument baru kelas dengan yang ditentukan XmlImplementation.
XmlDocument(XmlNameTable)	Menginisialisasi instans XmlDocument baru kelas dengan yang ditentukan XmlNameTable.

Properti

Nama	Deskripsi
Attributes	Mendapatkan yang XmlAttributeCollection berisi atribut simpul ini. (Diperoleh dari XmlNode)
BaseURI	Mendapatkan URI dasar simpul saat ini.
ChildNodes	Mendapatkan semua simpul anak dari simpul. (Diperoleh dari XmlNode)
DocumentElement	Mendapatkan akar XmlElement untuk dokumen.
DocumentType	Mendapatkan node yang berisi deklarasi DOCTYPE.
FirstChild	Mendapatkan anak pertama dari simpul. (Diperoleh dari XmlNode)
HasChildNodes	Mendapatkan nilai yang menunjukkan apakah simpul ini memiliki simpul anak. (Diperoleh dari XmlNode)
Implementation	XmlImplementation Mendapatkan objek untuk dokumen saat ini.
InnerText	InvalidOperationException Melemparkan dalam semua kasus.
InnerXml	Mendapatkan atau mengatur markup yang mewakili turunan simpul saat ini.
IsReadOnly	Mendapatkan nilai yang menunjukkan apakah simpul saat ini bersifat baca-saja.
Item[String, String]	Mendapatkan elemen turunan pertama dengan yang ditentukan LocalName dan NamespaceURI. (Diperoleh dari XmlNode)
Item[String]	Mendapatkan elemen turunan pertama dengan yang ditentukan Name. (Diperoleh dari XmlNode)
LastChild	Mendapatkan anak terakhir dari simpul. (Diperoleh dari XmlNode)
LocalName	Mendapatkan nama lokal simpul.
Name	Mendapatkan nama node yang memenuhi syarat.
NamespaceURI	Mendapatkan URI namespace dari simpul ini. (Diperoleh dari XmlNode)
NameTable	Mendapatkan yang XmlNameTable terkait dengan implementasi ini.
NextSibling	Mendapatkan simpul segera mengikuti simpul ini. (Diperoleh dari XmlNode)
NodeType	Mendapatkan jenis simpul saat ini.
OuterXml	Mendapatkan markup yang berisi simpul ini dan semua simpul anaknya. (Diperoleh dari XmlNode)
OwnerDocument	Mendapatkan tempat XmlDocument simpul saat ini berada.
ParentNode	Mendapatkan simpul induk dari simpul ini (untuk simpul yang dapat memiliki orang tua).
Prefix	Mendapatkan atau mengatur awalan namespace dari simpul ini. (Diperoleh dari XmlNode)
PreserveWhitespace	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan mempertahankan spasi kosong dalam konten elemen.
PreviousSibling	Mendapatkan simpul segera mendahului simpul ini. (Diperoleh dari XmlNode)
PreviousText	Mendapatkan simpul teks yang segera mendahului simpul ini. (Diperoleh dari XmlNode)
SchemaInfo	Mengembalikan Post-Schema-Validation-Infoset (PSVI) dari simpul.
Schemas	Mendapatkan atau mengatur objek yang XmlSchemaSet terkait dengan ini XmlDocument.
Value	Mendapatkan atau menetapkan nilai simpul. (Diperoleh dari XmlNode)
XmlResolver	Mengatur yang XmlResolver akan digunakan untuk menyelesaikan sumber daya eksternal.

Metode

Nama	Deskripsi
AppendChild(XmlNode)	Menambahkan simpul yang ditentukan ke akhir daftar simpul anak, dari simpul ini. (Diperoleh dari XmlNode)
Clone()	Membuat duplikat simpul ini. (Diperoleh dari XmlNode)
CloneNode(Boolean)	Membuat duplikat simpul ini.
CreateAttribute(String, String, String)	XmlAttribute Membuat dengan yang ditentukan Prefix, , LocalNamedan NamespaceURI.
CreateAttribute(String, String)	XmlAttribute Membuat dengan nama yang memenuhi syarat dan NamespaceURI.
CreateAttribute(String)	XmlAttribute Membuat dengan yang ditentukan Name.
CreateCDataSection(String)	Membuat yang XmlCDataSection berisi data yang ditentukan.
CreateComment(String)	Membuat yang XmlComment berisi data yang ditentukan.
CreateDefaultAttribute(String, String, String)	Membuat atribut default dengan awalan, nama lokal, dan URI namespace yang ditentukan.
CreateDocumentFragment()	Membuat sebuah XmlDocumentFragment.
CreateDocumentType(String, String, String, String)	Mengembalikan objek baru XmlDocumentType .
CreateElement(String, String, String)	Membuat elemen dengan yang ditentukan Prefix, , LocalNamedan NamespaceURI.
CreateElement(String, String)	XmlElement Membuat dengan nama yang memenuhi syarat dan NamespaceURI.
CreateElement(String)	Membuat elemen dengan nama yang ditentukan.
CreateEntityReference(String)	XmlEntityReference Membuat dengan nama yang ditentukan.
CreateNavigator()	Membuat objek baru XPathNavigator untuk menavigasi dokumen ini.
CreateNavigator(XmlNode)	XPathNavigator Membuat objek untuk menavigasi dokumen ini yang diposisikan pada XmlNode yang ditentukan.
CreateNode(String, String, String)	XmlNode Membuat dengan jenis node yang ditentukan, , Namedan NamespaceURI.
CreateNode(XmlNodeType, String, String, String)	XmlNode Membuat dengan yang ditentukan XmlNodeType, , Prefix, Namedan NamespaceURI.
CreateNode(XmlNodeType, String, String)	XmlNode Membuat dengan yang ditentukan XmlNodeType, , Namedan NamespaceURI.
CreateProcessingInstruction(String, String)	XmlProcessingInstruction Membuat dengan nama dan data yang ditentukan.
CreateSignificantWhitespace(String)	Membuat simpul XmlSignificantWhitespace .
CreateTextNode(String)	XmlText Membuat dengan teks yang ditentukan.
CreateWhitespace(String)	Membuat simpul XmlWhitespace .
CreateXmlDeclaration(String, String, String)	Membuat simpul XmlDeclaration dengan nilai yang ditentukan.
Equals(Object)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object)
GetElementById(String)	XmlElement Mendapatkan dengan ID yang ditentukan.
GetElementsByTagName(String, String)	Mengembalikan XmlNodeList daftar yang berisi semua elemen turunan yang cocok dengan yang ditentukan LocalName dan NamespaceURI.
GetElementsByTagName(String)	Mengembalikan XmlNodeList daftar yang berisi semua elemen turunan yang cocok dengan yang ditentukan Name.
GetEnumerator()	Mendapatkan enumerator yang melakukan iterasi melalui simpul anak di simpul saat ini. (Diperoleh dari XmlNode)
GetHashCode()	Berfungsi sebagai fungsi hash default. (Diperoleh dari Object)
GetNamespaceOfPrefix(String)	Mencari deklarasi xmln terdekat untuk awalan yang diberikan yang berada dalam cakupan untuk simpul saat ini dan mengembalikan URI namespace dalam deklarasi. (Diperoleh dari XmlNode)
GetPrefixOfNamespace(String)	Mencari deklarasi xmln terdekat untuk URI namespace yang diberikan yang berada dalam cakupan untuk simpul saat ini dan mengembalikan awalan yang ditentukan dalam deklarasi tersebut. (Diperoleh dari XmlNode)
GetType()	Mendapatkan Type instans saat ini. (Diperoleh dari Object)
ImportNode(XmlNode, Boolean)	Mengimpor simpul dari dokumen lain ke dokumen saat ini.
InsertAfter(XmlNode, XmlNode)	Menyisipkan simpul yang ditentukan segera setelah simpul referensi yang ditentukan. (Diperoleh dari XmlNode)
InsertBefore(XmlNode, XmlNode)	Menyisipkan simpul yang ditentukan segera sebelum simpul referensi yang ditentukan. (Diperoleh dari XmlNode)
Load(Stream)	Memuat dokumen XML dari aliran yang ditentukan.
Load(String)	Memuat dokumen XML dari URL yang ditentukan.
Load(TextReader)	Memuat dokumen XML dari yang ditentukan TextReader.
Load(XmlReader)	Memuat dokumen XML dari yang ditentukan XmlReader.
LoadXml(String)	Memuat dokumen XML dari string yang ditentukan.
MemberwiseClone()	Membuat salinan dangkal dari Objectsaat ini. (Diperoleh dari Object)
Normalize()	Menempatkan semua simpul XmlText di kedalaman penuh sub-pohon di bawah XmlNode ini ke dalam formulir "normal" di mana hanya markup (yaitu, tag, komentar, instruksi pemrosesan, bagian CDATA, dan referensi entitas) memisahkan simpul XmlText, yaitu, tidak ada simpul XmlText yang berdekatan. (Diperoleh dari XmlNode)
PrependChild(XmlNode)	Menambahkan simpul yang ditentukan ke awal daftar simpul anak untuk simpul ini. (Diperoleh dari XmlNode)
ReadNode(XmlReader)	XmlNode Membuat objek berdasarkan informasi di XmlReader. Pembaca harus diposisikan pada simpul atau atribut.
RemoveAll()	Menghapus semua simpul anak dan/atau atribut simpul saat ini. (Diperoleh dari XmlNode)
RemoveChild(XmlNode)	Menghapus simpul anak yang ditentukan. (Diperoleh dari XmlNode)
ReplaceChild(XmlNode, XmlNode)	Mengganti simpul oldChild anak dengan newChild simpul. (Diperoleh dari XmlNode)
Save(Stream)	Menyimpan dokumen XML ke aliran yang ditentukan.
Save(String)	Menyimpan dokumen XML ke file yang ditentukan. Jika file yang ditentukan ada, metode ini akan menimpanya.
Save(TextWriter)	Menyimpan dokumen XML ke yang ditentukan TextWriter.
Save(XmlWriter)	Menyimpan dokumen XML ke yang ditentukan XmlWriter.
SelectNodes(String, XmlNamespaceManager)	Memilih daftar simpul yang cocok dengan ekspresi XPath. Setiap awalan yang ditemukan dalam ekspresi XPath diselesaikan menggunakan yang disediakan XmlNamespaceManager. (Diperoleh dari XmlNode)
SelectNodes(String)	Memilih daftar simpul yang cocok dengan ekspresi XPath. (Diperoleh dari XmlNode)
SelectSingleNode(String, XmlNamespaceManager)	Memilih yang pertama XmlNode yang cocok dengan ekspresi XPath. Setiap awalan yang ditemukan dalam ekspresi XPath diselesaikan menggunakan yang disediakan XmlNamespaceManager. (Diperoleh dari XmlNode)
SelectSingleNode(String)	Memilih yang pertama XmlNode yang cocok dengan ekspresi XPath. (Diperoleh dari XmlNode)
Supports(String, String)	Menguji apakah implementasi DOM menerapkan fitur tertentu. (Diperoleh dari XmlNode)
ToString()	Mengembalikan string yang mewakili objek saat ini. (Diperoleh dari Object)
Validate(ValidationEventHandler, XmlNode)	Memvalidasi XmlNode objek yang ditentukan terhadap skema XML Schema Definition Language (XSD) dalam Schemas properti .
Validate(ValidationEventHandler)	Memvalidasi XmlDocument terhadap skema XML Schema Definition Language (XSD) yang terkandung dalam Schemas properti .
WriteContentTo(XmlWriter)	Menyimpan semua anak simpul XmlDocument ke yang ditentukan XmlWriter.
WriteTo(XmlWriter)	Menyimpan simpul XmlDocument ke yang ditentukan XmlWriter.

Acara

Nama	Deskripsi
NodeChanged	Terjadi ketika Value simpul milik dokumen ini telah diubah.
NodeChanging	Terjadi ketika Value simpul milik dokumen ini akan diubah.
NodeInserted	Terjadi ketika simpul milik dokumen ini telah dimasukkan ke dalam simpul lain.
NodeInserting	Terjadi ketika simpul milik dokumen ini akan dimasukkan ke dalam simpul lain.
NodeRemoved	Terjadi ketika simpul milik dokumen ini telah dihapus dari induknya.
NodeRemoving	Terjadi ketika simpul milik dokumen ini akan dihapus dari dokumen.

Implementasi Antarmuka Eksplisit

Nama	Deskripsi
ICloneable.Clone()	Untuk deskripsi anggota ini, lihat Clone(). (Diperoleh dari XmlNode)
IEnumerable.GetEnumerator()	Untuk deskripsi anggota ini, lihat GetEnumerator(). (Diperoleh dari XmlNode)

Metode Ekstensi

Nama	Deskripsi
AsParallel(IEnumerable)	Mengaktifkan paralelisasi kueri.
AsQueryable(IEnumerable)	Mengonversi IEnumerable menjadi IQueryable.
Cast<TResult>(IEnumerable)	Melemparkan elemen IEnumerable ke jenis yang ditentukan.
OfType<TResult>(IEnumerable)	Memfilter elemen IEnumerable berdasarkan jenis tertentu.

Lihat juga

• XmlNodeChangedEventHandler