XmlDocument Sınıf

Tanım

Ad Alanı:

System.Xml

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Xml.ReaderWriter.dll

Kaynak:

XmlDocument.cs

XML belgesini temsil eder. Belgedeki XML'yi yüklemek, doğrulamak, düzenlemek, eklemek ve konumlandırmak için bu sınıfı kullanabilirsiniz.

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

public class XmlDocument : System.Xml.XmlNode

type XmlDocument = class
    inherit XmlNode

Public Class XmlDocument
Inherits XmlNode

Devralma

Object

XmlNode

XmlDocument

Türetilmiş

System.Configuration.ConfigXmlDocument

System.Xml.XmlDataDocument

Açıklamalar

XmlDocument sınıfı, bir XML belgesinin bellek içi gösterimidir. W3C XML Belge Nesne Modeli (DOM) Düzey 1 Core ve Çekirdek DOM Düzey 2'yi uygular.

DOM , belge nesne modelinin kısaltmasıdır. Bu konuda daha fazla bilgi edinmek için bkz. XML Belge Nesne Modeli (DOM)...

SıNıFını kullanarak XmlDocument DOM'a XML yükleyebilir ve ardından belgedeki XML'yi program aracılığıyla okuyabilir, değiştirebilir ve kaldırabilirsiniz.

Sınıfı açıp içindekileri daha yakından incelemek istiyorsanız XmlDocument bakın.

Belge nesne modeline XML yükleme

Koleksiyonda birkaç kitap bulunan bunun gibi bir XML belgesiyle başlayın. Ad alanı, verileri temsil eden öğeler ve verileri açıklayan öznitelikler de dahil olmak üzere herhangi bir XML belgesinde bulabileceğiniz temel öğeleri içerir.

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

Ardından, bellekte çalışabilmek için bu verileri DOM'a yükleyin. Bunu yapmak için en popüler yol, yerel bilgisayarınızdaki veya ağdaki bir dosyaya başvurmaktır.

Bu örnek bir dosyadan XML yükler. Dosya yoksa, yalnızca biraz XML oluşturur ve bunu yükler.

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

Daha fazla bilgi için bkz. DOM'da XML Belgesi Okuma.

Şemaya göre doğrulama

Bunun gibi bir XML şemasıyla başlayın. Bu şema XML'deki veri türlerini ve hangi özniteliklerin gerekli olduğunu tanımlar.

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

Şemanızı kullanarak bir XmlReader nesne oluşturun ve ardından bu nesneyi DOM'a yükleyin. Kod XML dosyanızı şema kurallarını ihlal eden şekillerde değiştirmeye çalıştığında yürütülen bir olay işleyicisi oluşturun.

Bu kod blokları, tüm bunları sağlayan yardımcı yöntemleri gösterir.

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

Daha fazla bilgi için bkz. DOM'da XML Belgesini Doğrulama.

Belge ağacında gezinme

Xml belgesinde gezinmek için özellikleri kullanabilirsiniz. Ancak bunlardan herhangi birini kullanmadan önce birkaç terimi hızla gözden geçirelim. Belgeniz düğümlerden oluşuyor. Her düğümün hemen üzerinde tek bir ebeveyn düğüm vardır. Ebeveyn düğüme sahip olmayan tek düğüm belge köküdür, çünkü en üst düzey düğümdür. Çoğu düğümün alt düğümleri olabilir ve bunlar doğrudan alt düğümlerdir. Aynı düzeydeki düğümler kardeş.

Aşağıdaki örneklerde, kök düğümü elde etme, kök düğümün ilk alt düğümüne atlama, alt düğümlerinden herhangi birine erişme, üst düğüme geri dönme ve ardından eşdüzey düğümler arasında gezinme gösterilmektedir.

Kök düğümle başlayın

Bu örnek, kök düğümü alır ve ardından belgenin içeriğini konsola çıkarmak için bu düğümü kullanır.

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

Çocuk düğümlerini al

Bu örnek, kök düğümün ilk alt düğümüne atlar ve varsa bu düğümün alt düğümleri arasında yinelenir.

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

Üst düğüme geri dönme

ParentNode özelliğini kullanın.

Son alt düğüme bakın

Bu örnek, konsola bir kitabın fiyatını yazar. Fiyat düğümü, bir kitap düğümünün son alt öğesidir.

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

Eşdüzeyler arasında ileri gitme

Bu örnek bir kitaptan diğerine geçer. Kitap düğümleri birbirine kardeştir.

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

Hiyerarşik eşdüzeyler arasında geri gezinme

Bu örnek kitaplar arasında geriye doğru ilerler.

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

Düğümleri bul

Bir veya daha fazla veri düğümü bulmanın en popüler yolu bir XPath sorgu dizesi kullanmaktır, ancak bir sorgu dizesi gerektirmeyen yöntemler de vardır.

Tek düğüm alma

Bu örnek, ISBN numarasını kullanarak bir kitabı bulur.

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

Bu örnekte kullanılan dize bir Xpath sorgusudur. Daha fazla örnek için bkz. XPath örnekleri.

GetElementById düğümleri almak için de kullanabilirsiniz. Bu yaklaşımı kullanmak için, XML dosyanızın belge türü tanım bildirimlerinde kimlikleri tanımlamanız gerekir.

Düğüm aldıktan sonra özniteliklerin veya alt düğümlerin değerine erişirsiniz. Bu örnek bunu bir kitap düğümü aracılığıyla yapar.

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

Düğümleri topla

Bu örnek, yazarın soyadının Austen olduğu tüm kitapları seçer ve sonra bu kitapların fiyatını değiştirir.

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

Ayrıca düğümün adını kullanarak bir düğüm koleksiyonu da alabilirsiniz. Örneğin, bu örnek tüm kitap başlıklarından oluşan bir koleksiyon alır.

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

Daha fazla bilgi için bkz. XPath Gezintisini Kullanarak Düğümleri Seçme.

Düğümleri düzenle

Bu örnek, bir kitap öğesini ve özniteliklerini düzenler.

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

Daha fazla bilgi için bkz. XML Belgesinde Düğümleri, İçeriği ve Değerleri Değiştirme.

Düğümler ekle

Düğüm eklemek için CreateElement yöntemini veya CreateNode yöntemini kullanın.

Bir kitap gibi veri düğümü eklemek için CreateElement yöntemini kullanın.

Açıklama, boşluk düğümü veya CDATA düğümü gibi diğer düğüm türleri için CreateNode yöntemini kullanın.

Bu örnek bir kitap düğümü oluşturur, bu düğüme öznitelikler ekler ve sonra bu düğümü belgeye ekler.

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

Daha fazla bilgi için bkz. XML Belgesine Düğüm Ekleme.

Düğümleri kaldırma

Bir düğümü kaldırmak için yöntemini kullanın RemoveChild .

Bu örnek, belgeden bir kitabı ve kitap düğümünün hemen önünde bulunan boşlukları kaldırır.

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

Daha fazla bilgi için bkz. XML Belgesinden Düğümleri, İçeriği ve Değerleri Kaldırma.

Konum düğümleri

ve InsertBefore yöntemlerini kullanarak belgenizde bir düğümün InsertAfter nerede görünmesini istediğinizi seçebilirsiniz.

Bu örnekte iki yardımcı yöntem gösterilmektedir. Bunlardan biri, bir düğümü listede daha yukarı taşır. Diğeri bir düğümü daha aşağı taşır.

Bu yöntemler, kullanıcıların kitapları bir kitap listesinde yukarı ve aşağı taşımasını sağlayan bir uygulamada kullanılabilir. Kullanıcı bir kitabı seçip yukarı veya aşağı düğmesine bastığında kodunuz, ilgili kitap düğümünü diğer kitap düğümlerinden önce veya sonra konumlandırmak için aşağıdaki gibi yöntemleri çağırabilir.

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

Oluşturucular

Name	Description
XmlDocument()	XmlDocument sınıfının yeni bir örneğini başlatır.
XmlDocument(XmlImplementation)	belirtilen XmlDocumentile sınıfının yeni bir örneğini XmlImplementation başlatır.
XmlDocument(XmlNameTable)	belirtilen XmlDocumentile sınıfının yeni bir örneğini XmlNameTable başlatır.

Özellikler

Name	Description
Attributes	Bu düğümün özniteliklerini içeren bir XmlAttributeCollection alır. (Devralındığı yer: XmlNode)
BaseURI	Geçerli düğümün temel URI'sini alır.
ChildNodes	Düğümün tüm alt düğümlerini alır. (Devralındığı yer: XmlNode)
DocumentElement	Belgenin kökünü XmlElement alır.
DocumentType	DOCTYPE bildirimini içeren düğümü alır.
FirstChild	Düğümün ilk alt öğesini alır. (Devralındığı yer: XmlNode)
HasChildNodes	Bu düğümün alt düğümleri olup olmadığını belirten bir değer alır. (Devralındığı yer: XmlNode)
Implementation	XmlImplementation Geçerli belgenin nesnesini alır.
InnerText	Her durumda bir InvalidOperationException atar.
InnerXml	Geçerli düğümün alt öğelerini temsil eden işaretlemeyi alır veya ayarlar.
IsReadOnly	Geçerli düğümün salt okunur olup olmadığını belirten bir değer alır.
Item[String, String]	belirtilen LocalName ve NamespaceURIile ilk alt öğeyi alır. (Devralındığı yer: XmlNode)
Item[String]	Belirtilen Nameile ilk alt öğeyi alır. (Devralındığı yer: XmlNode)
LastChild	Düğümün son alt öğesini alır. (Devralındığı yer: XmlNode)
LocalName	Düğümün yerel adını alır.
Name	Düğümün tam adını alır.
NamespaceURI	Bu düğümün ad alanı URI'sini alır. (Devralındığı yer: XmlNode)
NameTable	Bu uygulamayla ilişkili alır XmlNameTable .
NextSibling	Düğümü bu düğümün hemen ardından alır. (Devralındığı yer: XmlNode)
NodeType	Geçerli düğümün türünü alır.
OuterXml	Bu düğümü ve tüm alt düğümlerini içeren işaretlemeyi alır. (Devralındığı yer: XmlNode)
OwnerDocument	XmlDocument Geçerli düğümün ait olduğu değeri alır.
ParentNode	Bu düğümün üst düğümünü alır (üst öğeye sahip olabilecek düğümler için).
Prefix	Bu düğümün ad alanı ön ekini alır veya ayarlar. (Devralındığı yer: XmlNode)
PreserveWhitespace	Öğe içeriğinde boşluk korunup korunmayacağını belirten bir değer alır veya ayarlar.
PreviousSibling	Bu düğümün hemen önündeki düğümü alır. (Devralındığı yer: XmlNode)
PreviousText	Bu düğümün hemen önündeki metin düğümünü alır. (Devralındığı yer: XmlNode)
SchemaInfo	Düğümün Şema SonrasıValidation-Infoset (PSVI) döndürür.
Schemas	Bu XmlSchemaSetile ilişkili nesneyi alır veya ayarlarXmlDocument.
Value	Düğümün değerini alır veya ayarlar. (Devralındığı yer: XmlNode)
XmlResolver	dış kaynakları çözümlemek için kullanılacak öğesini XmlResolver ayarlar.

Yöntemler

Name	Description
AppendChild(XmlNode)	Belirtilen düğümü bu düğümün alt düğüm listesinin sonuna ekler. (Devralındığı yer: XmlNode)
Clone()	Bu düğümün bir kopyasını oluşturur. (Devralındığı yer: XmlNode)
CloneNode(Boolean)	Bu düğümün bir kopyasını oluşturur.
CreateAttribute(String, String, String)	Belirtilen XmlAttribute, Prefixve LocalNameile bir NamespaceURI oluşturur.
CreateAttribute(String, String)	Belirtilen nitelenmiş ad ve XmlAttributeile bir NamespaceURI oluşturur.
CreateAttribute(String)	Belirtilen XmlAttributeile bir Name oluşturur.
CreateCDataSection(String)	Belirtilen verileri içeren bir XmlCDataSection oluşturur.
CreateComment(String)	Belirtilen verileri içeren bir XmlComment oluşturur.
CreateDefaultAttribute(String, String, String)	Belirtilen ön ek, yerel ad ve ad alanı URI'siyle varsayılan bir öznitelik oluşturur.
CreateDocumentFragment()	bir XmlDocumentFragmentoluşturur.
CreateDocumentType(String, String, String, String)	Yeni XmlDocumentType bir nesne döndürür.
CreateElement(String, String, String)	Belirtilen Prefix, LocalNameve NamespaceURIile bir öğe oluşturur.
CreateElement(String, String)	ve XmlElementnitelenmiş adıyla bir NamespaceURI oluşturur.
CreateElement(String)	Belirtilen ada sahip bir öğe oluşturur.
CreateEntityReference(String)	Belirtilen ada sahip bir XmlEntityReference oluşturur.
CreateNavigator()	Bu belgede gezinmek için yeni XPathNavigator bir nesne oluşturur.
CreateNavigator(XmlNode)	Belirtilen konuma yerleştirilmiş bu belgede gezinmek XPathNavigator için bir XmlNode nesne oluşturur.
CreateNode(String, String, String)	Belirtilen düğüm türü olan , XmlNodeve Nameile bir NamespaceURI oluşturur.
CreateNode(XmlNodeType, String, String, String)	Belirtilen XmlNode, , XmlNodeTypePrefixve Nameile bir NamespaceURI oluşturur.
CreateNode(XmlNodeType, String, String)	Belirtilen XmlNode, XmlNodeTypeve Nameile bir NamespaceURI oluşturur.
CreateProcessingInstruction(String, String)	Belirtilen ad ve verilere sahip bir XmlProcessingInstruction oluşturur.
CreateSignificantWhitespace(String)	Bir XmlSignificantWhitespace düğüm oluşturur.
CreateTextNode(String)	Belirtilen metinle bir XmlText oluşturur.
CreateWhitespace(String)	Bir XmlWhitespace düğüm oluşturur.
CreateXmlDeclaration(String, String, String)	Belirtilen değerlerle bir XmlDeclaration düğüm oluşturur.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetElementById(String)	XmlElement Belirtilen kimlikle alır.
GetElementsByTagName(String, String)	Belirtilen XmlNodeList ve LocalNameile eşleşen tüm alt öğelerin listesini içeren bir NamespaceURI liste döndürür.
GetElementsByTagName(String)	Belirtilen XmlNodeListile eşleşen tüm alt öğelerin listesini içeren bir Name döndürür.
GetEnumerator()	Geçerli düğümdeki alt düğümler arasında yineleyen bir numaralandırıcı alır. (Devralındığı yer: XmlNode)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetNamespaceOfPrefix(String)	Geçerli düğüm kapsamındaki belirtilen ön ek için en yakın xmlns bildirimini arar ve bildirimdeki ad alanı URI'sini döndürür. (Devralındığı yer: XmlNode)
GetPrefixOfNamespace(String)	Geçerli düğümün kapsamındaki verilen ad alanı URI'sinin en yakın xmlns bildirimini arar ve bu bildirimde tanımlanan ön eki döndürür. (Devralındığı yer: XmlNode)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
ImportNode(XmlNode, Boolean)	Bir düğümü başka bir belgeden geçerli belgeye aktarır.
InsertAfter(XmlNode, XmlNode)	Belirtilen düğümü belirtilen başvuru düğümünden hemen sonra ekler. (Devralındığı yer: XmlNode)
InsertBefore(XmlNode, XmlNode)	Belirtilen düğümü belirtilen başvuru düğümünden hemen önce ekler. (Devralındığı yer: XmlNode)
Load(Stream)	Belirtilen akıştan XML belgesini yükler.
Load(String)	Belirtilen URL'den XML belgesini yükler.
Load(TextReader)	Belirtilen TextReaderöğesinden XML belgesini yükler.
Load(XmlReader)	Belirtilen XmlReaderöğesinden XML belgesini yükler.
LoadXml(String)	Belirtilen dizeden XML belgesini yükler.
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
Normalize()	Tüm XmlText düğümlerini bu XmlNode'un altındaki alt ağacın tam derinliğine, yalnızca işaretlemenin (etiketler, açıklamalar, işleme yönergeleri, CDATA bölümleri ve varlık başvuruları) XmlText düğümlerini ayırdığı, yani bitişik XmlText düğümlerinin olmadığı bir "normal" forma yerleştirir. (Devralındığı yer: XmlNode)
PrependChild(XmlNode)	Belirtilen düğümü, bu düğüm için alt düğüm listesinin başına ekler. (Devralındığı yer: XmlNode)
ReadNode(XmlReader)	içindeki XmlNodebilgileri temel alan bir XmlReader nesne oluşturur. Okuyucu bir düğüme veya özniteliğe konumlandırılmalıdır.
RemoveAll()	Geçerli düğümün tüm alt düğümlerini ve/veya özniteliklerini kaldırır. (Devralındığı yer: XmlNode)
RemoveChild(XmlNode)	Belirtilen alt düğümü kaldırır. (Devralındığı yer: XmlNode)
ReplaceChild(XmlNode, XmlNode)	Alt düğümü düğümle oldChildnewChild değiştirir. (Devralındığı yer: XmlNode)
Save(Stream)	XML belgesini belirtilen akışa kaydeder.
Save(String)	XML belgesini belirtilen dosyaya kaydeder. Belirtilen dosya varsa, bu yöntem dosyanın üzerine yazar.
Save(TextWriter)	XML belgesini belirtilen TextWriteröğesine kaydeder.
Save(XmlWriter)	XML belgesini belirtilen XmlWriteröğesine kaydeder.
SelectNodes(String, XmlNamespaceManager)	XPath ifadesiyle eşleşen düğümlerin listesini seçer. XPath ifadesinde bulunan tüm ön ekler sağlanan XmlNamespaceManagerkullanılarak çözümlenir. (Devralındığı yer: XmlNode)
SelectNodes(String)	XPath ifadesiyle eşleşen düğümlerin listesini seçer. (Devralındığı yer: XmlNode)
SelectSingleNode(String, XmlNamespaceManager)	XPath ifadesiyle eşleşen ilk XmlNode ifadeyi seçer. XPath ifadesinde bulunan tüm ön ekler sağlanan XmlNamespaceManagerkullanılarak çözümlenir. (Devralındığı yer: XmlNode)
SelectSingleNode(String)	XPath ifadesiyle eşleşen ilk XmlNode ifadeyi seçer. (Devralındığı yer: XmlNode)
Supports(String, String)	DOM uygulamasının belirli bir özelliği uygulayarak gerçekleştirmediğini test eder. (Devralındığı yer: XmlNode)
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
Validate(ValidationEventHandler, XmlNode)	Özelliğindeki XmlNode XML Şema Tanım Dili (XSD) şemalarında belirtilen nesneyi doğrular Schemas .
Validate(ValidationEventHandler)	XmlDocument özelliğinin içerdiği Schemas XML Şema Tanım Dili (XSD) şemalarına göre öğesini doğrular.
WriteContentTo(XmlWriter)	Düğümün tüm alt öğelerini XmlDocument belirtilen XmlWriteröğesine kaydeder.
WriteTo(XmlWriter)	XmlDocument Düğümü belirtilen XmlWriteröğesine kaydeder.

Ekinlikler

Name	Description
NodeChanged	Bu belgeye ait bir düğümün değiştirildiğinde Value gerçekleşir.
NodeChanging	Bu belgeye ait bir düğümün değiştirilmek üzere olduğunda Value gerçekleşir.
NodeInserted	Bu belgeye ait bir düğüm başka bir düğüme eklendiğinde gerçekleşir.
NodeInserting	Bu belgeye ait bir düğüm başka bir düğüme eklemek üzere olduğunda gerçekleşir.
NodeRemoved	Bu belgeye ait bir düğüm üst öğesinden kaldırıldığında gerçekleşir.
NodeRemoving	Bu belgeye ait bir düğüm belgeden kaldırılacakken gerçekleşir.

Belirtik Arabirim Kullanımları

Name	Description
ICloneable.Clone()	Bu üyenin açıklaması için bkz Clone(). . (Devralındığı yer: XmlNode)
IEnumerable.GetEnumerator()	Bu üyenin açıklaması için bkz GetEnumerator(). . (Devralındığı yer: XmlNode)

Uzantı Metotları

Name	Description
AsParallel(IEnumerable)	Sorgunun paralelleştirilmesini etkinleştirir.
AsQueryable(IEnumerable)	bir IEnumerable öğesine IQueryabledönüştürür.
Cast<TResult>(IEnumerable)	öğesinin IEnumerable öğelerini belirtilen türe yazar.
OfType<TResult>(IEnumerable)	Belirtilen türe göre bir IEnumerable öğesinin öğelerini filtreler.

Ayrıca bkz.

• XmlNodeChangedEventHandler