XmlDocument Klas

Definitie

Naamruimte:

System.Xml

Assembly's:

netstandard.dll, System.Xml.ReaderWriter.dll

Bron:

XmlDocument.cs

Vertegenwoordigt een XML-document. U kunt deze klasse gebruiken om XML in een document te laden, valideren, bewerken, toevoegen en positioneren.

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

public class XmlDocument : System.Xml.XmlNode

type XmlDocument = class
    inherit XmlNode

Public Class XmlDocument
Inherits XmlNode

Overname

Object

XmlNode

XmlDocument

Afgeleid

System.Configuration.ConfigXmlDocument

System.Xml.XmlDataDocument

Opmerkingen

De XmlDocument klasse is een in-memory weergave van een XML-document. Het implementeert de W3C XML Document Object Model (DOM) Level 1 Core en de Core DOM Level 2.

DOM staat voor documentobjectmodel. Zie XML Document Object Model (DOM) voor meer informatie.

U kunt XML in de DOM laden met behulp van de XmlDocument klasse en vervolgens programmatisch XML in het document lezen, wijzigen en verwijderen.

Als u de XmlDocument klasse wilt openen en wilt zien hoe deze wordt geïmplementeerd, raadpleegt u de referentiebron.

XML laden in het documentobjectmodel

Begin met een XML-document zoals dit document met een aantal boeken in een verzameling. Het bevat de basisbeginselen die u zou vinden in een XML-document, waaronder een naamruimte, elementen die gegevens en kenmerken vertegenwoordigen die de gegevens beschrijven.

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

Laad vervolgens deze gegevens in de DOM, zodat u ermee in het geheugen kunt werken. De populairste manier om dit te doen is verwijzen naar een bestand op uw lokale computer of op een netwerk.

In dit voorbeeld wordt XML uit een bestand geladen. Als het bestand niet bestaat, wordt er alleen een XML gegenereerd en wordt dat geladen.

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

Zie Een XML-document lezen in de DOM voor meer informatie.

Valideren op basis van een schema

Begin met een XML-schema zoals deze. Dit schema definieert de gegevenstypen in de XML en welke kenmerken vereist zijn.

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

Maak een XmlReader object met behulp van uw schema en laad dat object vervolgens in de DOM. Maak een gebeurtenis-handler die wordt uitgevoerd wanneer code probeert uw XML-bestand te wijzigen op manieren die de regels van het schema schenden.

Deze codeblokken tonen helpermethoden die dit allemaal doen.

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

Zie Een XML-document valideren in de DOM voor meer informatie.

Navigeren in de documentstructuur

U kunt eigenschappen gebruiken om door een XML-document te navigeren. Maar voordat u een van deze termen gebruikt, gaan we snel enkele termen bekijken. Uw document bestaat uit knooppunten. Elk knooppunt heeft één ouder knooppunt direct erboven. Het enige knooppunt dat geen bovenliggend knooppunt heeft, is de documentwortel, als het hoogste niveau knooppunt. De meeste knooppunten kunnen onderliggende knooppunten hebben. Dit zijn knooppunten direct eronder. Knooppunten die zich op hetzelfde niveau bevinden, zijn broers en zussen.

In de volgende voorbeelden ziet u hoe u het hoofdknooppunt ophaalt, naar het eerste kindknooppunt van het hoofdknooppunt gaat, toegang krijgt tot een van de kindknooppunten, terug gaat naar het bovenliggende knooppunt en vervolgens door de broederknooppunten navigeert.

Beginnen met het hoofdknooppunt

In dit voorbeeld wordt het hoofdknooppunt opgehaald en vervolgens dat knooppunt gebruikt om de inhoud van het document naar de console uit te voeren.

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

Kindknooppunten ophalen

In dit voorbeeld gaat u naar het eerste onderliggende knooppunt van het hoofdknooppunt en doorloopt u vervolgens de onderliggende knooppunten van dat knooppunt, indien aanwezig.

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

Ga terug naar het ouderknooppunt

Gebruik de eigenschap ParentNode.

Raadpleeg het laatste kindknooppunt

In dit voorbeeld wordt de prijs van een boek naar de console geschreven. Het prijsknooppunt is het laatste onderliggende element van een boekknooppunt.

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

Naar voren navigeren tussen broers en zussen

In dit voorbeeld gaat u verder van boek naar boek. Boekknooppunten zijn elkaars gelijken.

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

Naar achteren navigeren tussen broers en zussen

In dit voorbeeld gaat men van boek naar boek in omgekeerde volgorde.

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

Knooppunten zoeken

De populairste manier om een of meer knooppunten met gegevens te vinden, is door een XPath-queryreeks te gebruiken, maar er zijn ook methoden die er geen nodig hebben.

Eén knooppunt ophalen

In dit voorbeeld wordt een boek gevonden met behulp van het ISBN-nummer.

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

De tekenreeks die in dit voorbeeld wordt gebruikt, is een xpath-query. U vindt er meer voorbeelden in XPath-voorbeelden.

U kunt ook knooppunten ophalen met de GetElementById. Als u deze methode wilt gebruiken, moet u id's definiëren in de declaraties van documenttypedefinities van uw XML-bestand.

Nadat u een knooppunt hebt opgehaald, krijgt u de waarde van kenmerken of kindknooppunten. In dit voorbeeld wordt dat met een boekknoop uitgevoerd.

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

Een verzameling knooppunten ophalen

In dit voorbeeld worden alle boeken geselecteerd waarbij de achternaam van de auteur Austen is en vervolgens de prijs van die boeken wijzigt.

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

U kunt ook een verzameling knooppunten ophalen met behulp van de naam van het knooppunt. In dit voorbeeld wordt bijvoorbeeld een verzameling van alle boektitels verzameld.

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

Zie Knooppunten selecteren met behulp van XPath-navigatie voor meer informatie.

Knooppunten bewerken

In dit voorbeeld worden een boekknooppunt en de bijbehorende kenmerken bewerkt.

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

Zie Knooppunten, inhoud en waarden wijzigen in een XML-document voor meer informatie.

Knooppunten toevoegen

Als u een knooppunt wilt toevoegen, gebruikt u de CreateElement methode of de CreateNode methode.

Als u een gegevensknooppunt zoals een boek wilt toevoegen, gebruikt u de CreateElement methode.

Gebruik de CreateNode methode voor elk ander type knooppunt, zoals een opmerking, witruimteknooppunt of CDATA-knooppunt.

In dit voorbeeld wordt een boekknooppunt gemaakt, worden kenmerken aan dat knooppunt toegevoegd en wordt dat knooppunt vervolgens aan het document toegevoegd.

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

Zie Knooppunten invoegen in een XML-document voor meer informatie.

Knooppunten verwijderen

Als u een knooppunt wilt verwijderen, gebruikt u de RemoveChild methode.

In dit voorbeeld wordt een boek verwijderd uit het document en eventuele witruimten die vlak voor het boekknooppunt worden weergegeven.

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

Zie Knooppunten, inhoud en waarden verwijderen uit een XML-document voor meer informatie.

Positieknooppunten

U kunt kiezen waar u een knooppunt in uw document wilt weergeven met behulp van de InsertBefore en InsertAfter methoden.

In dit voorbeeld ziet u twee helpermethoden. Een van deze items verplaatst een knooppunt hoger in een lijst. De andere verplaatst een knooppunt lager.

Deze methoden kunnen worden gebruikt in een toepassing waarmee gebruikers boeken omhoog en omlaag kunnen verplaatsen in een lijst met boeken. Wanneer een gebruiker een boek kiest en op een knop omhoog of omlaag drukt, kan uw code methoden zoals deze aanroepen om het bijbehorende boekknooppunt voor of na andere boekknooppunten te plaatsen.

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

Constructors

Name	Description
XmlDocument()	Initialiseert een nieuw exemplaar van de XmlDocument klasse.
XmlDocument(XmlImplementation)	Initialiseert een nieuw exemplaar van de XmlDocument klasse met de opgegeven XmlImplementation.
XmlDocument(XmlNameTable)	Initialiseert een nieuw exemplaar van de XmlDocument klasse met de opgegeven XmlNameTable.

Eigenschappen

Name	Description
Attributes	Hiermee haalt u een XmlAttributeCollection met de kenmerken van dit knooppunt op. (Overgenomen van XmlNode)
BaseURI	Hiermee haalt u de basis-URI van het huidige knooppunt op.
ChildNodes	Hiermee worden alle onderliggende knooppunten van het knooppunt opgehaald. (Overgenomen van XmlNode)
DocumentElement	Hiermee haalt u de hoofdmap XmlElement voor het document op.
DocumentType	Hiermee haalt u het knooppunt op met de DOCTYPE-declaratie.
FirstChild	Hiermee wordt het eerste onderliggende element van het knooppunt opgehaald. (Overgenomen van XmlNode)
HasChildNodes	Hiermee wordt een waarde opgehaald die aangeeft of dit knooppunt onderliggende knooppunten heeft. (Overgenomen van XmlNode)
Implementation	Hiermee haalt u het XmlImplementation object voor het huidige document op.
InnerText	Gooit een InvalidOperationException in alle gevallen.
InnerXml	Hiermee worden de markeringen opgehaald of ingesteld die de onderliggende elementen van het huidige knooppunt vertegenwoordigen.
IsReadOnly	Hiermee wordt een waarde opgehaald die aangeeft of het huidige knooppunt het kenmerk Alleen-lezen heeft.
Item[String, String]	Hiermee haalt u het eerste onderliggende element op met de opgegeven LocalName en NamespaceURI. (Overgenomen van XmlNode)
Item[String]	Hiermee haalt u het eerste onderliggende element op met de opgegeven Name. (Overgenomen van XmlNode)
LastChild	Hiermee wordt het laatste onderliggende element van het knooppunt opgehaald. (Overgenomen van XmlNode)
LocalName	Hiermee haalt u de lokale naam van het knooppunt op.
Name	Hiermee haalt u de gekwalificeerde naam van het knooppunt op.
NamespaceURI	Hiermee haalt u de naamruimte-URI van dit knooppunt op. (Overgenomen van XmlNode)
NameTable	Hiermee haalt u de XmlNameTable gekoppelde implementatie op.
NextSibling	Hiermee wordt het knooppunt onmiddellijk na dit knooppunt opgehaald. (Overgenomen van XmlNode)
NodeType	Hiermee wordt het type van het huidige knooppunt opgehaald.
OuterXml	Hiermee haalt u de markeringen op die dit knooppunt en alle onderliggende knooppunten bevatten. (Overgenomen van XmlNode)
OwnerDocument	Hiermee wordt het XmlDocument huidige knooppunt opgehaald.
ParentNode	Hiermee wordt het bovenliggende knooppunt van dit knooppunt opgehaald (voor knooppunten met bovenliggende items).
Prefix	Hiermee wordt het voorvoegsel van de naamruimte van dit knooppunt opgehaald of ingesteld. (Overgenomen van XmlNode)
PreserveWhitespace	Hiermee wordt een waarde opgehaald of ingesteld die aangeeft of witruimte in elementinhoud behouden moet blijven.
PreviousSibling	Hiermee wordt het knooppunt direct vóór dit knooppunt opgehaald. (Overgenomen van XmlNode)
PreviousText	Hiermee haalt u het tekstknooppunt op dat direct voorafgaat aan dit knooppunt. (Overgenomen van XmlNode)
SchemaInfo	Retourneert de Post-Schema-Validation-Infoset (PSVI) van het knooppunt.
Schemas	Hiermee wordt het XmlSchemaSet object opgehaald of ingesteld dat aan dit XmlDocumentobject is gekoppeld.
Value	Hiermee wordt de waarde van het knooppunt opgehaald of ingesteld. (Overgenomen van XmlNode)
XmlResolver	Hiermee stelt u het te gebruiken voor het XmlResolver oplossen van externe resources.

Methoden

Name	Description
AppendChild(XmlNode)	Hiermee voegt u het opgegeven knooppunt toe aan het einde van de lijst met onderliggende knooppunten van dit knooppunt. (Overgenomen van XmlNode)
Clone()	Hiermee maakt u een duplicaat van dit knooppunt. (Overgenomen van XmlNode)
CloneNode(Boolean)	Hiermee maakt u een duplicaat van dit knooppunt.
CreateAttribute(String, String, String)	Hiermee maakt u een XmlAttribute met de opgegeven Prefix, LocalNameen NamespaceURI.
CreateAttribute(String, String)	Hiermee maakt u een XmlAttribute met de opgegeven gekwalificeerde naam en NamespaceURI.
CreateAttribute(String)	Hiermee maakt u een XmlAttribute met de opgegeven Name.
CreateCDataSection(String)	Hiermee maakt u een XmlCDataSection met de opgegeven gegevens.
CreateComment(String)	Hiermee maakt u een XmlComment met de opgegeven gegevens.
CreateDefaultAttribute(String, String, String)	Hiermee maakt u een standaardkenmerk met het opgegeven voorvoegsel, de lokale naam en de naamruimte-URI.
CreateDocumentFragment()	Hiermee maakt u een XmlDocumentFragment.
CreateDocumentType(String, String, String, String)	Retourneert een nieuw XmlDocumentType object.
CreateElement(String, String, String)	Hiermee maakt u een element met de opgegeven Prefix, LocalNameen NamespaceURI.
CreateElement(String, String)	Hiermee maakt u een XmlElement met de gekwalificeerde naam en NamespaceURI.
CreateElement(String)	Hiermee maakt u een element met de opgegeven naam.
CreateEntityReference(String)	Hiermee maakt u een XmlEntityReference met de opgegeven naam.
CreateNavigator()	Hiermee maakt u een nieuw XPathNavigator object voor het navigeren in dit document.
CreateNavigator(XmlNode)	Hiermee maakt u een XPathNavigator object voor het navigeren in dit document dat op de XmlNode opgegeven locatie is geplaatst.
CreateNode(String, String, String)	Hiermee maakt u een XmlNode met het opgegeven knooppunttype, Nameen NamespaceURI.
CreateNode(XmlNodeType, String, String, String)	Hiermee maakt u een XmlNode met de opgegeven XmlNodeType, Prefix, en NameNamespaceURI.
CreateNode(XmlNodeType, String, String)	Hiermee maakt u een XmlNode met de opgegeven XmlNodeType, Nameen NamespaceURI.
CreateProcessingInstruction(String, String)	Hiermee maakt u een XmlProcessingInstruction met de opgegeven naam en gegevens.
CreateSignificantWhitespace(String)	Hiermee maakt u een XmlSignificantWhitespace knooppunt.
CreateTextNode(String)	Hiermee maakt u een XmlText met de opgegeven tekst.
CreateWhitespace(String)	Hiermee maakt u een XmlWhitespace knooppunt.
CreateXmlDeclaration(String, String, String)	Hiermee maakt u een XmlDeclaration knooppunt met de opgegeven waarden.
Equals(Object)	Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object)
GetElementById(String)	Hiermee haalt u de XmlElement opgegeven id op.
GetElementsByTagName(String, String)	Retourneert een XmlNodeList met een lijst met alle onderliggende elementen die overeenkomen met de opgegeven LocalName en NamespaceURI.
GetElementsByTagName(String)	Retourneert een XmlNodeList met een lijst met alle onderliggende elementen die overeenkomen met de opgegeven Name.
GetEnumerator()	Hiermee haalt u een enumerator op die door de onderliggende knooppunten in het huidige knooppunt wordt herhaald. (Overgenomen van XmlNode)
GetHashCode()	Fungeert als de standaardhashfunctie. (Overgenomen van Object)
GetNamespaceOfPrefix(String)	Zoekt de dichtstbijzijnde XMLN-declaratie op voor het opgegeven voorvoegsel dat binnen het bereik van het huidige knooppunt valt en retourneert de naamruimte-URI in de declaratie. (Overgenomen van XmlNode)
GetPrefixOfNamespace(String)	Hiermee wordt gezocht naar de dichtstbijzijnde XMLN-declaratie voor de opgegeven naamruimte-URI die binnen het bereik van het huidige knooppunt valt en wordt het voorvoegsel geretourneerd dat in die declaratie is gedefinieerd. (Overgenomen van XmlNode)
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
ImportNode(XmlNode, Boolean)	Hiermee importeert u een knooppunt van een ander document naar het huidige document.
InsertAfter(XmlNode, XmlNode)	Hiermee wordt het opgegeven knooppunt direct na het opgegeven referentieknooppunt ingevoegd. (Overgenomen van XmlNode)
InsertBefore(XmlNode, XmlNode)	Hiermee wordt het opgegeven knooppunt direct vóór het opgegeven referentieknooppunt ingevoegd. (Overgenomen van XmlNode)
Load(Stream)	Laadt het XML-document uit de opgegeven stream.
Load(String)	Laadt het XML-document vanuit de opgegeven URL.
Load(TextReader)	Laadt het XML-document van de opgegeven TextReader.
Load(XmlReader)	Laadt het XML-document van de opgegeven XmlReader.
LoadXml(String)	Laadt het XML-document uit de opgegeven tekenreeks.
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
Normalize()	Hiermee worden alle XmlText-knooppunten in de volledige diepte van de substructuur onder deze XmlNode in een 'normale' vorm geplaatst, waarbij alleen markeringen (tags, opmerkingen, verwerkingsinstructies, CDATA-secties en entiteitsverwijzingen) xmlText-knooppunten scheidt, dat wil zeggen dat er geen aangrenzende XmlText-knooppunten zijn. (Overgenomen van XmlNode)
PrependChild(XmlNode)	Voegt het opgegeven knooppunt toe aan het begin van de lijst met onderliggende knooppunten voor dit knooppunt. (Overgenomen van XmlNode)
ReadNode(XmlReader)	Hiermee maakt u een XmlNode object op basis van de informatie in de XmlReader. De lezer moet op een knooppunt of kenmerk worden weergegeven.
RemoveAll()	Hiermee verwijdert u alle onderliggende knooppunten en/of kenmerken van het huidige knooppunt. (Overgenomen van XmlNode)
RemoveChild(XmlNode)	Hiermee verwijdert u het opgegeven onderliggende knooppunt. (Overgenomen van XmlNode)
ReplaceChild(XmlNode, XmlNode)	Vervangt het onderliggende knooppunt oldChild door newChild het knooppunt. (Overgenomen van XmlNode)
Save(Stream)	Slaat het XML-document op in de opgegeven stroom.
Save(String)	Slaat het XML-document op in het opgegeven bestand. Als het opgegeven bestand bestaat, overschrijft deze methode het.
Save(TextWriter)	Hiermee wordt het XML-document opgeslagen in het opgegeven TextWriter.
Save(XmlWriter)	Hiermee wordt het XML-document opgeslagen in het opgegeven XmlWriter.
SelectNodes(String, XmlNamespaceManager)	Hiermee selecteert u een lijst met knooppunten die overeenkomen met de XPath-expressie. Alle voorvoegsels in de XPath-expressie worden omgezet met behulp van de opgegeven XmlNamespaceManager. (Overgenomen van XmlNode)
SelectNodes(String)	Hiermee selecteert u een lijst met knooppunten die overeenkomen met de XPath-expressie. (Overgenomen van XmlNode)
SelectSingleNode(String, XmlNamespaceManager)	Selecteert de eerste XmlNode die overeenkomt met de XPath-expressie. Alle voorvoegsels in de XPath-expressie worden omgezet met behulp van de opgegeven XmlNamespaceManager. (Overgenomen van XmlNode)
SelectSingleNode(String)	Selecteert de eerste XmlNode die overeenkomt met de XPath-expressie. (Overgenomen van XmlNode)
Supports(String, String)	Hiermee wordt getest of de DOM-implementatie een specifieke functie implementeert. (Overgenomen van XmlNode)
ToString()	Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object)
Validate(ValidationEventHandler, XmlNode)	Valideert het XmlNode object dat is opgegeven op basis van de XSD-schema's (XML Schema Definition Language) in de Schemas eigenschap.
Validate(ValidationEventHandler)	Valideert de XmlDocument schema's voor XML Schema Definition Language (XSD) in de Schemas eigenschap.
WriteContentTo(XmlWriter)	Slaat alle onderliggende elementen van het XmlDocument knooppunt op in de opgegeven XmlWriter.
WriteTo(XmlWriter)	Slaat het knooppunt op in XmlDocument het opgegeven XmlWriter.

gebeurtenis

Name	Description
NodeChanged	Treedt op wanneer het Value knooppunt dat deel uitmaakt van dit document is gewijzigd.
NodeChanging	Treedt op wanneer het Value knooppunt dat deel uitmaakt van dit document op het punt staat te worden gewijzigd.
NodeInserted	Treedt op wanneer een knooppunt dat deel uitmaakt van dit document is ingevoegd in een ander knooppunt.
NodeInserting	Treedt op wanneer een knooppunt dat deel uitmaakt van dit document op het punt staat in een ander knooppunt te worden ingevoegd.
NodeRemoved	Treedt op wanneer een knooppunt dat deel uitmaakt van dit document is verwijderd van het bovenliggende item.
NodeRemoving	Treedt op wanneer een knooppunt dat deel uitmaakt van dit document, wordt verwijderd uit het document.

Expliciete interface-implementaties

Name	Description
ICloneable.Clone()	Zie voor een beschrijving van dit lid Clone(). (Overgenomen van XmlNode)
IEnumerable.GetEnumerator()	Zie voor een beschrijving van dit lid GetEnumerator(). (Overgenomen van XmlNode)

Extensiemethoden

Name	Description
AsParallel(IEnumerable)	Hiermee schakelt u parallelle uitvoering van een query in.
AsQueryable(IEnumerable)	Converteert een IEnumerable naar een IQueryable.
Cast<TResult>(IEnumerable)	Cast de elementen van een IEnumerable naar het opgegeven type.
OfType<TResult>(IEnumerable)	Hiermee filtert u de elementen van een IEnumerable op basis van een opgegeven type.

Zie ook

• XmlNodeChangedEventHandler