XmlDocument Osztály

Definíció

Névtér:

System.Xml

Szerelvények:

netstandard.dll, System.Xml.ReaderWriter.dll

Forrás:

XmlDocument.cs

XML-dokumentumot jelöl. Ezzel az osztálysal betöltheti, érvényesítheti, szerkesztheti, hozzáadhatja és elhelyezheti az XML-fájlokat egy dokumentumban.

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

public class XmlDocument : System.Xml.XmlNode

type XmlDocument = class
    inherit XmlNode

Public Class XmlDocument
Inherits XmlNode

Öröklődés

Object

XmlNode

XmlDocument

Származtatott

System.Configuration.ConfigXmlDocument

System.Xml.XmlDataDocument

Megjegyzések

Az XmlDocument osztály egy XML-dokumentum memórián belüli ábrázolása. Implementálja a W3C XML Document Object Model (DOM) Level 1 Core és a Core DOM Level 2 szintet.

A DOM a dokumentumobjektum-modell-ben rejlik. Erről további információt az XML-dokumentumobjektum-modell (DOM) című témakörben talál.

Az XML-fájlokat az osztály használatával töltheti be a XmlDocument DOM-ba, majd programozott módon olvashatja, módosíthatja és eltávolíthatja az XML-t a dokumentumban.

Ha meg szeretné nyitni az osztályt XmlDocument , és látni szeretné annak implementálását, tekintse meg a referenciaforrást.

XML betöltése a dokumentumobjektum-modellbe

Kezdje egy ehhez hasonló XML-dokumentummal, amely egy gyűjtemény néhány könyvével rendelkezik. Tartalmazza azokat az alapvető dolgokat, amelyeket bármely XML-dokumentumban megtalálhat, beleértve a névteret, az adatokat képviselő elemeket és az adatokat leíró attribútumokat.

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

Ezután töltse be ezeket az adatokat a DOM-ba, hogy a memóriában is működjön. Ennek legnépszerűbb módja, ha a helyi számítógépen vagy egy hálózaton található fájlra hivatkozik.

Ez a példa betölti az XML-t egy fájlból. Ha a fájl nem létezik, csak létrehoz néhány XML-fájlt, és betölti azt.

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

További információ: XML-dokumentum beolvasása a DOM-ba.

Érvényesítse a sémával szemben

Kezdje az alábbihoz hasonló XML-sémával. Ez a séma határozza meg az XML adattípusait, és hogy mely attribútumokra van szükség.

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

Hozzon létre egy XmlReader objektumot a sémával, majd töltse be az objektumot a DOM-ba. Hozzon létre egy eseménykezelőt, amely akkor fut, amikor a kód olyan módon próbálja módosítani az XML-fájlt, hogy az megsértse a séma szabályait.

Ezek a kódblokkok olyan segítő metódusokat mutatnak, amelyek mindezt elvégezik.

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

További információ: XML-dokumentum érvényesítése a DOM-ban.

Navigálás a dokumentumfán

Tulajdonságok használatával navigálhat az XML-dokumentumok között. De mielőtt bármelyiket használjuk, tekintsünk át gyorsan néhány kifejezést. A dokumentum csomópontokból áll. Minden csomópont felett egyetlen szülőcsomópont található. Az egyetlen csomópont, amely nem rendelkezik szülőcsomópontokkal, a dokumentumgyökér, mivel ez a legfelső szintű csomópont. A legtöbb csomópont rendelkezhet gyermekcsomópontokkal, amelyek közvetlenül alattuk lévő csomópontok. Az azonos szintű csomópontok testvérek.

Az alábbi példák bemutatják, hogyan szerezheti be a gyökércsomópontot, hogyan ugorhat a gyökércsomópont első gyermekcsomópontjára, hogyan férhet hozzá bármelyik gyermekcsomóponthoz, hogyan léphet vissza a szülőcsomópontra, majd navigálhat a testvércsomópontok között.

Kezdés a gyökércsomóponttal

Ez a példa lekéri a gyökércsomópontot, majd a csomópont használatával adja ki a dokumentum tartalmát a konzolnak.

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

Gyermekcsomópontok lekérése

Ez a példa a gyökércsomópont első gyermekcsomópontjára ugrik, majd az adott csomópont gyermekcsomópontjai között halad át, ha vannak ilyenek.

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

Visszalépés a szülőcsomópontra

Használja a ParentNode tulajdonságot.

Hivatkozzon az utolsó gyermekcsomópontra

Ez a példa egy könyv árát írja a konzolra. Az árcsomópont egy könyvcsomópont utolsó gyermeke.

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

Előre navigálás a testvérek között

Ez a példa könyvről könyvre halad előre. A könyvcsomópontok egymás testvérei.

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

Navigálás hátrafelé a testvérek között

Ez a példa visszafelé halad könyvről könyvre.

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

Csomópontok keresése

Egy vagy több adatcsomópont megkeresésének legnépszerűbb módja egy XPath-lekérdezési sztring használata, de vannak olyan metódusok is, amelyekhez nincs szükség ilyenre.

Egyetlen csomópont lekérése

Ez a példa az ISBN-számmal keres egy könyvet.

public XmlNode GetBook(string uniqueAttribute, XmlDocument doc)
{
    XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books");
    string xPathString = "//bk:books/bk:book[@ISBN='" + uniqueAttribute + "']";
    XmlNode xmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr);
   return xmlNode;
}

Public Function GetBook(ByVal uniqueAttribute As String, ByVal doc As XmlDocument) As XmlNode
    Dim nsmgr As XmlNamespaceManager = New XmlNamespaceManager(doc.NameTable)
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books")
    Dim xPathString As String = ("//bk:books/bk:book[@ISBN='" _
                & (uniqueAttribute & "']"))
    Dim xmlNode As XmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr)
    Return xmlNode
End Function

A példában használt sztring egy Xpath-lekérdezés. Az XPath-példákban további példákat találhat rájuk.

A csomópontok lekérésére is használható GetElementById . Ennek a módszernek a használatához meg kell határoznia az azonosítókat az XML-fájl dokumentumtípusdefiníciós deklarációiban.

A csomópont lekérése után megkapja az attribútumok vagy a gyermekcsomópontok értékét. Ez a példa ezt egy könyvcsomóponttal teszi.

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

Csomópontok gyűjteményének lekérése

Ez a példa kijelöli az összes könyvet, ahol a szerző vezetékneve Austen, majd módosítja a könyvek árát.

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

A csomópontok gyűjteményét a csomópont nevével is lekérheti. Ez a példa például az összes könyvcím gyűjteményét kapja.

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

További információ: Csomópontok kiválasztása XPath-navigációval.

Csomópontok szerkesztése

Ez a példa szerkeszt egy könyvcsomópontot és annak attribútumait.

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

További információ: Csomópontok, tartalom és értékek módosítása XML-dokumentumban.

Csomópontok hozzáadása

Csomópont hozzáadásához használja a CreateElement metódust vagy a metódust CreateNode .

Adatcsomópont, például könyv hozzáadásához használja a metódust CreateElement .

Bármilyen más típusú csomóponthoz, például megjegyzéshez, térbeli csomóponthoz vagy CDATA-csomóponthoz használja a metódust CreateNode .

Ez a példa létrehoz egy könyvcsomópontot, attribútumokat ad hozzá a csomóponthoz, majd hozzáadja a csomópontot a dokumentumhoz.

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

További információ: Csomópontok beszúrása XML-dokumentumba.

Csomópontok eltávolítása

Csomópont eltávolításához használja a metódust RemoveChild .

Ez a példa eltávolít egy könyvet a dokumentumból, valamint a könyvcsomópont előtt megjelenő szóközöket.

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

További információ: Csomópontok, tartalom és értékek eltávolítása XML-dokumentumból.

Csomópontok pozicionálása

A InsertBefore és InsertAfter metódusok segítségével megadhatja, hogy a csomópont hol jelenjen meg a dokumentumban.

Ez a példa két segédmetelyt mutat be. Az egyik egy csomópontot feljebb helyez egy listában. A másik egy csomópontot lejjebb helyez.

Ezek a módszerek olyan alkalmazásokban használhatók, amelyek lehetővé teszik a felhasználók számára a könyvek felfelé és lefelé mozgatását a könyvek listájában. Ha egy felhasználó kiválaszt egy könyvet, és lenyom egy fel- vagy le gombot, a kód meghívhat ilyen metódusokat, hogy a megfelelő könyvcsomópontot más könyvcsomópontok előtt vagy után helyezze el.

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

Konstruktorok

Name	Description
XmlDocument()	Inicializálja a XmlDocument osztály új példányát.
XmlDocument(XmlImplementation)	Inicializálja az osztály új példányát XmlDocument a megadott XmlImplementation.
XmlDocument(XmlNameTable)	Inicializálja az osztály új példányát XmlDocument a megadott XmlNameTable.

Tulajdonságok

Name	Description
Attributes	XmlAttributeCollection Lekéri a csomópont attribútumait. (Öröklődés forrása XmlNode)
BaseURI	Lekéri az aktuális csomópont alap URI-ját.
ChildNodes	Lekéri a csomópont összes gyermekcsomópontját. (Öröklődés forrása XmlNode)
DocumentElement	Lekéri a dokumentum gyökerét XmlElement .
DocumentType	Lekéri a DOCTYPE deklarációt tartalmazó csomópontot.
FirstChild	Lekéri a csomópont első gyermekét. (Öröklődés forrása XmlNode)
HasChildNodes	Beolvas egy értéket, amely jelzi, hogy a csomópont rendelkezik-e gyermekcsomópontokkal. (Öröklődés forrása XmlNode)
Implementation	Lekéri az XmlImplementation aktuális dokumentum objektumát.
InnerText	Minden esetben bedob egy-egy InvalidOperationException esetet.
InnerXml	Lekéri vagy beállítja az aktuális csomópont gyermekeit ábrázoló korrektúrát.
IsReadOnly	Egy értéket kap, amely jelzi, hogy az aktuális csomópont írásvédett-e.
Item[String, String]	Lekéri az első gyermekelemet a megadott LocalName és NamespaceURIa . (Öröklődés forrása XmlNode)
Item[String]	Lekéri az első gyermekelemet a megadott Name. (Öröklődés forrása XmlNode)
LastChild	Lekéri a csomópont utolsó gyermekét. (Öröklődés forrása XmlNode)
LocalName	Lekéri a csomópont helyi nevét.
Name	Lekéri a csomópont minősített nevét.
NamespaceURI	Lekéri a csomópont névterének URI-ját. (Öröklődés forrása XmlNode)
NameTable	Lekéri az XmlNameTable implementációhoz társítottat.
NextSibling	Azonnal lekéri a csomópontot a csomópont után. (Öröklődés forrása XmlNode)
NodeType	Lekéri az aktuális csomópont típusát.
OuterXml	Lekéri a csomópontot és annak összes gyermekcsomópontját tartalmazó korrektúrát. (Öröklődés forrása XmlNode)
OwnerDocument	Lekéri az XmlDocument aktuális csomópontot.
ParentNode	Lekéri ennek a csomópontnak a szülőcsomópontját (a szülővel rendelkező csomópontokhoz).
Prefix	Lekéri vagy beállítja a csomópont névtérelőtagját. (Öröklődés forrása XmlNode)
PreserveWhitespace	Lekéri vagy beállít egy értéket, amely jelzi, hogy meg szeretné-e őrizni a szabad helyet az elemtartalomban.
PreviousSibling	Lekéri a csomópontot közvetlenül megelőző csomópontot. (Öröklődés forrása XmlNode)
PreviousText	Lekéri a csomópontot közvetlenül megelőző szövegcsomópontot. (Öröklődés forrása XmlNode)
SchemaInfo	A csomópont séma utániValidation-Infoset (PSVI) értékét adja vissza.
Schemas	Lekéri vagy beállítja a XmlSchemaSet hozzá társított XmlDocumentobjektumot.
Value	Lekéri vagy beállítja a csomópont értékét. (Öröklődés forrása XmlNode)
XmlResolver	Beállítja a XmlResolver külső erőforrások feloldásához használni kívánt elemet.

Metódusok

Name	Description
AppendChild(XmlNode)	Hozzáadja a megadott csomópontot a csomópont gyermekcsomópontjai listájának végéhez. (Öröklődés forrása XmlNode)
Clone()	Létrehoz egy másolatot erről a csomópontról. (Öröklődés forrása XmlNode)
CloneNode(Boolean)	Létrehoz egy másolatot erről a csomópontról.
CreateAttribute(String, String, String)	Létrehoz egy adott XmlAttributePrefix, LocalNameés NamespaceURI.
CreateAttribute(String, String)	Létrehoz egy XmlAttribute megadott minősített nevet és NamespaceURI.
CreateAttribute(String)	Létrehoz egy adott XmlAttribute .Name
CreateCDataSection(String)	Létrehoz egy XmlCDataSection , a megadott adatokat tartalmazót.
CreateComment(String)	Létrehoz egy XmlComment , a megadott adatokat tartalmazót.
CreateDefaultAttribute(String, String, String)	Létrehoz egy alapértelmezett attribútumot a megadott előtaggal, helyi névvel és névtér URI-val.
CreateDocumentFragment()	Létrehoz egy XmlDocumentFragment.
CreateDocumentType(String, String, String, String)	Új XmlDocumentType objektumot ad vissza.
CreateElement(String, String, String)	Létrehoz egy elemet a megadott Prefix, LocalNameés NamespaceURI.
CreateElement(String, String)	Létrehoz egy XmlElement minősített nevet és NamespaceURI.
CreateElement(String)	Létrehoz egy elemet a megadott névvel.
CreateEntityReference(String)	Létrehoz egy XmlEntityReference megadott névvel rendelkezőt.
CreateNavigator()	Létrehoz egy új XPathNavigator objektumot a dokumentum navigálásához.
CreateNavigator(XmlNode)	Létrehoz egy XPathNavigator objektumot a dokumentumnak a megadott helyen való navigálásához XmlNode .
CreateNode(String, String, String)	Létrehoz egy XmlNode megadott csomóponttípust, Nameés NamespaceURI.
CreateNode(XmlNodeType, String, String, String)	Létrehoz egy XmlNode adott XmlNodeType, Prefix, Nameés NamespaceURI.
CreateNode(XmlNodeType, String, String)	Létrehoz egy adott XmlNodeXmlNodeType, Nameés NamespaceURI.
CreateProcessingInstruction(String, String)	Létrehoz egy XmlProcessingInstruction megadott névvel és adatokkal rendelkezőt.
CreateSignificantWhitespace(String)	Létrehoz egy csomópontot XmlSignificantWhitespace .
CreateTextNode(String)	Létrehoz egy XmlText adott szöveggel rendelkezőt.
CreateWhitespace(String)	Létrehoz egy csomópontot XmlWhitespace .
CreateXmlDeclaration(String, String, String)	Létrehoz egy csomópontot XmlDeclaration a megadott értékekkel.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetElementById(String)	Lekéri a XmlElement megadott azonosítót.
GetElementsByTagName(String, String)	XmlNodeList A megadott LocalName és NamespaceURIa .
GetElementsByTagName(String)	XmlNodeList A megadottnak megfelelő összes leszármazott elemet tartalmazó listát ad Namevissza.
GetEnumerator()	Lekéri az aktuális csomópont gyermekcsomópontjai között iteráló enumerátort. (Öröklődés forrása XmlNode)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetNamespaceOfPrefix(String)	Megkeresi a legközelebbi xmlns-deklarációt az aktuális csomópont hatókörében lévő adott előtaghoz, és visszaadja a névtér URI-jának értékét a deklarációban. (Öröklődés forrása XmlNode)
GetPrefixOfNamespace(String)	Megkeresi a megadott névtér URI-jának legközelebbi xmlns-deklarációt, amely az aktuális csomópont hatókörében van, és visszaadja a deklarációban definiált előtagot. (Öröklődés forrása XmlNode)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
ImportNode(XmlNode, Boolean)	Csomópont importálása egy másik dokumentumból az aktuális dokumentumba.
InsertAfter(XmlNode, XmlNode)	A megadott csomópontot közvetlenül a megadott referenciacsomópont után szúrja be. (Öröklődés forrása XmlNode)
InsertBefore(XmlNode, XmlNode)	Közvetlenül a megadott referenciacsomópont elé szúrja be a megadott csomópontot. (Öröklődés forrása XmlNode)
Load(Stream)	Betölti az XML-dokumentumot a megadott adatfolyamból.
Load(String)	Betölti az XML-dokumentumot a megadott URL-címről.
Load(TextReader)	Betölti az XML-dokumentumot a megadottból TextReader.
Load(XmlReader)	Betölti az XML-dokumentumot a megadottból XmlReader.
LoadXml(String)	Betölti az XML-dokumentumot a megadott sztringből.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Normalize()	Az XmlNode alatti alfa teljes mélységébe helyezi az összes XmlText-csomópontot egy "normál" űrlapra, ahol csak a korrektúra (címkék, megjegyzések, feldolgozási utasítások, CDATA-szakaszok és entitáshivatkozások) választja el az XmlText-csomópontokat, vagyis nincsenek szomszédos XmlText-csomópontok. (Öröklődés forrása XmlNode)
PrependChild(XmlNode)	Hozzáadja a megadott csomópontot a csomóponthoz tartozó gyermekcsomópontok listájának elejére. (Öröklődés forrása XmlNode)
ReadNode(XmlReader)	Létrehoz egy XmlNode objektumot a XmlReader. Az olvasót csomóponton vagy attribútumon kell elhelyezni.
RemoveAll()	Eltávolítja az aktuális csomópont összes gyermekcsomópontját és/vagy attribútumát. (Öröklődés forrása XmlNode)
RemoveChild(XmlNode)	Eltávolítja a megadott gyermekcsomópontot. (Öröklődés forrása XmlNode)
ReplaceChild(XmlNode, XmlNode)	A gyermekcsomópontot oldChild csomópontra newChild cseréli. (Öröklődés forrása XmlNode)
Save(Stream)	Menti az XML-dokumentumot a megadott streambe.
Save(String)	Menti az XML-dokumentumot a megadott fájlba. Ha a megadott fájl létezik, ez a metódus felülírja azt.
Save(TextWriter)	Menti az XML-dokumentumot a megadottba TextWriter.
Save(XmlWriter)	Menti az XML-dokumentumot a megadottba XmlWriter.
SelectNodes(String, XmlNamespaceManager)	Kiválasztja az XPath-kifejezésnek megfelelő csomópontok listáját. Az XPath-kifejezésben található előtagok feloldása a megadott XmlNamespaceManagerparanccsel történik. (Öröklődés forrása XmlNode)
SelectNodes(String)	Kiválasztja az XPath-kifejezésnek megfelelő csomópontok listáját. (Öröklődés forrása XmlNode)
SelectSingleNode(String, XmlNamespaceManager)	Az XPath kifejezésnek megfelelő elsőt XmlNode választja ki. Az XPath-kifejezésben található előtagok feloldása a megadott XmlNamespaceManagerparanccsel történik. (Öröklődés forrása XmlNode)
SelectSingleNode(String)	Az XPath kifejezésnek megfelelő elsőt XmlNode választja ki. (Öröklődés forrása XmlNode)
Supports(String, String)	Teszteli, hogy a DOM-implementáció implementál-e egy adott funkciót. (Öröklődés forrása XmlNode)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
Validate(ValidationEventHandler, XmlNode)	Ellenőrzi a XmlNode tulajdonság XML-sémadefiníciós (XSD) sémáiban Schemas megadott objektumot.
Validate(ValidationEventHandler)	Ellenőrzi a XmlDocument tulajdonságban található XML-sémadefiníciós nyelv (XSD) sémák alapján.Schemas
WriteContentTo(XmlWriter)	Menti a csomópont összes gyermekét XmlDocument a megadottba XmlWriter.
WriteTo(XmlWriter)	A csomópontot a XmlDocument megadott XmlWriterértékre menti.

esemény

Name	Description
NodeChanged	Akkor fordul elő, ha a Value dokumentumhoz tartozó csomópont módosult.
NodeChanging	Akkor fordul elő, ha a Value dokumentumhoz tartozó csomópontot módosítani szeretné.
NodeInserted	Ez akkor fordul elő, ha a dokumentumhoz tartozó csomópontot egy másik csomópontba szúrták be.
NodeInserting	Akkor fordul elő, ha a dokumentumhoz tartozó csomópontot egy másik csomópontba szeretné beszúrni.
NodeRemoved	Akkor fordul elő, ha a dokumentumhoz tartozó csomópontot eltávolították a szülőből.
NodeRemoving	Akkor fordul elő, ha a dokumentumhoz tartozó csomópontot el szeretné távolítani a dokumentumból.

Explicit interfész-implementációk

Name	Description
ICloneable.Clone()	Ennek a tagnak a leírását lásd Clone(): . (Öröklődés forrása XmlNode)
IEnumerable.GetEnumerator()	Ennek a tagnak a leírását lásd GetEnumerator(): . (Öröklődés forrása XmlNode)

Bővítő metódusok

Name	Description
AsParallel(IEnumerable)	Lehetővé teszi a lekérdezés párhuzamosítását.
AsQueryable(IEnumerable)	Átalakítja az egyiket IEnumerableIQueryable.
Cast<TResult>(IEnumerable)	Egy elem elemeit IEnumerable a megadott típusra veti.
OfType<TResult>(IEnumerable)	Egy adott típus alapján szűri IEnumerable egy adott elem elemeit.

Lásd még

• XmlNodeChangedEventHandler