Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

XmlDocument-Klasse

 

Veröffentlicht: August 2016

Stellt ein XML-Dokument dar. Sie können diese Klasse zum Laden, Überprüfen, Bearbeiten, Hinzufügen und Positionieren von XML in einem Dokument verwenden.

Namespace:   System.Xml
Assembly:  System.Xml (in System.Xml.dll)


public class XmlDocument : XmlNode

NameBeschreibung
System_CAPS_pubmethodXmlDocument()

Initialisiert eine neue Instanz der XmlDocument-Klasse.

System_CAPS_protmethodXmlDocument(XmlImplementation)

Initialisiert eine neue Instanz der XmlDocument-Klasse mit der angegebenen XmlImplementation.

System_CAPS_pubmethodXmlDocument(XmlNameTable)

Initialisiert eine neue Instanz der XmlDocument-Klasse mit der angegebenen XmlNameTable.

NameBeschreibung
System_CAPS_pubpropertyAttributes

Ruft eine XmlAttributeCollection ab, die die Attribute dieses Knotens enthält.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyBaseURI

Ruft den Basis-URI des aktuellen Knotens ab.(Überschreibt XmlNode.BaseURI.)

System_CAPS_pubpropertyChildNodes

Ruft alle untergeordneten Knoten des Knotens ab.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyDocumentElement

Ruft das Stamm-XmlElement für das Dokument ab.

System_CAPS_pubpropertyDocumentType

Ruft den Knoten ab, der die DOCTYPE-Deklaration enthält.

System_CAPS_pubpropertyFirstChild

Ruft das erste untergeordnete Element des Knotens ab.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyHasChildNodes

Ruft einen Wert ab, der angibt, ob dieser Knoten über untergeordnete Knoten verfügt.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyImplementation

Ruft das XmlImplementation-Objekt für das aktuelle Dokument ab.

System_CAPS_pubpropertyInnerText

Löst in allen Fällen eine InvalidOperationException aus.(Überschreibt XmlNode.InnerText.)

System_CAPS_pubpropertyInnerXml

Ruft das Markup ab, das die untergeordneten Elemente des aktuellen Knotens darstellt, oder legt dieses fest.(Überschreibt XmlNode.InnerXml.)

System_CAPS_pubpropertyIsReadOnly

Ruft einen Wert ab, der angibt, ob der aktuelle Knoten schreibgeschützt ist.(Überschreibt XmlNode.IsReadOnly.)

System_CAPS_pubpropertyItem[String]

Ruft das erste untergeordnete Element mit dem angegebenen Name ab.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyItem[String, String]

Ruft das erste untergeordnete Element mit dem angegebenen LocalName und dem NamespaceURI ab.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyLastChild

Ruft das letzte untergeordnete Element des Knotens ab.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyLocalName

Ruft den lokalen Namen des Knotens ab.(Überschreibt XmlNode.LocalName.)

System_CAPS_pubpropertyName

Ruft den qualifizierten Namen des Knotens ab.(Überschreibt XmlNode.Name.)

System_CAPS_pubpropertyNamespaceURI

Ruft den Namespace-URI dieses Knotens ab.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyNameTable

Ruft die XmlNameTable ab, die dieser Implementierung zugeordnet ist.

System_CAPS_pubpropertyNextSibling

Ruft den Knoten ab, der diesem Knoten unmittelbar folgt.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyNodeType

Ruft den Typ des aktuellen Knotens ab.(Überschreibt XmlNode.NodeType.)

System_CAPS_pubpropertyOuterXml

Ruft das Markup ab, das diesen Knoten und alle ihm untergeordneten Knoten enthält.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyOwnerDocument

Ruft das XmlDocument ab, zu dem der aktuelle Knoten gehört.(Überschreibt XmlNode.OwnerDocument.)

System_CAPS_pubpropertyParentNode

Ruft den übergeordneten Knoten dieses Knotens ab (bei Knoten, die über übergeordnete Knoten verfügen können).(Überschreibt XmlNode.ParentNode.)

System_CAPS_pubpropertyPrefix

Ruft das Namespacepräfix dieses Knotens ab oder legt dieses fest.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyPreserveWhitespace

Ruft einen Wert ab, der angibt, ob der Leerraum im Elementinhalt beibehalten wird, oder legt diesen fest.

System_CAPS_pubpropertyPreviousSibling

Ruft den Knoten ab, der diesem Knoten unmittelbar vorausgeht.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyPreviousText

Ruft den Textknoten ab, der diesem Knoten unmittelbar vorausgeht.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertySchemaInfo

Gibt das PSVI (Post-Schema-Validation Infoset) des Knotens zurück.(Überschreibt XmlNode.SchemaInfo.)

System_CAPS_pubpropertySchemas

Ruft das XmlSchemaSet-Objekt ab, das diesem XmlDocument zugeordnet ist, oder legt dieses fest.

System_CAPS_pubpropertyValue

Ruft den Wert des Knotens ab oder legt diesen fest.(Geerbt von „XmlNode“.)

System_CAPS_pubpropertyXmlResolver

Legt den für die Auflösung externer Ressourcen zu verwendenden XmlResolver fest.

NameBeschreibung
System_CAPS_pubmethodAppendChild(XmlNode)

Fügt den angegebenen Knoten am Ende der Liste der untergeordneten Knoten dieses Knotens hinzu.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodClone()

Erstellt ein Duplikat dieses Knotens.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodCloneNode(Boolean)

Erstellt ein Duplikat dieses Knotens.(Überschreibt XmlNode.CloneNode(Boolean).)

System_CAPS_pubmethodCreateAttribute(String)

Erstellt ein XmlAttribute mit dem angegebenen Name.

System_CAPS_pubmethodCreateAttribute(String, String)

Erstellt ein XmlAttribute mit dem angegebenen qualifizierten Namen und dem angegebenen NamespaceURI.

System_CAPS_pubmethodCreateAttribute(String, String, String)

Erstellt einen XmlAttribute mit dem angegebenen Prefix, LocalName und NamespaceURI.

System_CAPS_pubmethodCreateCDataSection(String)

Erstellt einen XmlCDataSection, der die angegebenen Daten enthält.

System_CAPS_pubmethodCreateComment(String)

Erstellt einen XmlComment, der die angegebenen Daten enthält.

System_CAPS_protmethodCreateDefaultAttribute(String, String, String)

Erstellt ein Standardattribut mit dem angegebenen Präfix, lokalen Namen und Namespace-URI.

System_CAPS_pubmethodCreateDocumentFragment()

Erstellt eine XmlDocumentFragment.

System_CAPS_pubmethodCreateDocumentType(String, String, String, String)

Gibt ein neues XmlDocumentType-Objekt zurück.

System_CAPS_pubmethodCreateElement(String)

Erstellt ein Element mit dem angegebenen Namen.

System_CAPS_pubmethodCreateElement(String, String)

Erstellt ein XmlElement mit dem qualifizierten Namen und dem NamespaceURI.

System_CAPS_pubmethodCreateElement(String, String, String)

Erstellt ein Element mit dem angegebenen Prefix, LocalName und der NamespaceURI.

System_CAPS_pubmethodCreateEntityReference(String)

Erstellt eine XmlEntityReference mit dem angegebenen Namen.

System_CAPS_pubmethodCreateNavigator()

Erstellt ein neues XPathNavigator-Objekt zum Navigieren in diesem Dokument.(Überschreibt XmlNode.CreateNavigator().)

System_CAPS_protmethodCreateNavigator(XmlNode)

Erstellt ein XPathNavigator-Objekt zum Navigieren in diesem Dokument, das auf dem angegebenen XmlNode positioniert ist.

System_CAPS_pubmethodCreateNode(String, String, String)

Erstellt einen XmlNode mit dem angegebenen Knotentyp, Name und NamespaceURI.

System_CAPS_pubmethodCreateNode(XmlNodeType, String, String)

Erstellt einen XmlNode mit dem angegebenen XmlNodeType, Name und NamespaceURI.

System_CAPS_pubmethodCreateNode(XmlNodeType, String, String, String)

Erstellt einen XmlNode mit dem angegebenen XmlNodeType, Prefix, Name und NamespaceURI.

System_CAPS_pubmethodCreateProcessingInstruction(String, String)

Erstellt eine XmlProcessingInstruction mit dem angegebenen Namen und den angegebenen Daten.

System_CAPS_pubmethodCreateSignificantWhitespace(String)

Erstellt einen XmlSignificantWhitespace-Knoten.

System_CAPS_pubmethodCreateTextNode(String)

Erstellt einen XmlText mit dem angegebenen Text.

System_CAPS_pubmethodCreateWhitespace(String)

Erstellt einen XmlWhitespace-Knoten.

System_CAPS_pubmethodCreateXmlDeclaration(String, String, String)

Erstellt einen XmlDeclaration-Knoten mit den angegebenen Werten.

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird.(Geerbt von „Object“.)

System_CAPS_pubmethodGetElementById(String)

Ruft das XmlElement mit der angegebenen ID ab.

System_CAPS_pubmethodGetElementsByTagName(String)

Gibt eine XmlNodeList mit einer Liste aller untergeordneten Elemente zurück, die mit dem angegebenen Name übereinstimmen.

System_CAPS_pubmethodGetElementsByTagName(String, String)

Gibt eine XmlNodeList mit einer Liste aller untergeordneten Elemente zurück, die mit dem angegebenen LocalName und NamespaceURI übereinstimmen.

System_CAPS_pubmethodGetEnumerator()

Ruft einen Enumerator ab, der die untergeordneten Knoten des aktuellen Knotens durchläuft.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetNamespaceOfPrefix(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.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodGetPrefixOfNamespace(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.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodImportNode(XmlNode, Boolean)

Importiert einen Knoten aus einem anderen Dokument in das aktuelle Dokument.

System_CAPS_pubmethodInsertAfter(XmlNode, XmlNode)

Fügt den angegebenen Knoten unmittelbar hinter dem angegebenen Verweisknoten ein.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodInsertBefore(XmlNode, XmlNode)

Fügt den angegebenen Knoten direkt vor dem angegebenen Verweisknoten ein.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodLoad(Stream)

Lädt das XML-Dokument aus dem angegebenen Stream.

System_CAPS_pubmethodLoad(String)

Lädt das XML-Dokument aus der angegebenen URL.

System_CAPS_pubmethodLoad(TextReader)

Lädt das XML-Dokument aus dem angegebenen TextReader.

System_CAPS_pubmethodLoad(XmlReader)

Lädt das XML-Dokument aus dem angegebenen XmlReader.

System_CAPS_pubmethodLoadXml(String)

Lädt das XML-Dokument aus der angegebenen Zeichenfolge.

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodNormalize()

Weist allen XmlText-Knoten in der Unterstruktur 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.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodPrependChild(XmlNode)

Fügt den angegebenen Knoten am Anfang der Liste der untergeordneten Knoten dieses Knotens hinzu.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodReadNode(XmlReader)

Erstellt anhand der Informationen im XmlReader ein XmlNode-Objekt. Der Reader muss auf einem Knoten oder Attribut positioniert sein.

System_CAPS_pubmethodRemoveAll()

Entfernt alle untergeordneten Knoten bzw. Attribute des aktuellen Knotens.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodRemoveChild(XmlNode)

Entfernt den angegebenen untergeordneten Knoten.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodReplaceChild(XmlNode, XmlNode)

Ersetzt den untergeordneten oldChild-Knoten durch den newChild-Knoten.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodSave(Stream)

Speichert das XML-Dokument im angegebenen Stream.

System_CAPS_pubmethodSave(String)

Speichert das XML-Dokument in der angegebenen Datei. Die angegebene Datei existiert, diese Methode überschreibt sie.

System_CAPS_pubmethodSave(TextWriter)

Speichert das XML-Dokument im angegebenen TextWriter.

System_CAPS_pubmethodSave(XmlWriter)

Speichert das XML-Dokument im angegebenen XmlWriter.

System_CAPS_pubmethodSelectNodes(String)

Wählt eine Liste von Knoten aus, die mit dem XPath-Ausdruck übereinstimmen.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodSelectNodes(String, XmlNamespaceManager)

Wählt eine Liste von Knoten aus, die mit dem XPath-Ausdruck übereinstimmen. Sämtliche im XPath-Ausdruck vorhandenen Präfixe werden mit dem angegebenen XmlNamespaceManager aufgelöst.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodSelectSingleNode(String)

Wählt den ersten XmlNode aus, der mit dem XPath-Ausdruck übereinstimmt.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodSelectSingleNode(String, XmlNamespaceManager)

Wählt den ersten XmlNode aus, der mit dem XPath-Ausdruck übereinstimmt. Sämtliche im XPath-Ausdruck vorhandenen Präfixe werden mit dem angegebenen XmlNamespaceManager aufgelöst.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodSupports(String, String)

Überprüft, ob die DOM-Implementierung ein bestimmtes Funktion implementiert.(Geerbt von „XmlNode“.)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodValidate(ValidationEventHandler)

Validiert das XmlDocument anhand der in der Schemas-Eigenschaft enthaltenen XSD-Schemas (XML Schema Definition).

System_CAPS_pubmethodValidate(ValidationEventHandler, XmlNode)

Validiert das angegebene XmlNode-Objekt anhand der in der Schemas-Eigenschaft enthaltenen XSD-Schemas (XML Schema Definition).

System_CAPS_pubmethodWriteContentTo(XmlWriter)

Speichert alle untergeordneten Elemente des XmlDocument-Knotens im angegebenen XmlWriter.(Überschreibt XmlNode.WriteContentTo(XmlWriter).)

System_CAPS_pubmethodWriteTo(XmlWriter)

Speichert den XmlDocument-Knoten im angegebenen XmlWriter.(Überschreibt XmlNode.WriteTo(XmlWriter).)

NameBeschreibung
System_CAPS_pubeventNodeChanged

Tritt ein, wenn der Value eines zu diesem Dokument gehörenden Knotens geändert wurde.

System_CAPS_pubeventNodeChanging

Tritt ein, wenn der Value eines zu diesem Dokument gehörenden Knotens gerade geändert wird.

System_CAPS_pubeventNodeInserted

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten in einen anderen Knoten eingefügt wurde.

System_CAPS_pubeventNodeInserting

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten gerade in einen anderen Knoten eingefügt wird.

System_CAPS_pubeventNodeRemoved

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten aus dem übergeordneten Element entfernt wurde.

System_CAPS_pubeventNodeRemoving

Tritt ein, wenn ein zu diesem Dokument gehörender Knoten gerade aus dem Dokument entfernt wird.

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Eine Beschreibung dieses Elements finden Sie unter XmlNode.GetEnumerator.(Geerbt von „XmlNode“.)

System_CAPS_pubinterfaceSystem_CAPS_privmethodICloneable.Clone()

Eine Beschreibung dieses Elements finden Sie unter XmlNode.Clone.(Geerbt von „XmlNode“.)

NameBeschreibung
System_CAPS_pubmethodAsParallel()

Überladen. Ermöglicht die Parallelisierung einer Abfrage.(Definiert durch ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable()

Überladen. Konvertiert ein IEnumerable zu einer IQueryable.(Definiert durch Queryable.)

System_CAPS_pubmethodCast<TResult>()

Wandelt die Elemente einer IEnumerable in den angegebenen Typ.(Definiert durch Enumerable.)

System_CAPS_pubmethodOfType<TResult>()

Filtert die Elemente einer IEnumerable auf Grundlage eines angegebenen Typs.(Definiert durch Enumerable.)


Die XmlDocument Klasse ist eine speicherinterne Darstellung eines XML-Dokuments. Es implementiert die W3C XML-Dokumentobjektmodell (DOM) Level 1 Core und das DOM Level 2 Core.

DOM steht für Dokumentobjektmodell. Weitere Informationen dazu, finden Sie unter XML-Dokumentobjektmodell (DOM).

Sie können XML in das DOM geladen, mit der XmlDocument Klasse, und klicken Sie dann programmgesteuert lesen, ändern und Entfernen von XML in das Dokument.

Öffnen Sie gegebenenfalls die Abdeckung der XmlDocument Klasse und finden Sie unter wie sie implementiert wird, finden Sie unter der Reference Source.

Beginnen Sie mit einem XML-Dokument, wie diese. Es ist nur ein paar Bücher in einer Auflistung. Aber sie enthält grundlegende Dinge, die Sie in einem beliebigen XML-Dokument zu finden ist. ein Namespace, Elemente, die Daten darstellen und Attribute, die die Daten beschreiben.

<?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 geladen Sie diese Daten in das DOM werden, damit Sie damit arbeiten können, im Arbeitsspeicher. Die am häufigsten verwendete Möglichkeit hierzu ist, finden Sie in eine Datei auf dem lokalen Computer oder in einem Netzwerk.

In diesem Beispiel werden XML-Daten aus einer Datei geladen. Wenn die Datei nicht vorhanden ist, gerade generiert einige XML-Code und lädt, gesucht.

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

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen:Einlesen eines XML-Dokuments in das DOM

Beginnen Sie mit einem XML-Schema wie diesen. Dieses Schema definiert die Datentypen in der XML-Code, und welche Attribute erforderlich sind.

<?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 ein XmlReader -Objekt mithilfe des Schemas, und klicken Sie dann dieses Objekt in das DOM geladen Erstellen Sie einen Ereignishandler, der ausgeführt wird, wenn der Code versucht, auf die XML-Datei auf Weise ändern, die die Regeln des Schemas.

Diese Codeblöcke anzeigen Hilfsmethoden, die diese ausführen.


//************************************************************************************
//
//  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();
    }

}

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen:Validieren eines XML-Dokuments im Dokumentobjektmodell

Sie können Eigenschaften zum Navigieren in einem XML-Dokument verwenden. Aber bevor Sie diese verwenden, schnell überprüfen wir einige Begriffe. Ihr Dokument besteht aus Knoten. Jeder Knoten besitzt als einzelnes übergeordneten Knoten direkt darüber liegenden. Der einzige Knoten, die keinen übergeordneten Knoten ist das Stammelement des Dokuments, als Knoten der obersten Ebene ist. Die meisten Knoten verfügen können untergeordneten Knoten, die Knoten direkt darunter sind. Knoten, die auf der gleichen Ebene befinden, sind gleichgeordnete Elemente.

Die folgenden Beispiele veranschaulichen den Stammknoten, springen Sie zu den ersten untergeordneten Knoten des Stammknotens, Zugriff auf alle untergeordneten Knoten, Abrufen zurück an den übergeordneten Knoten, und navigieren dann über nebengeordneten Knoten.

Beginnen Sie mit dem Stammknoten

In diesem Beispiel ruft den Stammknoten ab und verwendet dann diesen Knoten, um den Inhalt des Dokuments auf der Konsole ausgegeben.

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

Abrufen von untergeordneten Knoten

In diesem Beispiel springt zu den ersten untergeordneten Knoten des Stammknotens, und klicken Sie dann die untergeordneten Knoten dieses Knotens durchläuft, falls vorhanden.

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

Zurück zum übergeordneten Knoten abrufen

Verwenden Sie die ParentNode-Eigenschaft.

Anhand des letzten untergeordneten Knoten

In diesem Beispiel schreibt den Preis des Buchs an die Konsole (die den letzten untergeordneten Knoten eines Knotens Buch ist).

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

Wechseln, über die gleichgeordneten Elemente

In diesem Beispiel wird die Book um Buch vorwärts verschoben. Buchknoten sind gleichgeordnete Elemente untereinander.

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

  }
}

Für gleichgeordnete Elemente rückwärts navigieren

In diesem Beispiel wird aus Book um Buch rückwärts verschoben.

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

Die am häufigsten verwendete Möglichkeit zum finden von einem oder mehreren Knoten der Daten ist die Verwendung eine XPath-Abfrage-Zeichenfolge, aber es gibt auch Methoden, die eine nicht erforderlich ist.

Abrufen eines Knotens

In diesem Beispiel sucht ein Buch mit der 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;
}

Die Zeichenfolge ab, die in diesem Beispiel wird eine XPath-Abfrage. Finden Sie weitere Beispiele finden sie hier: XPath examples.

Sie können auch die GetElementById Knoten abgerufen. Um diesen Ansatz verwenden, müssen Sie definieren in das Dokument Definition Typdeklarationen Ihrer XML-Datei-IDs.

Nachdem Sie einen Knoten erhalten haben, erhalten Sie den Wert von Attributen oder untergeordneten Knoten. In diesem Beispiel werden, die mit einem Buchknoten.

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

Abrufen einer Auflistung von Knoten

In diesem Beispiel werden alle Bücher ausgewählt, wird der Nachname des Autors Austen, und klicken Sie dann den Preis für diese Büchern ändert.

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

  }
}

Sie können auch eine Auflistung von Knoten abrufen, mit dem Namen des Knotens. In diesem Beispiel ruft z. B. eine Auflistung von der alle Buchtitel.

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

  }
}

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen:Auswählen von Knoten mithilfe der XPath-Navigation

In diesem Beispiel bearbeitet eine Book-Knoten und seine Attribute.

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

Weitere Informationen:Ändern von Knoten, Inhalten und Werten in einem XML-Dokument

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Um einen Knoten hinzuzufügen, verwenden Sie die CreateElement Methode oder die CreateNode Methode.

Verwenden Sie zum Hinzufügen eines Datenknoten z. B. ein Buch die CreateElement Methode.

Für alle anderen Arten von Knoten, z. B. einen Kommentar, Leerzeichen oder CDATA-Knoten, die CreateNode Methode.

In diesem Beispiel wird einen Buchknoten erstellt, fügt der Attribute für diesen Knoten und fügt dann diesen Knoten, auf das Dokument.

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;

}

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen:Einfügen von Knoten in ein XML-Dokument

Verwenden Sie zum Entfernen eines Knotens die RemoveChild Methode.

In diesem Beispiel entfernt ein Buch aus dem Dokument und Leerzeichen, das unmittelbar vor der Buchknoten angezeigt wird.

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

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Weitere Informationen:Entfernen von Knoten, Inhalten und Werten aus einem XML-Dokument

Sie können auswählen, in dem einen Knoten im Dokument angezeigt werden soll die InsertBefore und InsertAfter Methoden.

Dieses Beispiel zeigt zwei Hilfsmethoden. Eine davon wird einen höheren Knoten in einer Liste verschoben. Die anderen Knoten Verschiebt einen unteren Knoten.

Diese Methoden können in einer Anwendung verwendet werden, die Benutzern ermöglicht, Bücher in einer Liste von Büchern nach oben oder unten verschieben. Wenn ein Benutzer ein Buch auswählt und einen Up drückt und gedrückt konnte Methoden wie diese mit der entsprechenden Buchknoten vor oder nach anderen Buchknoten Positionieren von Code aufgerufen werden.

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

}

Vollständiges Beispiel:Manipulate XML in-Memory by using the XmlDocument class and other related types

Universelle Windows-Plattform
Verfügbar seit 10
.NET Framework
Verfügbar seit 1.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: