XmlDocument Klasa

Definicja

Przestrzeń nazw:

System.Xml

Zestawy:

netstandard.dll, System.Xml.ReaderWriter.dll

Źródło:

XmlDocument.cs

Reprezentuje dokument XML. Tej klasy można użyć do ładowania, weryfikowania, edytowania, dodawania i umieszczania kodu XML w dokumencie.

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

public class XmlDocument : System.Xml.XmlNode

type XmlDocument = class
    inherit XmlNode

Public Class XmlDocument
Inherits XmlNode

Dziedziczenie

Object

XmlNode

XmlDocument

Pochodne

System.Configuration.ConfigXmlDocument

System.Xml.XmlDataDocument

Uwagi

Klasa XmlDocument jest reprezentacją w pamięci dokumentu XML. Implementuje model obiektowy dokumentów XML W3C (DOM) Poziom 1 Core i Poziom 2 Core DOM.

DOM oznacza model obiektu dokumentu. Aby dowiedzieć się więcej na ten temat, zobacz XML Document Object Model (DOM).

Kod XML można załadować do modelu DOM przy użyciu XmlDocument klasy , a następnie programowo odczytywać, modyfikować i usuwać kod XML w dokumencie.

Jeśli chcesz otworzyć klasę XmlDocument i zobaczyć, jak jest ona zaimplementowana, zobacz Źródło referencyjne.

Ładowanie kodu XML do modelu obiektów dokumentu

Zacznij od dokumentu XML, takiego jak ten, który zawiera kilka książek w kolekcji. Zawiera on podstawowe elementy, które można znaleźć w dowolnym dokumencie XML, w tym przestrzeń nazw, elementy reprezentujące dane i atrybuty opisujące dane.

<?xml version="1.0" encoding="utf-8"?>
<books xmlns="http://www.contoso.com/books">
  <book genre="novel" ISBN="1-861001-57-8" publicationdate="1823-01-28">
    <title>Pride And Prejudice</title>
    <price>24.95</price>
  </book>
  <book genre="novel" ISBN="1-861002-30-1" publicationdate="1985-01-01">
    <title>The Handmaid's Tale</title>
    <price>29.95</price>
  </book>
  <book genre="novel" ISBN="1-861001-45-3" publicationdate="1811-01-01">
    <title>Sense and Sensibility</title>
    <price>19.95</price>
  </book>
</books>

Następnie załaduj te dane do modelu DOM, aby można było z nim pracować w pamięci. Najpopularniejszym sposobem, aby to zrobić, jest odwołanie się do pliku na komputerze lokalnym lub w sieci.

Ten przykład ładuje kod XML z pliku. Jeśli plik nie istnieje, po prostu generuje kod XML i ładuje go.

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

Aby uzyskać więcej informacji, zobacz Odczytywanie dokumentu XML do modelu DOM.

Zweryfikować go względem schematu

Zacznij od schematu XML, takiego jak ten. Ten schemat definiuje typy danych w kodzie XML i wymagane atrybuty.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
  attributeFormDefault="unqualified"
  elementFormDefault="qualified"
  targetNamespace="http://www.contoso.com/books">
  <xs:element name="books">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" name="book">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="title" type="xs:string" />
              <xs:element name="price" type="xs:decimal" />
            </xs:sequence>
            <xs:attribute name="genre" type="xs:string" use="required" />
            <xs:attribute name="ISBN" type="xs:string" use="required" />
            <xs:attribute name="publicationdate" type="xs:date" use="required" />
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

XmlReader Utwórz obiekt przy użyciu schematu, a następnie załaduj ten obiekt do modelu DOM. Utwórz procedurę obsługi zdarzeń, która jest wykonywana, gdy kod próbuje zmodyfikować plik XML w sposób naruszający reguły schematu.

Te bloki kodu pokazują metody pomocnicze, które wykonują wszystkie te czynności.

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

Aby uzyskać więcej informacji, zobacz Weryfikowanie dokumentu XML w modelu DOM.

Nawigowanie po drzewie dokumentów

Właściwości umożliwiają poruszanie się po dokumencie XML. Ale zanim użyjesz któregokolwiek z nich, szybko przejrzyjmy kilka terminów. Dokument składa się z węzłów. Każdy węzeł ma jeden węzeł nadrzędny bezpośrednio nad nim. Jedynym węzłem, który nie ma węzła nadrzędnego, jest węzeł główny dokumentu, ponieważ jest to węzeł szczytowy. Większość węzłów może mieć węzły podrzędne , które są węzłami bezpośrednio poniżej nich. Węzły, które znajdują się na tym samym poziomie, są rodzeństwem.

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

Rozpoczynanie pracy z węzłem głównym

Ten przykład pobiera węzeł główny, a następnie używa tego węzła do wyprowadzania zawartości dokumentu do konsoli.

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

Pobierz węzły podrzędne

Ten przykład przechodzi do pierwszego węzła podrzędnego węzła głównego, a następnie iteruje przez węzły podrzędne tego węzła, jeśli istnieją.

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

Powrót do węzła nadrzędnego

Użyj właściwości ParentNode.

Odwołaj się do ostatniego węzła podrzędnego

W tym przykładzie na konsoli zapisywana jest cena książki. Węzeł cena jest ostatnim elementem węzła książki.

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

Przechodzenie do przodu między elementami równorzędnymi

Ten przykład przenosi się z książki do książki. Węzły książki są ze sobą równorzędne.

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

Nawigacja wstecz przez elementy równorzędne

Ten przykład przenosi się wstecz od książki do książki.

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

Znajdowanie węzłów

Najpopularniejszym sposobem znalezienia jednego lub większej liczby węzłów danych jest użycie ciągu zapytania XPath, ale istnieją również metody, które nie wymagają jednego.

Pobierz pojedynczy węzeł

W tym przykładzie książka jest zlokalizowana za pomocą numeru ISBN.

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

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

Ciąg używany w tym przykładzie to zapytanie Xpath. Więcej przykładów można znaleźć w przykładach XPath.

Można również użyć GetElementById, aby pobrać węzły. Aby użyć tego podejścia, należy zdefiniować identyfikatory w deklaracjach definicji typu dokumentu pliku XML.

Po uzyskaniu węzła uzyskasz wartość atrybutów lub węzłów podrzędnych. Ten przykład robi to przy użyciu węzła książki.

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

Pobierz kolekcję węzłów

W tym przykładzie wybieramy wszystkie książki, w których nazwisko autora to Austen, a następnie zmienia cenę tych książek.

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

Możesz także uzyskać kolekcję węzłów, używając nazwy węzła. Na przykład poniższy przykład uzyskuje kolekcję wszystkich tytułów książek.

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

Aby uzyskać więcej informacji, zobacz Wybieranie węzłów przy użyciu nawigacji XPath.

Edytowanie węzłów

W tym przykładzie edytowany jest węzeł książki i jego atrybuty.

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

Aby uzyskać więcej informacji, zobacz Modyfikowanie węzłów, zawartości i wartości w dokumencie XML.

Dodawanie węzłów

Aby dodać węzeł, użyj CreateElement metody lub CreateNode metody .

Aby dodać węzeł danych, taki jak książka, użyj CreateElement metody .

W przypadku innego typu węzła, takiego jak komentarz, węzeł spacji lub węzeł CDATA, użyj metody CreateNode.

W tym przykładzie tworzony jest węzeł książki, dodawane są atrybuty do tego węzła, a następnie wspomniany węzeł dodawany jest do dokumentu.

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

Aby uzyskać więcej informacji, zobacz Wstawianie węzłów do dokumentu XML.

Usuń węzły

Aby usunąć węzeł, użyj RemoveChild metody .

W tym przykładzie usunięto książkę z dokumentu i wszelkie białe znaki wyświetlane tuż przed węzłem książki.

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

Aby uzyskać więcej informacji, zobacz Usuwanie węzłów, zawartości i wartości z dokumentu XML.

Położenie węzłów

Możesz wybrać miejsce, w którym węzeł ma być umieszczony w dokumencie przy użyciu metod InsertBefore i InsertAfter.

W tym przykładzie przedstawiono dwie metody pomocnicze. Jeden z nich przesuwa węzeł wyżej na liście. Drugi przesuwa węzeł w dół.

Te metody mogą być używane w aplikacji, która umożliwia użytkownikom przenoszenie książek w górę i w dół na liście książek. Gdy użytkownik wybierze książkę i naciśnie przycisk w górę lub w dół, kod może wywołać metody takie jak te, aby umieścić odpowiedni węzeł książki przed lub po innych węzłach książki.

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

Konstruktory

Nazwa	Opis
XmlDocument()	Inicjuje nowe wystąpienie klasy XmlDocument.
XmlDocument(XmlImplementation)	Inicjuje nowe wystąpienie klasy XmlDocument z określonym XmlImplementation.
XmlDocument(XmlNameTable)	Inicjuje nowe wystąpienie klasy XmlDocument z określonym XmlNameTable.

Właściwości

Nazwa	Opis
Attributes	Pobiera element XmlAttributeCollection zawierający atrybuty tego węzła. (Odziedziczone po XmlNode)
BaseURI	Pobiera podstawowy identyfikator URI bieżącego węzła.
ChildNodes	Pobiera wszystkie węzły podrzędne węzła. (Odziedziczone po XmlNode)
DocumentElement	Pobiera katalog główny XmlElement dokumentu.
DocumentType	Pobiera węzeł zawierający deklarację DOCTYPE.
FirstChild	Pobiera pierwszy element podrzędny węzła. (Odziedziczone po XmlNode)
HasChildNodes	Pobiera wartość wskazującą, czy ten węzeł ma jakiekolwiek węzły podrzędne. (Odziedziczone po XmlNode)
Implementation	XmlImplementation Pobiera obiekt dla bieżącego dokumentu.
InnerText	Zgłasza wartość InvalidOperationException we wszystkich przypadkach.
InnerXml	Pobiera lub ustawia znacznik reprezentujący elementy podrzędne bieżącego węzła.
IsReadOnly	Pobiera wartość wskazującą, czy bieżący węzeł jest tylko do odczytu.
Item[String, String]	Pobiera pierwszy element podrzędny z określonymi LocalName elementami i NamespaceURI. (Odziedziczone po XmlNode)
Item[String]	Pobiera pierwszy element podrzędny z określonym Nameelementem . (Odziedziczone po XmlNode)
LastChild	Pobiera ostatnie podrzędne węzła. (Odziedziczone po XmlNode)
LocalName	Pobiera lokalną nazwę węzła.
Name	Pobiera kwalifikowaną nazwę węzła.
NamespaceURI	Pobiera identyfikator URI przestrzeni nazw tego węzła. (Odziedziczone po XmlNode)
NameTable	XmlNameTable Pobiera element skojarzony z tą implementacją.
NextSibling	Pobiera węzeł bezpośrednio po tym węźle. (Odziedziczone po XmlNode)
NodeType	Pobiera typ bieżącego węzła.
OuterXml	Pobiera znacznik zawierający ten węzeł i wszystkie węzły podrzędne. (Odziedziczone po XmlNode)
OwnerDocument	Pobiera element, XmlDocument do którego należy bieżący węzeł.
ParentNode	Pobiera węzeł nadrzędny tego węzła (dla węzłów, które mogą mieć elementy nadrzędne).
Prefix	Pobiera lub ustawia prefiks przestrzeni nazw tego węzła. (Odziedziczone po XmlNode)
PreserveWhitespace	Pobiera lub ustawia wartość wskazującą, czy zachować białe znaki w zawartości elementu.
PreviousSibling	Pobiera węzeł bezpośrednio poprzedzający ten węzeł. (Odziedziczone po XmlNode)
PreviousText	Pobiera węzeł tekstowy, który bezpośrednio poprzedza ten węzeł. (Odziedziczone po XmlNode)
SchemaInfo	ZwracaValidation-Infoset po schemacie (PSVI) węzła.
Schemas	Pobiera lub ustawia XmlSchemaSet obiekt skojarzony z tym XmlDocumentobiektem .
Value	Pobiera lub ustawia wartość węzła. (Odziedziczone po XmlNode)
XmlResolver	Ustawia wartość XmlResolver , która ma być używana do rozpoznawania zasobów zewnętrznych.

Metody

Nazwa	Opis
AppendChild(XmlNode)	Dodaje określony węzeł na końcu listy węzłów podrzędnych tego węzła. (Odziedziczone po XmlNode)
Clone()	Tworzy duplikat tego węzła. (Odziedziczone po XmlNode)
CloneNode(Boolean)	Tworzy duplikat tego węzła.
CreateAttribute(String, String, String)	Tworzy obiekt XmlAttribute z określonymi Prefixelementami , LocalNamei NamespaceURI.
CreateAttribute(String, String)	Tworzy element XmlAttribute o określonej kwalifikowanej nazwie i NamespaceURI.
CreateAttribute(String)	Tworzy obiekt XmlAttribute z określonym Nameelementem .
CreateCDataSection(String)	Tworzy obiekt XmlCDataSection zawierający określone dane.
CreateComment(String)	Tworzy obiekt XmlComment zawierający określone dane.
CreateDefaultAttribute(String, String, String)	Tworzy atrybut domyślny z określonym prefiksem, nazwą lokalną i identyfikatorem URI przestrzeni nazw.
CreateDocumentFragment()	Tworzy element XmlDocumentFragment.
CreateDocumentType(String, String, String, String)	Zwraca nowy XmlDocumentType obiekt.
CreateElement(String, String, String)	Tworzy element z określonymi Prefixelementami , LocalNamei NamespaceURI.
CreateElement(String, String)	Tworzy element XmlElement o kwalifikowanej nazwie i NamespaceURI.
CreateElement(String)	Tworzy element o określonej nazwie.
CreateEntityReference(String)	Tworzy obiekt XmlEntityReference o określonej nazwie.
CreateNavigator()	Tworzy nowy XPathNavigator obiekt do nawigowania po tym dokumencie.
CreateNavigator(XmlNode)	XPathNavigator Tworzy obiekt do nawigowania po tym dokumencie umieszczonym w XmlNode określonym miejscu.
CreateNode(String, String, String)	Tworzy obiekt XmlNode o określonym typie węzła, Namei NamespaceURI.
CreateNode(XmlNodeType, String, String, String)	Tworzy obiekt XmlNode z określonymi XmlNodeTypeelementami , , PrefixNamei NamespaceURI.
CreateNode(XmlNodeType, String, String)	Tworzy obiekt XmlNode z określonymi XmlNodeTypeelementami , Namei NamespaceURI.
CreateProcessingInstruction(String, String)	Tworzy obiekt XmlProcessingInstruction o określonej nazwie i danych.
CreateSignificantWhitespace(String)	XmlSignificantWhitespace Tworzy węzeł.
CreateTextNode(String)	Tworzy obiekt XmlText z określonym tekstem.
CreateWhitespace(String)	XmlWhitespace Tworzy węzeł.
CreateXmlDeclaration(String, String, String)	XmlDeclaration Tworzy węzeł z określonymi wartościami.
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
GetElementById(String)	Pobiera element XmlElement z określonym identyfikatorem.
GetElementsByTagName(String, String)	XmlNodeList Zwraca obiekt zawierający listę wszystkich elementów potomnych, które są zgodne z określonymi LocalName elementami i NamespaceURI.
GetElementsByTagName(String)	XmlNodeList Zwraca obiekt zawierający listę wszystkich elementów potomnych, które są zgodne z określonym Nameelementem .
GetEnumerator()	Pobiera moduł wyliczający iterujący przez węzły podrzędne w bieżącym węźle. (Odziedziczone po XmlNode)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetNamespaceOfPrefix(String)	Wyszukuje najbliższą deklarację xmlns dla danego prefiksu, który znajduje się w zakresie dla bieżącego węzła i zwraca identyfikator URI przestrzeni nazw w deklaracji . (Odziedziczone po XmlNode)
GetPrefixOfNamespace(String)	Wyszukuje najbliższą deklarację xmlns dla danego identyfikatora URI przestrzeni nazw, który jest w zakresie dla bieżącego węzła i zwraca prefiks zdefiniowany w tej deklaracji. (Odziedziczone po XmlNode)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
ImportNode(XmlNode, Boolean)	Importuje węzeł z innego dokumentu do bieżącego dokumentu.
InsertAfter(XmlNode, XmlNode)	Wstawia określony węzeł bezpośrednio po określonym węźle odniesienia. (Odziedziczone po XmlNode)
InsertBefore(XmlNode, XmlNode)	Wstawia określony węzeł bezpośrednio przed określonym węzłem odniesienia. (Odziedziczone po XmlNode)
Load(Stream)	Ładuje dokument XML z określonego strumienia.
Load(String)	Ładuje dokument XML z określonego adresu URL.
Load(TextReader)	Ładuje dokument XML z określonego TextReaderelementu .
Load(XmlReader)	Ładuje dokument XML z określonego XmlReaderelementu .
LoadXml(String)	Ładuje dokument XML z określonego ciągu.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
Normalize()	Umieszcza wszystkie węzły XmlText w pełnej głębi pod drzewem podrzędnym pod tym węzłem XmlNode w postaci "normalny", w której nie ma tylko tagów (czyli tagów, komentarzy, instrukcji przetwarzania, sekcji CDATA i odwołań do jednostek) oddziela węzły XmlText, czyli nie ma sąsiednich węzłów XmlText. (Odziedziczone po XmlNode)
PrependChild(XmlNode)	Dodaje określony węzeł na początku listy węzłów podrzędnych dla tego węzła. (Odziedziczone po XmlNode)
ReadNode(XmlReader)	XmlNode Tworzy obiekt na podstawie informacji w pliku XmlReader. Czytnik musi być umieszczony w węźle lub atrybucie.
RemoveAll()	Usuwa wszystkie węzły podrzędne i/lub atrybuty bieżącego węzła. (Odziedziczone po XmlNode)
RemoveChild(XmlNode)	Usuwa określony węzeł podrzędny. (Odziedziczone po XmlNode)
ReplaceChild(XmlNode, XmlNode)	Zastępuje węzeł podrzędny węzłem oldChildnewChild . (Odziedziczone po XmlNode)
Save(Stream)	Zapisuje dokument XML w określonym strumieniu.
Save(String)	Zapisuje dokument XML w określonym pliku. Jeśli określony plik istnieje, ta metoda zastępuje go.
Save(TextWriter)	Zapisuje dokument XML w określonym TextWriterpliku .
Save(XmlWriter)	Zapisuje dokument XML w określonym XmlWriterpliku .
SelectNodes(String, XmlNamespaceManager)	Wybiera listę węzłów pasujących do wyrażenia XPath. Wszystkie prefiksy znalezione w wyrażeniu XPath są rozpoznawane przy użyciu podanego XmlNamespaceManagerelementu . (Odziedziczone po XmlNode)
SelectNodes(String)	Wybiera listę węzłów pasujących do wyrażenia XPath. (Odziedziczone po XmlNode)
SelectSingleNode(String, XmlNamespaceManager)	Wybiera pierwszy element XmlNode zgodny z wyrażeniem XPath. Wszystkie prefiksy znalezione w wyrażeniu XPath są rozpoznawane przy użyciu podanego XmlNamespaceManagerelementu . (Odziedziczone po XmlNode)
SelectSingleNode(String)	Wybiera pierwszy element XmlNode zgodny z wyrażeniem XPath. (Odziedziczone po XmlNode)
Supports(String, String)	Sprawdza, czy implementacja MODELU DOM implementuje określoną funkcję. (Odziedziczone po XmlNode)
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
Validate(ValidationEventHandler, XmlNode)	Sprawdza poprawność XmlNode obiektu określonego względem schematów języka XSD (XML Schema Definition Language) we Schemas właściwości .
Validate(ValidationEventHandler)	Weryfikuje XmlDocument schematy języka XSD (XML Schema Definition Language) zawarte we Schemas właściwości .
WriteContentTo(XmlWriter)	Zapisuje wszystkie elementy podrzędne węzła XmlDocument w określonym XmlWriterobiekcie .
WriteTo(XmlWriter)	Zapisuje węzeł w XmlDocument określonym XmlWriterobiekcie .

Zdarzenia

Nazwa	Opis
NodeChanged	Występuje, gdy Value węzeł należący do tego dokumentu został zmieniony.
NodeChanging	Występuje, gdy Value węzeł należący do tego dokumentu ma zostać zmieniony.
NodeInserted	Występuje, gdy węzeł należący do tego dokumentu został wstawiony do innego węzła.
NodeInserting	Występuje, gdy węzeł należący do tego dokumentu ma zostać wstawiony do innego węzła.
NodeRemoved	Występuje, gdy węzeł należący do tego dokumentu został usunięty z elementu nadrzędnego.
NodeRemoving	Występuje, gdy węzeł należący do tego dokumentu ma zostać usunięty z dokumentu.

Jawne implementacje interfejsu

Nazwa	Opis
ICloneable.Clone()	Aby uzyskać opis tego elementu członkowskiego, zobacz Clone(). (Odziedziczone po XmlNode)
IEnumerable.GetEnumerator()	Aby uzyskać opis tego elementu członkowskiego, zobacz GetEnumerator(). (Odziedziczone po XmlNode)

Metody rozszerzania

Nazwa	Opis
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje IEnumerable na IQueryable.
Cast<TResult>(IEnumerable)	Rzutuje elementy IEnumerable do określonego typu.
OfType<TResult>(IEnumerable)	Filtruje elementy IEnumerable na podstawie określonego typu.

Zobacz też

• XmlNodeChangedEventHandler