XmlDocument Třída

Definice

Obor názvů:

System.Xml

Sestavení:

netstandard.dll, System.Xml.ReaderWriter.dll

Zdroj:

XmlDocument.cs

Představuje dokument XML. Tuto třídu můžete použít k načtení, ověření, úpravě, přidání a umístění XML v dokumentu.

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

public class XmlDocument : System.Xml.XmlNode

type XmlDocument = class
    inherit XmlNode

Public Class XmlDocument
Inherits XmlNode

Dědičnost

Object

XmlNode

XmlDocument

Odvozené

System.Configuration.ConfigXmlDocument

System.Xml.XmlDataDocument

Poznámky

Třída XmlDocument je reprezentace dokumentu XML v paměti. Implementuje W3C XML Document Object Model (DOM) úrovně 1 Jádra a úrovně 2 Jádra DOM.

DOM je zkratka pro model objektu dokumentu. Další informace najdete v tématu MODEL DOM (Document Object Model) XML.

XML můžete načíst do DOM pomocí třídy XmlDocument a pak v dokumentu programově číst, upravovat a odebírat XML.

Pokud chcete otevřít XmlDocument třídu a podívat se, jak je implementovaná, přečtěte si referenční zdroj.

Načtení XML do objektového modelu dokumentu

Začněte s dokumentem XML, jako je ten, který obsahuje několik knih v kolekci. Obsahuje základní věci, které byste našli v jakémkoli dokumentu XML, včetně oboru názvů, elementů představujících data a atributů, které popisují data.

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

Dále načtěte tato data do DOM, abyste s nimi mohli pracovat v paměti. Nejoblíbenější způsob, jak to udělat, je odkazovat na soubor na místním počítači nebo v síti.

Tento příklad načte XML ze souboru. Pokud soubor neexistuje, stačí vygenerovat nějaký KÓD XML a načte ho.

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

Další informace najdete v tématu Čtení dokumentu XML do DOM.

Ověřte ho vůči schématu.

Začněte schématem XML, jako je tento. Toto schéma definuje datové typy v jazyce XML a požadované atributy.

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

Vytvořte objekt XmlReader pomocí schématu a pak ho načtěte do modelu DOM. Vytvořte obslužnou rutinu události, která se spustí, když se kód pokusí upravit soubor XML způsobem, který porušuje pravidla schématu.

Tyto bloky kódu zobrazují pomocné metody, které to všechno dělají.

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

Další informace naleznete v tématu Ověřování dokumentu XML v DOM.

Procházet stromem dokumentu

K procházení dokumentu XML můžete použít vlastnosti. Než ale některou z nich použijete, pojďme se rychle podívat na několik termínů. Dokument se skládá z uzlů. Každý uzel má jeden nadřazený uzel přímo nad ním. Jediným uzlem, který nemá nadřazený uzel, je kořen dokumentu, protože se jedná o uzel nejvyšší úrovně. Většina uzlů může mít podřízené uzly, což jsou uzly přímo pod nimi. Uzly, které jsou na stejné úrovni, jsou sourozenci.

Následující příklady ukazují, jak získat kořenový uzel, přejít na první podřízený uzel kořenového uzlu, získat přístup k libovolnému z jeho podřízených uzlů, vrátit se k nadřazeného uzlu a pak přejít mezi uzly na stejné úrovni.

Začínáme s kořenovým uzlem

Tento příklad získá kořenový uzel a pak tento uzel použije k výstupu obsahu dokumentu do konzoly.

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

Získání podřízených uzlů

Tento příklad přejde na první podřízený uzel kořenového uzlu a pak iteruje podřízené uzly tohoto uzlu, pokud existují.

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

Návrat k nadřazenému uzlu

Použijte vlastnost ParentNode.

Odkaz na poslední podřízený uzel

Tento příklad zapíše cenu knihy do konzoly. Cenový uzel je posledním podřízeným uzlem knihy.

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

Přejít vpřed mezi sourozenci

Tento příklad se posouvá z knihy na knihu. Uzly knih jsou sourozenci ve struktuře.

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

Přecházet zpět mezi sourozenci

Tento příklad postupuje zpětně z knihy do knihy.

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

Vyhledání uzlů

Nejoblíbenější způsob, jak najít jeden nebo více uzlů dat, je použít řetězec dotazu XPath, ale existují i metody, které ho nevyžadují.

Získejte jeden uzel

Tento příklad vyhledá knihu pomocí čísla 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

Řetězec použitý v tomto příkladu je dotaz Xpath. Další příklady najdete v příkladech XPathu.

Můžete také použít GetElementById k načtení uzlů. Pokud chcete tento přístup použít, budete muset definovat ID v deklarací definice typu dokumentu souboru XML.

Jakmile získáte uzel, získáte hodnoty atributů nebo podřízených uzlů. Tento příklad to dělá s uzlem knihy.

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

Získejte kolekci uzlů

Tento příklad vybere všechny knihy, ve kterých je příjmení autora Austen, a pak změní cenu těchto knih.

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

Kolekci uzlů můžete získat také pomocí názvu uzlu. Tento příklad například získá kolekci všech titulů knih.

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

Další informace naleznete v tématu Výběr uzlů pomocí navigace XPath.

Úprava uzlů

Tento příklad upraví uzel knihy a jeho atributy.

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

Další informace naleznete v tématu Úpravy uzlů, obsahu a hodnot v dokumentu XML.

Přidání uzlů

Pokud chcete přidat uzel, použijte metodu CreateElement nebo metodu CreateNode .

Pokud chcete přidat datový uzel, například knihu, použijte metodu CreateElement .

Pro jakýkoli jiný typ uzlu, jako je komentář, prázdný uzel nebo uzel CDATA, použijte metodu CreateNode .

Tento příklad vytvoří uzel knihy, přidá do tohoto uzlu atributy a pak tento uzel přidá 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

Další informace naleznete v tématu Vložení uzlů do dokumentu XML.

Odebrání uzlů

Pokud chcete odebrat uzel, použijte metodu RemoveChild .

Tento příklad odebere knihu z dokumentu a všechny mezery, které se nachází těsně před uzlem knihy.

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

Další informace naleznete v tématu Odebrání uzlů, obsahu a hodnot z dokumentu XML.

Pozice uzlů

Pomocí metod InsertBefore a InsertAfter můžete zvolit, kde se má uzel ve vašem dokumentu zobrazit.

Tento příklad ukazuje dvě pomocné metody. Jeden z nich přesune uzel v seznamu výš. Druhý z nich přesune uzel dolů.

Tyto metody lze použít v aplikaci, která uživatelům umožňuje přesouvat knihy v seznamu knih nahoru a dolů. Když uživatel zvolí knihu a stiskne tlačítko nahoru nebo dolů, může kód volat podobné metody, které umístí odpovídající uzel knihy před nebo za jinými uzly knihy.

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

Name	Description
XmlDocument()	Inicializuje novou instanci XmlDocument třídy.
XmlDocument(XmlImplementation)	Inicializuje novou instanci XmlDocument třídy se zadaným XmlImplementation.
XmlDocument(XmlNameTable)	Inicializuje novou instanci XmlDocument třídy se zadaným XmlNameTable.

Vlastnosti

Name	Description
Attributes	XmlAttributeCollection Získá obsahující atributy tohoto uzlu. (Zděděno od XmlNode)
BaseURI	Získá základní identifikátor URI aktuálního uzlu.
ChildNodes	Získá všechny podřízené uzly uzlu. (Zděděno od XmlNode)
DocumentElement	Získá kořen XmlElement dokumentu.
DocumentType	Získá uzel obsahující deklaraci DOCTYPE.
FirstChild	Získá první podřízený uzel. (Zděděno od XmlNode)
HasChildNodes	Získá hodnotu označující, zda má tento uzel nějaké podřízené uzly. (Zděděno od XmlNode)
Implementation	XmlImplementation Získá objekt pro aktuální dokument.
InnerText	Vyvolá výjimku InvalidOperationException ve všech případech.
InnerXml	Získá nebo nastaví kód představující podřízené položky aktuálního uzlu.
IsReadOnly	Získá hodnotu označující, zda je aktuální uzel jen pro čtení.
Item[String, String]	Získá první podřízený prvek se zadaným LocalName a NamespaceURI. (Zděděno od XmlNode)
Item[String]	Získá první podřízený prvek se zadaným Name. (Zděděno od XmlNode)
LastChild	Získá poslední podřízený uzel. (Zděděno od XmlNode)
LocalName	Získá místní název uzlu.
Name	Získá kvalifikovaný název uzlu.
NamespaceURI	Získá identifikátor URI oboru názvů tohoto uzlu. (Zděděno od XmlNode)
NameTable	Získá přidružené k XmlNameTable této implementaci.
NextSibling	Získá uzel bezprostředně za tímto uzlem. (Zděděno od XmlNode)
NodeType	Získá typ aktuálního uzlu.
OuterXml	Získá kód obsahující tento uzel a všechny jeho podřízené uzly. (Zděděno od XmlNode)
OwnerDocument	XmlDocument Získá, ke kterému patří aktuální uzel.
ParentNode	Získá nadřazený uzel tohoto uzlu (pro uzly, které mohou mít nadřazené uzly).
Prefix	Získá nebo nastaví předponu oboru názvů tohoto uzlu. (Zděděno od XmlNode)
PreserveWhitespace	Získá nebo nastaví hodnotu označující, zda zachovat prázdné znaky v obsahu prvku.
PreviousSibling	Získá uzel bezprostředně před tímto uzlem. (Zděděno od XmlNode)
PreviousText	Získá textový uzel, který bezprostředně předchází tomuto uzlu. (Zděděno od XmlNode)
SchemaInfo	Vrátí hodnotu post-schema-Validation-Infoset (PSVI) uzlu.
Schemas	Získá nebo nastaví XmlSchemaSet objekt přidružený k tomuto XmlDocument.
Value	Získá nebo nastaví hodnotu uzlu. (Zděděno od XmlNode)
XmlResolver	XmlResolver Nastaví použití pro překlad externích prostředků.

Metody

Name	Description
AppendChild(XmlNode)	Přidá zadaný uzel na konec seznamu podřízených uzlů tohoto uzlu. (Zděděno od XmlNode)
Clone()	Vytvoří duplikát tohoto uzlu. (Zděděno od XmlNode)
CloneNode(Boolean)	Vytvoří duplikát tohoto uzlu.
CreateAttribute(String, String, String)	Vytvoří se zadaným XmlAttributeparametrem Prefix , LocalNamea NamespaceURI.
CreateAttribute(String, String)	Vytvoří se zadaným kvalifikovaným XmlAttribute názvem a NamespaceURI.
CreateAttribute(String)	Vytvoří se zadaným XmlAttributeparametrem Name .
CreateCDataSection(String)	Vytvoří obsahující XmlCDataSection zadaná data.
CreateComment(String)	Vytvoří obsahující XmlComment zadaná data.
CreateDefaultAttribute(String, String, String)	Vytvoří výchozí atribut se zadanou předponou, místním názvem a identifikátorem URI oboru názvů.
CreateDocumentFragment()	Vytvoří XmlDocumentFragment.
CreateDocumentType(String, String, String, String)	Vrátí nový XmlDocumentType objekt.
CreateElement(String, String, String)	Vytvoří prvek se zadaným Prefixznakem , LocalNamea NamespaceURI.
CreateElement(String, String)	Vytvoří s kvalifikovaným XmlElement názvem a NamespaceURI.
CreateElement(String)	Vytvoří prvek se zadaným názvem.
CreateEntityReference(String)	Vytvoří se zadaným XmlEntityReference názvem.
CreateNavigator()	Vytvoří nový XPathNavigator objekt pro navigaci v tomto dokumentu.
CreateNavigator(XmlNode)	XPathNavigator Vytvoří objekt pro navigaci v tomto dokumentu umístěném na zadaném XmlNode místě.
CreateNode(String, String, String)	Vytvoří se zadaným typem XmlNodeNameuzlu a NamespaceURI.
CreateNode(XmlNodeType, String, String, String)	Vytvoří se zadaným XmlNodeparametrem XmlNodeType , Prefix, Namea NamespaceURI.
CreateNode(XmlNodeType, String, String)	Vytvoří se zadaným XmlNodeparametrem XmlNodeType , Namea NamespaceURI.
CreateProcessingInstruction(String, String)	Vytvoří se zadaným XmlProcessingInstruction názvem a daty.
CreateSignificantWhitespace(String)	XmlSignificantWhitespace Vytvoří uzel.
CreateTextNode(String)	Vytvoří se zadaným textem XmlText .
CreateWhitespace(String)	XmlWhitespace Vytvoří uzel.
CreateXmlDeclaration(String, String, String)	XmlDeclaration Vytvoří uzel se zadanými hodnotami.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetElementById(String)	Získá se XmlElement zadaným ID.
GetElementsByTagName(String, String)	XmlNodeList Vrátí seznam všech následnických prvků, které odpovídají zadanému LocalName a NamespaceURI.
GetElementsByTagName(String)	XmlNodeList Vrátí obsahující seznam všech následnických prvků, které odpovídají zadanému Name.
GetEnumerator()	Získá enumerátor, který iteruje prostřednictvím podřízených uzlů v aktuálním uzlu. (Zděděno od XmlNode)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetNamespaceOfPrefix(String)	Vyhledá nejbližší deklaraci xmlns pro danou předponu, která je v oboru pro aktuální uzel, a vrátí identifikátor URI oboru názvů v deklaraci. (Zděděno od XmlNode)
GetPrefixOfNamespace(String)	Vyhledá nejbližší deklaraci xmlns pro daný identifikátor URI oboru názvů, který je v oboru pro aktuální uzel, a vrátí předponu definovanou v této deklaraci. (Zděděno od XmlNode)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
ImportNode(XmlNode, Boolean)	Importuje uzel z jiného dokumentu do aktuálního dokumentu.
InsertAfter(XmlNode, XmlNode)	Vloží zadaný uzel bezprostředně za zadaný referenční uzel. (Zděděno od XmlNode)
InsertBefore(XmlNode, XmlNode)	Vloží zadaný uzel bezprostředně před zadaný referenční uzel. (Zděděno od XmlNode)
Load(Stream)	Načte dokument XML ze zadaného datového proudu.
Load(String)	Načte dokument XML ze zadané adresy URL.
Load(TextReader)	Načte dokument XML ze zadaného TextReadersouboru .
Load(XmlReader)	Načte dokument XML ze zadaného XmlReadersouboru .
LoadXml(String)	Načte dokument XML ze zadaného řetězce.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
Normalize()	Umístí všechny uzly XmlText do úplné hloubky pod tímto objektem XmlNode do "normálního" formátu, kde pouze značky (tj. značky, komentáře, pokyny ke zpracování, oddíly CDATA a odkazy na entity) odděluje uzly XmlText, to znamená, že neexistují žádné sousední uzly XmlText. (Zděděno od XmlNode)
PrependChild(XmlNode)	Přidá zadaný uzel na začátek seznamu podřízených uzlů pro tento uzel. (Zděděno od XmlNode)
ReadNode(XmlReader)	XmlNode Vytvoří objekt na základě informací v objektu XmlReader. Čtenář musí být umístěn na uzlu nebo atributu.
RemoveAll()	Odebere všechny podřízené uzly nebo atributy aktuálního uzlu. (Zděděno od XmlNode)
RemoveChild(XmlNode)	Odebere zadaný podřízený uzel. (Zděděno od XmlNode)
ReplaceChild(XmlNode, XmlNode)	Nahradí podřízený uzel oldChildnewChild uzlem. (Zděděno od XmlNode)
Save(Stream)	Uloží dokument XML do zadaného datového proudu.
Save(String)	Uloží dokument XML do zadaného souboru. Pokud zadaný soubor existuje, tato metoda jej přepíše.
Save(TextWriter)	Uloží dokument XML do zadaného TextWritersouboru .
Save(XmlWriter)	Uloží dokument XML do zadaného XmlWritersouboru .
SelectNodes(String, XmlNamespaceManager)	Vybere seznam uzlů odpovídajících výrazu XPath. Všechny předpony nalezené ve výrazu XPath se přeloží pomocí zadaného XmlNamespaceManagervýrazu . (Zděděno od XmlNode)
SelectNodes(String)	Vybere seznam uzlů odpovídajících výrazu XPath. (Zděděno od XmlNode)
SelectSingleNode(String, XmlNamespaceManager)	Vybere první XmlNode výraz, který odpovídá výrazu XPath. Všechny předpony nalezené ve výrazu XPath se přeloží pomocí zadaného XmlNamespaceManagervýrazu . (Zděděno od XmlNode)
SelectSingleNode(String)	Vybere první XmlNode výraz, který odpovídá výrazu XPath. (Zděděno od XmlNode)
Supports(String, String)	Otestuje, jestli implementace DOM implementuje konkrétní funkci. (Zděděno od XmlNode)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Validate(ValidationEventHandler, XmlNode)	XmlNode Ověří objekt zadaný ve schématu XSD (XML Schema Definition Language) ve Schemas vlastnosti.
Validate(ValidationEventHandler)	Ověří proti XmlDocument schématům XSD (XML Schema Definition Language) obsaženým Schemas ve vlastnosti.
WriteContentTo(XmlWriter)	Uloží všechny podřízené položky XmlDocument uzlu do zadaného XmlWriter.
WriteTo(XmlWriter)	Uloží XmlDocument uzel do zadaného XmlWriter.

Událost

Name	Description
NodeChanged	Nastane, když došlo ke Value změně uzlu, který patří do tohoto dokumentu.
NodeChanging	Nastane, když Value se chystá změnit uzel, který patří do tohoto dokumentu.
NodeInserted	Nastane, když uzel, který patří do tohoto dokumentu, byl vložen do jiného uzlu.
NodeInserting	Nastane, když se uzel, který patří do tohoto dokumentu, chystá vložit do jiného uzlu.
NodeRemoved	Nastane, když uzel, který patří do tohoto dokumentu, byl odebrán z nadřazeného objektu.
NodeRemoving	Nastane, když se uzel, který patří do tohoto dokumentu, chystá odebrat z dokumentu.

Explicitní implementace rozhraní

Name	Description
ICloneable.Clone()	Popis tohoto člena naleznete v tématu Clone(). (Zděděno od XmlNode)
IEnumerable.GetEnumerator()	Popis tohoto člena naleznete v tématu GetEnumerator(). (Zděděno od XmlNode)

Metody rozšíření

Name	Description
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede IEnumerable na IQueryable.
Cast<TResult>(IEnumerable)	Přetypuje prvky IEnumerable na zadaný typ.
OfType<TResult>(IEnumerable)	Filtruje prvky IEnumerable na základě zadaného typu.

Viz také

• XmlNodeChangedEventHandler