XmlDocument XmlDocument XmlDocument XmlDocument Class

Definition

Stellt ein XML-Dokument dar.Represents an XML document. Sie können diese Klasse zum Laden, Überprüfen, Bearbeiten, Hinzufügen und Positionieren von XML in einem Dokument verwenden.You can use this class to load, validate, edit, add, and position XML in a document.

public ref class XmlDocument : System::Xml::XmlNode
public class XmlDocument : System.Xml.XmlNode
type XmlDocument = class
    inherit XmlNode
Public Class XmlDocument
Inherits XmlNode
Vererbung
XmlDocumentXmlDocumentXmlDocumentXmlDocument
Abgeleitet

Hinweise

Bei XmlDocument der-Klasse handelt es sich um eine Speicher interne Darstellung eines XML-Dokuments.The XmlDocument class is an in-memory representation of an XML document. Es implementiert die W3C- XML-Dokumentobjektmodell (DOM) Level 1 Core und das DOM Level 2 (DOM).It implements the W3C XML Document Object Model (DOM) Level 1 Core and the Core DOM Level 2.

DOM steht für das Dokument Objektmodell.DOM stands for document object model. Weitere Informationen hierzu finden Sie unter XML Dokumentobjektmodell (DOM).To read more about it, see XML Document Object Model (DOM).

Sie können XML in das DOM laden, indem Sie XmlDocument die-Klasse verwenden und dann Programm gesteuert XML-Code im Dokument lesen, ändern und entfernen.You can load XML into the DOM by using the XmlDocument class, and then programmatically read, modify, and remove XML in the document.

Wenn Sie die XmlDocument -Klasse öffnen und sehen möchten, wie Sie implementiert wird, finden Sie weitere Informationen unter Verweis Quelle.If you want to pry open the XmlDocument class and see how it's implemented, see the Reference Source.

AufgabenTasks

Laden von XML in das Dokument ObjektmodellLoad XML into the document object model

Beginnen Sie mit einem XML-Dokument wie diesem mit einigen Büchern in einer Auflistung.Start with an XML document like this one that has a few books in a collection. Sie enthält die grundlegenden Dinge, die Sie in einem beliebigen XML-Dokument finden, einschließlich eines Namespaces, Elemente, die Daten darstellen, und Attributen, die die Daten beschreiben.It contains the basic things that you'd find in any XML document, including a namespace, elements that represent data, and attributes that describe the 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>  

Als Nächstes laden Sie diese Daten in das DOM, damit Sie im Arbeitsspeicher damit arbeiten können.Next, load this data into the DOM so that you can work with it in memory. Die gängigste Methode hierfür ist das verweisen auf eine Datei auf dem lokalen Computer oder in einem Netzwerk.The most popular way to do this is refer to a file on your local computer or on a network.

In diesem Beispiel wird XML aus einer Datei geladen.This example loads XML from a file. Wenn die Datei nicht vorhanden ist, generiert Sie lediglich XML und lädt Sie.If the file doesn't exist, it just generates some XML and loads that.

XmlDocument ^doc = gcnew XmlDocument();
doc->PreserveWhitespace = true;
try
{doc->Load("booksData.xml");}
catch (System::IO::FileNotFoundException ^e1)
{
    // If no book is found, generate some XML.

    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>");
}
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

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen: Einlesen eines XML-Dokuments in das DOMLearn more: Reading an XML Document into the DOM

Überprüfen anhand eines SchemasValidate it against a schema

Beginnen Sie mit einem XML-Schema, das wie folgt aussieht.Start with an XML schema like this one. Dieses Schema definiert die Datentypen im XML-Format und welche Attribute erforderlich sind.This schema defines the data types in the XML and which attributes are required.

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

Erstellen Sie XmlReader ein-Objekt, indem Sie das Schema verwenden, und laden Sie das Objekt dann in das DOM.Create an XmlReader object by using your schema, and then load that object into the DOM. Erstellen Sie einen Ereignishandler, der ausgeführt wird, wenn der Code versucht, die XML-Datei so zu ändern, dass Sie die Regeln des Schemas verletzen.Create an event handler that executes when code attempts to modify your XML file in ways that violate the rules of the schema.

Diese Code Blöcke zeigen Hilfsmethoden, die all dies tun.These blocks of code show helper methods that do all of this.

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************

XmlDocument ^XMLDOMProcessing::XMLHelperMethods::LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader ^reader;

    XmlReaderSettings ^settings = gcnew XmlReaderSettings();

    // Helper method to retrieve schema.
    XmlSchema ^schema = getSchema(generateSchema);
    
    if (schema == nullptr)
    {
        return nullptr;
    }

    settings->Schemas->Add(schema);
    settings->ValidationEventHandler +=
        gcnew System::Xml::Schema::ValidationEventHandler
        (this, &XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler);
    settings->ValidationFlags = settings->ValidationFlags | XmlSchemaValidationFlags::ReportValidationWarnings;
    settings->ValidationType = ValidationType::Schema;

    try
    {
        reader = XmlReader::Create("booksData.xml", settings);
    }
    catch (System::IO::FileNotFoundException ^e1)
    {
        if (generateXML)
        {
            String ^xml = generateXMLString();
            array<Byte> ^byteArray = Encoding::UTF8->GetBytes(xml);
            MemoryStream ^stream = gcnew MemoryStream(byteArray);
            reader = XmlReader::Create(stream, settings);
        }
        else
        {
            return nullptr;
        }

    }

    XmlDocument ^doc = gcnew XmlDocument();
    doc->PreserveWhitespace = true;
    doc->Load(reader);
    reader->Close();

    return doc;
}

//************************************************************************************
//
//  Helper method that generates an XML Schema.
//
//************************************************************************************

String ^XMLDOMProcessing::XMLHelperMethods::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
//
//************************************************************************************

XmlSchema ^XMLDOMProcessing::XMLHelperMethods::getSchema(bool generateSchema)
{
    XmlSchemaSet ^xs = gcnew XmlSchemaSet();
    XmlSchema ^schema;
    try
    {
        schema = xs->Add("http://www.contoso.com/books", "booksData.xsd");
    }
    catch (System::IO::FileNotFoundException ^e1)
    {
        if (generateSchema)
        {
            String ^xmlSchemaString = generateXMLSchema();
            array<Byte> ^byteArray = Encoding::UTF8->GetBytes(xmlSchemaString);
            MemoryStream ^stream = gcnew MemoryStream(byteArray);
            XmlReader ^reader = XmlReader::Create(stream);
            schema = xs->Add("http://www.contoso.com/books", reader);
        }
        else
        {
            return nullptr;
        }

    }
    return schema;
}
//************************************************************************************
//
//  Helper method to validate the XML against the schema.
//
//************************************************************************************
bool XMLDOMProcessing::XMLHelperMethods::validateXML(bool generateSchema, XmlDocument ^doc)
{
    if (doc->Schemas->Count == 0)
    {
        // Helper method to retrieve schema.
        XmlSchema ^schema = getSchema(generateSchema);
        doc->Schemas->Add(schema);
    }

    ValidationEventHandler^ eventHandler = gcnew System::Xml::Schema::ValidationEventHandler
        (this, &XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler);

    // Use an event handler to validate the XML node against the schema.
    doc->Validate(eventHandler);

    if (_IsValid == false)
    {
        _IsValid = true;
        return false;
    }
    else
    {
        return true;
    }

}
//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************

void XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler(System::Object ^sender, System::Xml::Schema::ValidationEventArgs ^e)
{
    if (e->Severity == XmlSeverityType::Warning)
    {
        // do nothing.
    }
    else if (e->Severity == XmlSeverityType::Error)
    {
        // set some global variables.
        _IsValid = false;
        ValidationError = e->Message;
    }
}

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************
public XmlDocument LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader reader;

    XmlReaderSettings settings = new XmlReaderSettings();

    // Helper method to retrieve schema.
    XmlSchema schema = getSchema(generateSchema);

    if (schema == null)
    {
        return null;
    }

    settings.Schemas.Add(schema);

    settings.ValidationEventHandler += settings_ValidationEventHandler;
    settings.ValidationFlags =
        settings.ValidationFlags | XmlSchemaValidationFlags.ReportValidationWarnings;
    settings.ValidationType = ValidationType.Schema;

    try
    {
        reader = XmlReader.Create("booksData.xml", settings);
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateXML)
        {
            string xml = generateXMLString();
            byte[] byteArray = Encoding.UTF8.GetBytes(xml);
            MemoryStream stream = new MemoryStream(byteArray);
            reader = XmlReader.Create(stream, settings);
        }
        else
        {
            return null;
        }

    }

    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;
    try
    {
        schema = xs.Add("http://www.contoso.com/books", "booksData.xsd");
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateSchema)
        {
            string xmlSchemaString = generateXMLSchema();
            byte[] byteArray = Encoding.UTF8.GetBytes(xmlSchemaString);
            MemoryStream stream = new MemoryStream(byteArray);
            XmlReader reader = XmlReader.Create(stream);
            schema = xs.Add("http://www.contoso.com/books", reader);
        }
        else
        {
            return null;
        }

    }
    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 an event handler to validate the XML node against the schema.
    doc.Validate(settings_ValidationEventHandler);

}

//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************
void settings_ValidationEventHandler(object sender,
    System.Xml.Schema.ValidationEventArgs e)
{
    if (e.Severity == XmlSeverityType.Warning)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following validation warning occurred: " + e.Message);
    }
    else if (e.Severity == XmlSeverityType.Error)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following critical validation errors occurred: " + e.Message);
        Type objectType = sender.GetType();
    }

}
'************************************************************************************
'
'  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

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen: Validieren eines XML-Dokuments im DOMLearn more: Validating an XML Document in the DOM

Sie können Eigenschaften verwenden, um um ein XML-Dokument zu navigieren.You can use properties to navigate around an XML document. Bevor Sie eine dieser Komponenten verwenden, können Sie sich schnell mit einigen Begriffen auseinandersetzen.But before you use any of them, let's quickly review a few terms. Ihr Dokument besteht aus Knoten.Your document is composed of nodes. Jeder Knoten verfügt über einen direkt oberhalb über geordneten Knoten.Each node has as single parent node directly above it. Der einzige Knoten, der über keinen übergeordneten Knoten verfügt, ist der Stamm des Dokuments, da er der Knoten der obersten Ebene ist.The only node that does not have a parent node is the document root, as it is the top-level node. Die meisten Knoten können ** über untergeordnete Knoten verfügen, die direkt unterhalb der Knoten liegen.Most nodes can have child nodes, which are nodes directly below them. Knoten, die sich auf derselben Ebene befinden **, sind gleich geordnete Knoten.Nodes that are at the same level are siblings.

In den folgenden Beispielen wird veranschaulicht, wie Sie den Stamm Knoten abrufen, zum ersten untergeordneten Knoten des Stamm Knotens springen, auf alle untergeordneten Knoten zugreifen, den übergeordneten Knoten zurückkehren und dann über neben geordnete Knoten navigieren.The following examples show you how to obtain the root node, jump to the first child node of the root node, access any of its child nodes, get back out to the parent node, and then navigate across sibling nodes.

Mit dem Stamm Knoten beginnenStart with the root node

In diesem Beispiel wird der Stamm Knoten abgerufen und anschließend verwendet, um den Inhalt des Dokuments an die Konsole auszugeben.This example gets the root node and then uses that node to output the contents of the document to the console.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   
   //Create the XmlDocument.
   XmlDocument^ doc = gcnew 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 );
}

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
Option Explicit

Imports System.IO
Imports System.Xml

Public Class Sample
    
    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

Untergeordnete Knoten erhaltenGet child nodes

Dieses Beispiel springt zum ersten untergeordneten Knoten des Stamm Knotens und durchläuft dann die untergeordneten Knoten dieses Knotens, sofern vorhanden.This example jumps to the first child node of the root node and then iterates through the child nodes of that node if any exist.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;

int main()
{
   XmlDocument^ doc = gcnew 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 );
      }
   }
}
using System;
using System.IO;
using System.Xml;

public class Sample {

  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

Zurück zum übergeordneten KnotenGet back to the parent node

Verwenden Sie die ParentNode-Eigenschaft.Use the ParentNode property.

Siehe den letzten untergeordneten Knoten.Refer to the last child node

In diesem Beispiel wird der Preis eines Buchs in die Konsole geschrieben.This example writes the price of a book to the console. Der Preis Knoten ist das letzte untergeordnete Element eines Book-Knotens.The price node is the last child of a book node.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew 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 );
}

using System;
using System.IO;
using System.Xml;

public class Sample {

  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
Option Strict

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
        
        Console.WriteLine("Display the price element...")
        Console.WriteLine(root.LastChild.OuterXml)
    End Sub
End Class

Vorwärtsnavigation über gleich geordnete ElementeNavigate forward across siblings

Dieses Beispiel wechselt von Book zu Book.This example moves forward from book to book. Buch Knoten sind gleich geordnete Knoten.Book nodes are siblings to one another.

#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew 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 );
}

using System;
using System.Xml;

public class Sample {

  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 Sample 

  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

Rückwärts Navigation zwischen gleich geordneten ElementenNavigate backwards across siblings

Dieses Beispiel wechselt rückwärts von Book zu Book.This example moves backwards from book to book.

#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew 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 );
}

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 Sample 

  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

Knoten suchenFind nodes

Die gängigste Methode, um einen oder mehrere Knoten von Daten zu finden, ist die Verwendung einer XPath-Abfrage Zeichenfolge, aber es gibt auch Methoden, die keine solche Knoten erfordern.The most popular way to find one or more nodes of data is to use an XPath query string, but there are also methods that don't require one.

Einen einzelnen Knoten erhaltenGet a single node

In diesem Beispiel wird ein Buch mit der ISBN-Nummer angezeigt.This example locates a book by using the ISBN number.

XmlNode ^XMLDOMProcessing::XMLHelperMethods::GetBook(String ^uniqueAttribute, XmlDocument ^doc)
{
    XmlNamespaceManager ^nsmgr = gcnew 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 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

Die in diesem Beispiel verwendete Zeichenfolge ist eine XPath-Abfrage.The string used in this example is an Xpath query. Weitere Beispiele hierfür finden Sie hier: XPath-Beispiele.You can find more examples of them here: XPath examples.

Sie können auch zum Abrufen GetElementById von Knoten verwenden.You can also use the GetElementById to retrieve nodes. Um diesen Ansatz zu verwenden, müssen Sie IDs in den Dokumenttyp-Definitions Deklarationen der XML-Datei definieren.To use this approach, you'll have to define ID's in the document type definition declarations of your XML file.

Nachdem Sie einen Knoten erhalten haben, erhalten Sie den Wert von Attributen oder untergeordneten Knoten.After you get a node, you get the value of attributes or child nodes. In diesem Beispiel wird dies mit einem book-Knoten erledigt.This example does that with a book node.

void XMLDOMProcessing::XMLHelperMethods::GetBookInformation
(String ^%title, String ^%ISBN, String ^%publicationDate, String ^%price, String ^%genre, XmlNode ^book)
{
    XmlElement ^bookElement = safe_cast<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 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

Sammlung von KnotenGet a collection of nodes

In diesem Beispiel werden alle Bücher ausgewählt, bei denen der Nachname des Autors Austenist, und dann der Preis dieser Bücher geändert wird.This example selects all books where the author's last name is Austen, and then changes the price of those books.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew 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.
   System::Collections::IEnumerator^ myEnum = nodeList->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      XmlNode^ book = safe_cast<XmlNode^>(myEnum->Current);
      book->LastChild->InnerText = "15.95";
   }

   Console::WriteLine( "Display the modified XML document...." );
   doc->Save( Console::Out );
}

using System;
using System.IO;
using System.Xml;

public class Sample {

  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

Sie können auch eine Sammlung von Knoten mithilfe des Namens des Knotens erhalten.You can also get a collection of nodes by using the name of the node. In diesem Beispiel wird z. b. eine Sammlung aller Buchtitel abgerufen.For example, this example gets a collection of all book titles.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;

int main()
{
   //Create the XmlDocument.
   XmlDocument^ doc = gcnew 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 );
   }
}
using System;
using System.IO;
using System.Xml;

public class Sample
{
  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
Option Strict

Imports System.IO
Imports System.Xml

Public Class Sample
    
    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

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen: Auswählen von Knoten mithilfe der XPath-NavigationLearn more: Select Nodes Using XPath Navigation

Knoten bearbeitenEdit nodes

In diesem Beispiel werden ein Buch Knoten und seine Attribute bearbeitet.This example edits a book node and its attributes.

bool XMLDOMProcessing::XMLHelperMethods::editBook(String ^title, String ^ISBN, String ^publicationDate, String ^genre, String ^price, XmlNode ^book, bool validateNode, bool generateSchema)
{

    XmlElement ^bookElement = safe_cast<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)
    {
        if (validateXML(generateSchema, bookElement->OwnerDocument))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    return true;
}
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

Weitere Informationen: Ändern von Knoten, Inhalten und Werten in einem XML-DokumentLearn more: Modifying Nodes, Content, and Values in an XML Document

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Knoten hinzufügenAdd nodes

Um einen Knoten hinzuzufügen, verwenden CreateElement Sie die- CreateNode Methode oder die-Methode.To add a node, use the CreateElement method or the CreateNode method.

Verwenden Sie die CreateElement -Methode, um einen Datenknoten wie z. b. ein Buch hinzuzufügen.To add a data node such as a book, use the CreateElement method.

Verwenden Sie für jeden anderen Knotentyp, z. b. einen Kommentar, einen Leerraum Knoten oder einen CDATA-Knoten, die CreateNode -Methode.For any other type of node such as a comment, whitespace node, or CDATA node, use the CreateNode method.

In diesem Beispiel wird ein Buch Knoten erstellt, dem Knoten Attribute hinzugefügt und dann der Knoten dem Dokument hinzugefügt.This example creates a book node, adds attributes to that node, and then adds that node to the document.

XmlElement ^XMLDOMProcessing::XMLHelperMethods::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 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

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen: Einfügen von Knoten in ein XML-DokumentLearn more: Inserting Nodes into an XML Document

Entfernen von KnotenRemove nodes

Um einen Knoten zu entfernen, verwenden RemoveChild Sie die-Methode.To remove a node, use the RemoveChild method.

In diesem Beispiel wird ein Buch aus dem Dokument und alle Leerzeichen entfernt, die direkt vor dem Buch Knoten angezeigt werden.This example removes a book from the document and any whitespace that appears just before the book node.

void XMLDOMProcessing::XMLHelperMethods::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 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

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen: Entfernen von Knoten, Inhalten und Werten aus einem XML-DokumentLearn more: Removing Nodes, Content, and Values from an XML Document

Positions KnotenPosition nodes

Mithilfe der InsertBefore Methoden und InsertAfter können Sie auswählen, wo ein Knoten in Ihrem Dokument angezeigt werden soll.You can choose where you want a node to appear in your document by using the InsertBefore and InsertAfter methods.

Dieses Beispiel zeigt zwei Hilfsmethoden.This example shows two helper methods. Einer von Ihnen verschiebt einen Knoten in einer Liste nach oben.One of them moves a node higher in a list. Der andere verschiebt einen Knoten nach unten.The other one moves a node lower.

Diese Methoden können in einer Anwendung verwendet werden, die es Benutzern ermöglicht, Bücher in einer Liste von Büchern nach oben oder unten zu verschieben.These methods could be used in an application that enables users to move books up and down in a list of books. Wenn ein Benutzer ein Buch auswählt und eine nach-oben-oder nach-unten-Taste drückt, könnte der Code Methoden wie diese aufzurufen, um den entsprechenden Buch Knoten vor oder nach anderen Buch Knoten zu positionieren.When a user chooses a book and presses an up or down button, your code could call methods like these to position the corresponding book node before or after other book nodes.

//************************************************************************************
//
//  Summary: Move elements up in the XML.
//  
//
//************************************************************************************
void XMLDOMProcessing::XMLHelperMethods::MoveElementUp(XmlNode ^book)
{
    XmlNode ^previousNode = book->PreviousSibling;
    while (previousNode != nullptr && (previousNode->NodeType != XmlNodeType::Element))
    {
        previousNode = previousNode->PreviousSibling;
    }
    if (previousNode != nullptr)
    {
        XmlNode ^newLineNode = book->NextSibling;
        book->OwnerDocument->DocumentElement->RemoveChild(book);
        if (newLineNode->NodeType == XmlNodeType::Whitespace || newLineNode->NodeType == XmlNodeType::SignificantWhitespace)
        {
            newLineNode->OwnerDocument->DocumentElement->RemoveChild(newLineNode);
        }
        InsertBookElement(safe_cast<XmlElement^>(book), Constants::positionAbove, previousNode, false, false);
    }
}

//************************************************************************************
//
//  Summary: Move elements down in the XML.
//  
//
//************************************************************************************
void XMLDOMProcessing::XMLHelperMethods::MoveElementDown(XmlNode ^book)
{
    // Walk backwards until we find an element - ignore text nodes
    XmlNode ^NextNode = book->NextSibling;
    while (NextNode != nullptr && (NextNode->NodeType != XmlNodeType::Element))
    {
        NextNode = NextNode->NextSibling;
    }
    if (NextNode != nullptr)
    {
        XmlNode ^newLineNode = book->PreviousSibling;
        book->OwnerDocument->DocumentElement->RemoveChild(book);
        if (newLineNode->NodeType == XmlNodeType::Whitespace || newLineNode->NodeType == XmlNodeType::SignificantWhitespace)
        {
            newLineNode->OwnerDocument->DocumentElement->RemoveChild(newLineNode);
        }

        InsertBookElement(safe_cast<XmlElement^>(book), Constants::positionBelow, NextNode, false, false);
    }

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

Complete Sample: Bearbeiten von XML im Speicher mithilfe der XmlDocument-Klasse und anderer verwandter TypenComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Konstruktoren

XmlDocument() XmlDocument() XmlDocument() XmlDocument()

Initialisiert eine neue Instanz der XmlDocument-Klasse.Initializes a new instance of the XmlDocument class.

XmlDocument(XmlImplementation) XmlDocument(XmlImplementation) XmlDocument(XmlImplementation) XmlDocument(XmlImplementation)

Initialisiert eine neue Instanz der XmlDocument-Klasse mit der angegebenen XmlImplementation.Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

XmlDocument(XmlNameTable) XmlDocument(XmlNameTable) XmlDocument(XmlNameTable) XmlDocument(XmlNameTable)

Initialisiert eine neue Instanz der XmlDocument-Klasse mit der angegebenen XmlNameTable.Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

Eigenschaften

Attributes Attributes Attributes Attributes

Ruft eine XmlAttributeCollection ab, die die Attribute dieses Knotens enthält.Gets an XmlAttributeCollection containing the attributes of this node.

(Inherited from XmlNode)
BaseURI BaseURI BaseURI BaseURI

Ruft den Basis-URI des aktuellen Knotens ab.Gets the base URI of the current node.

ChildNodes ChildNodes ChildNodes ChildNodes

Ruft alle untergeordneten Knoten des Knotens ab.Gets all the child nodes of the node.

(Inherited from XmlNode)
DocumentElement DocumentElement DocumentElement DocumentElement

Ruft das Stamm-XmlElement für das Dokument ab.Gets the root XmlElement for the document.

DocumentType DocumentType DocumentType DocumentType

Ruft den Knoten ab, der die DOCTYPE-Deklaration enthält.Gets the node containing the DOCTYPE declaration.

FirstChild FirstChild FirstChild FirstChild

Ruft das erste untergeordnete Element des Knotens ab.Gets the first child of the node.

(Inherited from XmlNode)
HasChildNodes HasChildNodes HasChildNodes HasChildNodes

Ruft einen Wert ab, der angibt, ob dieser Knoten über untergeordnete Knoten verfügt.Gets a value indicating whether this node has any child nodes.

(Inherited from XmlNode)
Implementation Implementation Implementation Implementation

Ruft das XmlImplementation-Objekt für das aktuelle Dokument ab.Gets the XmlImplementation object for the current document.

InnerText InnerText InnerText InnerText

Löst in allen Fällen eine InvalidOperationException aus.Throws an InvalidOperationException in all cases.

InnerXml InnerXml InnerXml InnerXml

Ruft das Markup ab, das die untergeordneten Elemente des aktuellen Knotens darstellt, oder legt dieses fest.Gets or sets the markup representing the children of the current node.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ruft einen Wert ab, der angibt, ob der aktuelle Knoten schreibgeschützt ist.Gets a value indicating whether the current node is read-only.

Item[String, String] Item[String, String] Item[String, String] Item[String, String]

Ruft das erste untergeordnete Element mit dem angegebenen LocalName und dem NamespaceURI ab.Gets the first child element with the specified LocalName and NamespaceURI.

(Inherited from XmlNode)
Item[String] Item[String] Item[String] Item[String]

Ruft das erste untergeordnete Element mit dem angegebenen Name ab.Gets the first child element with the specified Name.

(Inherited from XmlNode)
LastChild LastChild LastChild LastChild

Ruft das letzte untergeordnete Element des Knotens ab.Gets the last child of the node.

(Inherited from XmlNode)
LocalName LocalName LocalName LocalName

Ruft den lokalen Namen des Knotens ab.Gets the local name of the node.

Name Name Name Name

Ruft den qualifizierten Namen des Knotens ab.Gets the qualified name of the node.

NamespaceURI NamespaceURI NamespaceURI NamespaceURI

Ruft den Namespace-URI dieses Knotens ab.Gets the namespace URI of this node.

(Inherited from XmlNode)
NameTable NameTable NameTable NameTable

Ruft die XmlNameTable ab, die dieser Implementierung zugeordnet ist.Gets the XmlNameTable associated with this implementation.

NextSibling NextSibling NextSibling NextSibling

Ruft den Knoten ab, der diesem Knoten unmittelbar folgt.Gets the node immediately following this node.

(Inherited from XmlNode)
NodeType NodeType NodeType NodeType

Ruft den Typ des aktuellen Knotens ab.Gets the type of the current node.

OuterXml OuterXml OuterXml OuterXml

Ruft das Markup ab, das diesen Knoten und alle ihm untergeordneten Knoten enthält.Gets the markup containing this node and all its child nodes.

(Inherited from XmlNode)
OwnerDocument OwnerDocument OwnerDocument OwnerDocument

Ruft das XmlDocument ab, zu dem der aktuelle Knoten gehört.Gets the XmlDocument to which the current node belongs.

ParentNode ParentNode ParentNode ParentNode

Ruft den übergeordneten Knoten dieses Knotens ab (bei Knoten, die über übergeordnete Knoten verfügen können).Gets the parent node of this node (for nodes that can have parents).

Prefix Prefix Prefix Prefix

Ruft das Namespacepräfix dieses Knotens ab oder legt dieses fest.Gets or sets the namespace prefix of this node.

(Inherited from XmlNode)
PreserveWhitespace PreserveWhitespace PreserveWhitespace PreserveWhitespace

Ruft einen Wert ab, der angibt, ob der Leerraum im Elementinhalt beibehalten wird, oder legt diesen fest.Gets or sets a value indicating whether to preserve white space in element content.

PreviousSibling PreviousSibling PreviousSibling PreviousSibling

Ruft den Knoten ab, der diesem Knoten unmittelbar vorausgeht.Gets the node immediately preceding this node.

(Inherited from XmlNode)
PreviousText PreviousText PreviousText PreviousText

Ruft den Textknoten ab, der diesem Knoten unmittelbar vorausgeht.Gets the text node that immediately precedes this node.

(Inherited from XmlNode)
SchemaInfo SchemaInfo SchemaInfo SchemaInfo

Gibt das PSVI (Post-Schema-Validation Infoset) des Knotens zurück.Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

Schemas Schemas Schemas Schemas

Ruft das XmlSchemaSet-Objekt ab, das diesem XmlDocument zugeordnet ist, oder legt dieses fest.Gets or sets the XmlSchemaSet object associated with this XmlDocument.

Value Value Value Value

Ruft den Wert des Knotens ab oder legt diesen fest.Gets or sets the value of the node.

(Inherited from XmlNode)
XmlResolver XmlResolver XmlResolver XmlResolver

Legt den für die Auflösung externer Ressourcen zu verwendenden XmlResolver fest.Sets the XmlResolver to use for resolving external resources.

Methoden

AppendChild(XmlNode) AppendChild(XmlNode) AppendChild(XmlNode) AppendChild(XmlNode)

Fügt den angegebenen Knoten am Ende der Liste der untergeordneten Knoten dieses Knotens hinzu.Adds the specified node to the end of the list of child nodes, of this node.

(Inherited from XmlNode)
Clone() Clone() Clone() Clone()

Erstellt ein Duplikat dieses Knotens.Creates a duplicate of this node.

(Inherited from XmlNode)
CloneNode(Boolean) CloneNode(Boolean) CloneNode(Boolean) CloneNode(Boolean)

Erstellt ein Duplikat dieses Knotens.Creates a duplicate of this node.

CreateAttribute(String) CreateAttribute(String) CreateAttribute(String) CreateAttribute(String)

Erstellt ein XmlAttribute mit dem angegebenen Name.Creates an XmlAttribute with the specified Name.

CreateAttribute(String, String) CreateAttribute(String, String) CreateAttribute(String, String) CreateAttribute(String, String)

Erstellt ein XmlAttribute mit dem angegebenen qualifizierten Namen und dem angegebenen NamespaceURI.Creates an XmlAttribute with the specified qualified name and NamespaceURI.

CreateAttribute(String, String, String) CreateAttribute(String, String, String) CreateAttribute(String, String, String) CreateAttribute(String, String, String)

Erstellt einen XmlAttribute mit dem angegebenen Prefix, LocalName und NamespaceURI.Creates an XmlAttribute with the specified Prefix, LocalName, and NamespaceURI.

CreateCDataSection(String) CreateCDataSection(String) CreateCDataSection(String) CreateCDataSection(String)

Erstellt einen XmlCDataSection, der die angegebenen Daten enthält.Creates an XmlCDataSection containing the specified data.

CreateComment(String) CreateComment(String) CreateComment(String) CreateComment(String)

Erstellt einen XmlComment, der die angegebenen Daten enthält.Creates an XmlComment containing the specified data.

CreateDefaultAttribute(String, String, String) CreateDefaultAttribute(String, String, String) CreateDefaultAttribute(String, String, String) CreateDefaultAttribute(String, String, String)

Erstellt ein Standardattribut mit dem angegebenen Präfix, lokalen Namen und Namespace-URI.Creates a default attribute with the specified prefix, local name and namespace URI.

CreateDocumentFragment() CreateDocumentFragment() CreateDocumentFragment() CreateDocumentFragment()

Erstellt ein XmlDocumentFragment.Creates an XmlDocumentFragment.

CreateDocumentType(String, String, String, String) CreateDocumentType(String, String, String, String) CreateDocumentType(String, String, String, String) CreateDocumentType(String, String, String, String)

Gibt ein neues XmlDocumentType-Objekt zurück.Returns a new XmlDocumentType object.

CreateElement(String) CreateElement(String) CreateElement(String) CreateElement(String)

Erstellt ein Element mit dem angegebenen Namen.Creates an element with the specified name.

CreateElement(String, String) CreateElement(String, String) CreateElement(String, String) CreateElement(String, String)

Erstellt ein XmlElement mit dem qualifizierten Namen und dem NamespaceURI.Creates an XmlElement with the qualified name and NamespaceURI.

CreateElement(String, String, String) CreateElement(String, String, String) CreateElement(String, String, String) CreateElement(String, String, String)

Erstellt ein Element mit dem angegebenen Prefix, LocalName und der NamespaceURI.Creates an element with the specified Prefix, LocalName, and NamespaceURI.

CreateEntityReference(String) CreateEntityReference(String) CreateEntityReference(String) CreateEntityReference(String)

Erstellt eine XmlEntityReference mit dem angegebenen Namen.Creates an XmlEntityReference with the specified name.

CreateNavigator() CreateNavigator() CreateNavigator() CreateNavigator()

Erstellt ein neues XPathNavigator-Objekt zum Navigieren in diesem Dokument.Creates a new XPathNavigator object for navigating this document.

CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode)

Erstellt ein XPathNavigator-Objekt zum Navigieren in diesem Dokument, das auf dem angegebenen XmlNode positioniert ist.Creates an XPathNavigator object for navigating this document positioned on the XmlNode specified.

CreateNode(String, String, String) CreateNode(String, String, String) CreateNode(String, String, String) CreateNode(String, String, String)

Erstellt einen XmlNode mit dem angegebenen Knotentyp, Name und NamespaceURI.Creates an XmlNode with the specified node type, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String) CreateNode(XmlNodeType, String, String) CreateNode(XmlNodeType, String, String) CreateNode(XmlNodeType, String, String)

Erstellt einen XmlNode mit dem angegebenen XmlNodeType, Name und NamespaceURI.Creates an XmlNode with the specified XmlNodeType, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String, String) CreateNode(XmlNodeType, String, String, String) CreateNode(XmlNodeType, String, String, String) CreateNode(XmlNodeType, String, String, String)

Erstellt einen XmlNode mit dem angegebenen XmlNodeType, Prefix, Name und NamespaceURI.Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.

CreateProcessingInstruction(String, String) CreateProcessingInstruction(String, String) CreateProcessingInstruction(String, String) CreateProcessingInstruction(String, String)

Erstellt eine XmlProcessingInstruction mit dem angegebenen Namen und den angegebenen Daten.Creates an XmlProcessingInstruction with the specified name and data.

CreateSignificantWhitespace(String) CreateSignificantWhitespace(String) CreateSignificantWhitespace(String) CreateSignificantWhitespace(String)

Erstellt einen XmlSignificantWhitespace-Knoten.Creates an XmlSignificantWhitespace node.

CreateTextNode(String) CreateTextNode(String) CreateTextNode(String) CreateTextNode(String)

Erstellt einen XmlText mit dem angegebenen Text.Creates an XmlText with the specified text.

CreateWhitespace(String) CreateWhitespace(String) CreateWhitespace(String) CreateWhitespace(String)

Erstellt einen XmlWhitespace-Knoten.Creates an XmlWhitespace node.

CreateXmlDeclaration(String, String, String) CreateXmlDeclaration(String, String, String) CreateXmlDeclaration(String, String, String) CreateXmlDeclaration(String, String, String)

Erstellt einen XmlDeclaration-Knoten mit den angegebenen Werten.Creates an XmlDeclaration node with the specified values.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetElementById(String) GetElementById(String) GetElementById(String) GetElementById(String)

Ruft das XmlElement mit der angegebenen ID ab.Gets the XmlElement with the specified ID.

GetElementsByTagName(String) GetElementsByTagName(String) GetElementsByTagName(String) GetElementsByTagName(String)

Gibt eine XmlNodeList mit einer Liste aller untergeordneten Elemente zurück, die mit dem angegebenen Name übereinstimmen.Returns an XmlNodeList containing a list of all descendant elements that match the specified Name.

GetElementsByTagName(String, String) GetElementsByTagName(String, String) GetElementsByTagName(String, String) GetElementsByTagName(String, String)

Gibt eine XmlNodeList mit einer Liste aller untergeordneten Elemente zurück, die mit dem angegebenen LocalName und NamespaceURI übereinstimmen.Returns an XmlNodeList containing a list of all descendant elements that match the specified LocalName and NamespaceURI.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Ruft einen Enumerator ab, der die untergeordneten Knoten des aktuellen Knotens durchläuft.Gets an enumerator that iterates through the child nodes in the current node.

(Inherited from XmlNode)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetNamespaceOfPrefix(String) GetNamespaceOfPrefix(String) GetNamespaceOfPrefix(String) GetNamespaceOfPrefix(String)

Sucht im Gültigkeitsbereich des aktuellen Knotens die nächstgelegene xmlns-Deklaration für das angegebene Präfix und gibt den Namespace-URI in der Deklaration zurück.Looks up the closest xmlns declaration for the given prefix that is in scope for the current node and returns the namespace URI in the declaration.

(Inherited from XmlNode)
GetPrefixOfNamespace(String) GetPrefixOfNamespace(String) GetPrefixOfNamespace(String) GetPrefixOfNamespace(String)

Sucht im Gültigkeitsbereich des aktuellen Knotens die nächstgelegene xmlns-Deklaration für den angegebenen Namespace-URI und gibt das in dieser Deklaration definierte Präfix zurück.Looks up the closest xmlns declaration for the given namespace URI that is in scope for the current node and returns the prefix defined in that declaration.

(Inherited from XmlNode)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
ImportNode(XmlNode, Boolean) ImportNode(XmlNode, Boolean) ImportNode(XmlNode, Boolean) ImportNode(XmlNode, Boolean)

Importiert einen Knoten aus einem anderen Dokument in das aktuelle Dokument.Imports a node from another document to the current document.

InsertAfter(XmlNode, XmlNode) InsertAfter(XmlNode, XmlNode) InsertAfter(XmlNode, XmlNode) InsertAfter(XmlNode, XmlNode)

Fügt den angegebenen Knoten unmittelbar hinter dem angegebenen Verweisknoten ein.Inserts the specified node immediately after the specified reference node.

(Inherited from XmlNode)
InsertBefore(XmlNode, XmlNode) InsertBefore(XmlNode, XmlNode) InsertBefore(XmlNode, XmlNode) InsertBefore(XmlNode, XmlNode)

Fügt den angegebenen Knoten direkt vor dem angegebenen Verweisknoten ein.Inserts the specified node immediately before the specified reference node.

(Inherited from XmlNode)
Load(Stream) Load(Stream) Load(Stream) Load(Stream)

Lädt das XML-Dokument aus dem angegebenen Stream.Loads the XML document from the specified stream.

Load(String) Load(String) Load(String) Load(String)

Lädt das XML-Dokument aus der angegebenen URL.Loads the XML document from the specified URL.

Load(TextReader) Load(TextReader) Load(TextReader) Load(TextReader)

Lädt das XML-Dokument aus dem angegebenen TextReader.Loads the XML document from the specified TextReader.

Load(XmlReader) Load(XmlReader) Load(XmlReader) Load(XmlReader)

Lädt das XML-Dokument aus dem angegebenen XmlReader.Loads the XML document from the specified XmlReader.

LoadXml(String) LoadXml(String) LoadXml(String) LoadXml(String)

Lädt das XML-Dokument aus der angegebenen Zeichenfolge.Loads the XML document from the specified string.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Weist allen XmlText-Knoten in der Teilstruktur unterhalb dieses XmlNode eine „normale“ Form zu. In dieser werden XmlText-Knoten nur durch Markup (d. h. Tags, Kommentare, Verarbeitungsanweisungen, CDATA-Abschnitte und Entitätsverweise) getrennt, und es sind somit keine direkt aufeinander folgenden XmlText-Knoten vorhanden.Puts all XmlText nodes in the full depth of the sub-tree underneath this XmlNode into a "normal" form where only markup (that is, tags, comments, processing instructions, CDATA sections, and entity references) separates XmlText nodes, that is, there are no adjacent XmlText nodes.

(Inherited from XmlNode)
PrependChild(XmlNode) PrependChild(XmlNode) PrependChild(XmlNode) PrependChild(XmlNode)

Fügt den angegebenen Knoten am Anfang der Liste der untergeordneten Knoten dieses Knotens hinzu.Adds the specified node to the beginning of the list of child nodes for this node.

(Inherited from XmlNode)
ReadNode(XmlReader) ReadNode(XmlReader) ReadNode(XmlReader) ReadNode(XmlReader)

Erstellt anhand der Informationen im XmlReader ein XmlNode-Objekt.Creates an XmlNode object based on the information in the XmlReader. Der Reader muss auf einem Knoten oder Attribut positioniert sein.The reader must be positioned on a node or attribute.

RemoveAll() RemoveAll() RemoveAll() RemoveAll()

Entfernt alle untergeordneten Knoten bzw. Attribute des aktuellen Knotens.Removes all the child nodes and/or attributes of the current node.

(Inherited from XmlNode)
RemoveChild(XmlNode) RemoveChild(XmlNode) RemoveChild(XmlNode) RemoveChild(XmlNode)

Entfernt den angegebenen untergeordneten Knoten.Removes specified child node.

(Inherited from XmlNode)
ReplaceChild(XmlNode, XmlNode) ReplaceChild(XmlNode, XmlNode) ReplaceChild(XmlNode, XmlNode) ReplaceChild(XmlNode, XmlNode)

Ersetzt den untergeordneten oldChild-Knoten durch den newChild-Knoten.Replaces the child node oldChild with newChild node.

(Inherited from XmlNode)
Save(Stream) Save(Stream) Save(Stream) Save(Stream)

Speichert das XML-Dokument im angegebenen Stream.Saves the XML document to the specified stream.

Save(String) Save(String) Save(String) Save(String)

Speichert das XML-Dokument in der angegebenen Datei.Saves the XML document to the specified file. Die angegebene Datei existiert, diese Methode überschreibt sie.If the specified file exists, this method overwrites it.

Save(TextWriter) Save(TextWriter) Save(TextWriter) Save(TextWriter)

Speichert das XML-Dokument im angegebenen TextWriter.Saves the XML document to the specified TextWriter.

Save(XmlWriter) Save(XmlWriter) Save(XmlWriter) Save(XmlWriter)

Speichert das XML-Dokument im angegebenen XmlWriter.Saves the XML document to the specified XmlWriter.

SelectNodes(String) SelectNodes(String) SelectNodes(String) SelectNodes(String)

Wählt eine Liste von Knoten aus, die mit dem XPath-Ausdruck übereinstimmen.Selects a list of nodes matching the XPath expression.

(Inherited from XmlNode)
SelectNodes(String, XmlNamespaceManager) SelectNodes(String, XmlNamespaceManager) SelectNodes(String, XmlNamespaceManager) SelectNodes(String, XmlNamespaceManager)

Wählt eine Liste von Knoten aus, die mit dem XPath-Ausdruck übereinstimmen.Selects a list of nodes matching the XPath expression. Sämtliche im XPath-Ausdruck vorhandenen Präfixe werden mit dem angegebenen XmlNamespaceManager aufgelöst.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Inherited from XmlNode)
SelectSingleNode(String) SelectSingleNode(String) SelectSingleNode(String) SelectSingleNode(String)

Wählt den ersten XmlNode aus, der mit dem XPath-Ausdruck übereinstimmt.Selects the first XmlNode that matches the XPath expression.

(Inherited from XmlNode)
SelectSingleNode(String, XmlNamespaceManager) SelectSingleNode(String, XmlNamespaceManager) SelectSingleNode(String, XmlNamespaceManager) SelectSingleNode(String, XmlNamespaceManager)

Wählt den ersten XmlNode aus, der mit dem XPath-Ausdruck übereinstimmt.Selects the first XmlNode that matches the XPath expression. Sämtliche im XPath-Ausdruck vorhandenen Präfixe werden mit dem angegebenen XmlNamespaceManager aufgelöst.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Inherited from XmlNode)
Supports(String, String) Supports(String, String) Supports(String, String) Supports(String, String)

Überprüft, ob die DOM-Implementierung ein bestimmtes Funktion implementiert.Tests if the DOM implementation implements a specific feature.

(Inherited from XmlNode)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)
Validate(ValidationEventHandler) Validate(ValidationEventHandler) Validate(ValidationEventHandler) Validate(ValidationEventHandler)

Validiert das XmlDocument anhand der in der Schemas-Eigenschaft enthaltenen XSD-Schemas (XML Schema Definition).Validates the XmlDocument against the XML Schema Definition Language (XSD) schemas contained in the Schemas property.

Validate(ValidationEventHandler, XmlNode) Validate(ValidationEventHandler, XmlNode) Validate(ValidationEventHandler, XmlNode) Validate(ValidationEventHandler, XmlNode)

Validiert das angegebene XmlNode-Objekt anhand der in der Schemas-Eigenschaft enthaltenen XSD-Schemas (XML Schema Definition).Validates the XmlNode object specified against the XML Schema Definition Language (XSD) schemas in the Schemas property.

WriteContentTo(XmlWriter) WriteContentTo(XmlWriter) WriteContentTo(XmlWriter) WriteContentTo(XmlWriter)

Speichert alle untergeordneten Elemente des XmlDocument-Knotens im angegebenen XmlWriter.Saves all the children of the XmlDocument node to the specified XmlWriter.

WriteTo(XmlWriter) WriteTo(XmlWriter) WriteTo(XmlWriter) WriteTo(XmlWriter)

Speichert den XmlDocument-Knoten im angegebenen XmlWriter.Saves the XmlDocument node to the specified XmlWriter.

Ereignisse

NodeChanged NodeChanged NodeChanged NodeChanged

Tritt ein, wenn der Value eines zu diesem Dokument gehörenden Knotens geändert wurde.Occurs when the Value of a node belonging to this document has been changed.

NodeChanging NodeChanging NodeChanging NodeChanging

Tritt ein, wenn der Value eines zu diesem Dokument gehörenden Knotens gerade geändert wird.Occurs when the Value of a node belonging to this document is about to be changed.

NodeInserted NodeInserted NodeInserted NodeInserted

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten in einen anderen Knoten eingefügt wurde.Occurs when a node belonging to this document has been inserted into another node.

NodeInserting NodeInserting NodeInserting NodeInserting

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten gerade in einen anderen Knoten eingefügt wird.Occurs when a node belonging to this document is about to be inserted into another node.

NodeRemoved NodeRemoved NodeRemoved NodeRemoved

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten aus dem übergeordneten Element entfernt wurde.Occurs when a node belonging to this document has been removed from its parent.

NodeRemoving NodeRemoving NodeRemoving NodeRemoving

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten gerade aus dem Dokument entfernt wird.Occurs when a node belonging to this document is about to be removed from the document.

Explizite Schnittstellenimplementierungen

ICloneable.Clone() ICloneable.Clone() ICloneable.Clone() ICloneable.Clone()

Eine Beschreibung dieses Elements finden Sie unter Clone().For a description of this member, see Clone().

(Inherited from XmlNode)
IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Eine Beschreibung dieses Members finden Sie unter GetEnumerator().For a description of this member, see GetEnumerator().

(Inherited from XmlNode)

Erweiterungsmethoden

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

CreateNavigator(XmlDocument) CreateNavigator(XmlDocument) CreateNavigator(XmlDocument) CreateNavigator(XmlDocument)
CreateNavigator(XmlDocument, XmlNode) CreateNavigator(XmlDocument, XmlNode) CreateNavigator(XmlDocument, XmlNode) CreateNavigator(XmlDocument, XmlNode)
CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode) CreateNavigator(XmlNode)
SelectNodes(XmlNode, String) SelectNodes(XmlNode, String) SelectNodes(XmlNode, String) SelectNodes(XmlNode, String)
SelectNodes(XmlNode, String, XmlNamespaceManager) SelectNodes(XmlNode, String, XmlNamespaceManager) SelectNodes(XmlNode, String, XmlNamespaceManager) SelectNodes(XmlNode, String, XmlNamespaceManager)
SelectSingleNode(XmlNode, String) SelectSingleNode(XmlNode, String) SelectSingleNode(XmlNode, String) SelectSingleNode(XmlNode, String)
SelectSingleNode(XmlNode, String, XmlNamespaceManager) SelectSingleNode(XmlNode, String, XmlNamespaceManager) SelectSingleNode(XmlNode, String, XmlNamespaceManager) SelectSingleNode(XmlNode, String, XmlNamespaceManager)
ToXPathNavigable(XmlNode) ToXPathNavigable(XmlNode) ToXPathNavigable(XmlNode) ToXPathNavigable(XmlNode)

Gilt für:

Siehe auch