XmlReader Klasse

  • Referenz

Definition

Namespace:
System.Xml
Assembly:
System.Xml.ReaderWriter.dll
Assembly:
System.Xml.dll
Assembly:
netstandard.dll

Stellt einen Reader dar, der einen schnellen Zugriff auf XML-Daten bietet, ohne Zwischenspeicher und welcher nur vorwärts möglich ist.

public ref class XmlReader abstract : IDisposable
public ref class XmlReader abstract
public abstract class XmlReader : IDisposable
public abstract class XmlReader
type XmlReader = class
    interface IDisposable
type XmlReader = class
Public MustInherit Class XmlReader
Implements IDisposable
Public MustInherit Class XmlReader
Vererbung
Object
XmlReader
Abgeleitet
Implementiert
IDisposable

Beispiele

Der folgende Beispielcode zeigt, wie Sie die asynchrone API verwenden, um XML zu analysieren.

async Task TestReader(System.IO.Stream stream)
{
    XmlReaderSettings settings = new XmlReaderSettings();
    settings.Async = true;

    using (XmlReader reader = XmlReader.Create(stream, settings))
    {
        while (await reader.ReadAsync())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element:
                    Console.WriteLine("Start Element {0}", reader.Name);
                    break;
                case XmlNodeType.Text:
                    Console.WriteLine("Text Node: {0}",
                             await reader.GetValueAsync());
                    break;
                case XmlNodeType.EndElement:
                    Console.WriteLine("End Element {0}", reader.Name);
                    break;
                default:
                    Console.WriteLine("Other node {0} with value {1}",
                                    reader.NodeType, reader.Value);
                    break;
            }
        }
    }
}

Public Async Function TestReader(stream As System.IO.Stream) As Task
    Dim settings As New XmlReaderSettings()
    settings.Async = True

    Using reader As XmlReader = XmlReader.Create(stream, settings)
        While (Await reader.ReadAsync())
            Select Case (reader.NodeType)
                Case XmlNodeType.Element
                    Console.WriteLine("Start Element {0}", reader.Name)
                Case XmlNodeType.Text
                    Console.WriteLine("Text Node: {0}",
                             Await reader.GetValueAsync())
                Case XmlNodeType.EndElement
                    Console.WriteLine("End Element {0}", reader.Name)
                Case Else
                    Console.WriteLine("Other node {0} with value {1}",
                                    reader.NodeType, reader.Value)
            End Select
        End While
    End Using
End Function

Hinweise

XmlReader bietet schreibgeschützten Vorwärtszugriff auf XML-Daten in einem Dokument oder Stream. Diese Klasse entspricht den Empfehlungen von W3C Extensible Markup Language (XML) 1.0 (vierte Edition) und den Namespaces in XML 1.0 (dritte Edition).

XmlReader mit -Methoden können Sie XML-Daten durchlaufen und den Inhalt eines Knotens lesen. Die Eigenschaften der -Klasse spiegeln den Wert des aktuellen Knotens wider, an dem sich der Leser befindet. Der ReadState Eigenschaftswert gibt den aktuellen Zustand des XML-Readers an. Beispielsweise wird die -Eigenschaft von der XmlReader.Read -Methode und ReadState.Closed der XmlReader.Close -Methode auf ReadState.Initial festgelegt. XmlReader bietet außerdem Datenkonformitätsprüfungen und -validierungen für eine DTD oder ein Schema.

XmlReader verwendet ein Pullmodell zum Abrufen von Daten. Dieses Modell:

  • Vereinfacht die Zustandsverwaltung durch eine natürliche, von oben nach unten prozedurale Verfeinerung.

  • Unterstützt mehrere Eingabedatenströme und Ebenen.

  • Ermöglicht dem Client, dem Parser einen Puffer zu geben, in den die Zeichenfolge direkt geschrieben wird, und vermeidet so die Notwendigkeit einer zusätzlichen Zeichenfolgenkopie.

  • Unterstützt selektive Verarbeitung. Der Client kann Elemente überspringen und verarbeiten, die für die Anwendung von Interesse sind. Sie können eigenschaften auch im Voraus festlegen, um zu verwalten, wie der XML-Stream verarbeitet wird (z. B. Normalisierung).

In diesem Abschnitt

Erstellen eines XML-ReadersÜberprüfen der XML-DatenkonformitätNavigieren durch KnotenLesen von XML-ElementenLesen von XML-AttributenLesen von XML-InhaltenKonvertieren in CLR-TypenAsynchrone ProgrammierungSicherheitsüberlegungen

Erstellen eines XML-Readers

Verwenden Sie die Create -Methode, um eine XmlReader instance zu erstellen.

Obwohl die .NET Framework konkrete Implementierungen der XmlReader -Klasse bietet, z. B. die XmlTextReaderKlassen , XmlNodeReaderund die XmlValidatingReader Klassen, wird empfohlen, die spezialisierten Klassen nur in diesen Szenarien zu verwenden:

  • Wenn Sie eine XML DOM-Unterstruktur aus einem XmlNode Objekt lesen möchten, verwenden Sie die XmlNodeReader -Klasse. (Diese Klasse unterstützt jedoch keine DTD- oder Schemaüberprüfung.)

  • Wenn Sie Entitäten bei Anforderung erweitern müssen, Der Textinhalt nicht normalisiert werden soll oder keine Standardattribute zurückgegeben werden sollen, verwenden Sie die XmlTextReader -Klasse.

Um den Satz von Features anzugeben, die Sie für den XML-Reader aktivieren möchten, übergeben Sie ein System.Xml.XmlReaderSettings -Objekt an die Create -Methode. Sie können ein einzelnes System.Xml.XmlReaderSettings Objekt verwenden, um mehrere Reader mit derselben Funktionalität zu erstellen, oder das System.Xml.XmlReaderSettings Objekt ändern, um einen neuen Reader mit einem anderen Satz von Features zu erstellen. Sie können auch ganz einfach Features zu einem vorhandenen Reader hinzufügen.

Wenn Sie kein Objekt verwenden System.Xml.XmlReaderSettings , werden Standardeinstellungen verwendet. Weitere Informationen finden Sie auf der Create Referenzseite.

XmlReader löst einen bei XML-Analysefehlern aus XmlException . Nachdem eine Ausnahme ausgelöst wurde, ist der Zustand des Lesers nicht vorhersagbar. Beispielsweise kann sich der gemeldete Knotentyp vom tatsächlichen Knotentyp des aktuellen Knotens unterscheiden. Verwenden Sie die ReadState -Eigenschaft, um zu überprüfen, ob sich der Reader im Fehlerzustand befindet.

Überprüfen von XML-Daten

Um die Struktur eines XML-Dokuments und dessen Elementbeziehungen, Datentypen und Inhaltseinschränkungen zu definieren, verwenden Sie eine Dokumenttypdefinition (DTD) oder ein XSD-Schema (XML Schema Definition Language). Ein XML-Dokument gilt als wohlgeformt, wenn es alle syntaktischen Anforderungen erfüllt, die in der W3C XML 1.0-Empfehlung definiert sind. Sie gilt als gültig, wenn sie wohlgeformt ist und auch den durch die DTD oder das Schema definierten Einschränkungen entspricht. (Siehe W3C XML Schema Part 1: Structures und W3C XML Schema Part 2: Datatypes empfehlungen.) Daher sind, obwohl alle gültigen XML-Dokumente wohlgeformt sind, nicht alle wohlgeformten XML-Dokumente gültig.

Sie können die Daten anhand einer DTD, eines Inline-XSD-Schemas oder eines in einem XmlSchemaSet Objekt (cache) gespeicherten XSD-Schemas überprüfen. Diese Szenarien werden auf der Create Referenzseite beschrieben. XmlReader unterstützt keine XDR-Schemaüberprüfung (XML-Data Reduziert).

Sie verwenden die folgenden Einstellungen für die XmlReaderSettings -Klasse, um anzugeben, welche Art der Überprüfung (falls vorhanden) der XmlReader instance unterstützt.

Verwenden Dieses XmlReaderSettings Member Angabe von
DtdProcessing -Eigenschaft Gibt an, ob die DTD-Verarbeitung zugelassen werden soll. In der Standardeinstellung ist die DTD-Verarbeitung nicht zulässig.
ValidationType -Eigenschaft Gibt an, ob der Leser Daten überprüfen soll und welche Art der Validierung (DTD oder Schema) ausgeführt werden soll. In der Standardeinstellung erfolgt keine Validierung.
ValidationEventHandler -Ereignis Ein Ereignishandler zum Empfangen von Informationen zu Validierungsereignissen. Wenn kein Ereignishandler bereitgestellt wird, wird beim ersten Validierungsfehler eine XmlException ausgelöst.
ValidationFlags -Eigenschaft Zusätzliche Validierungsoptionen über die Enumerationsmber XmlSchemaValidationFlags :

- AllowXmlAttributes– Erlauben Sie XML-Attribute (xml:*) in instance Dokumenten, auch wenn sie nicht im Schema definiert sind. Die Attribute werden anhand ihres Datentyps validiert. Sehen Sie sich die XmlSchemaValidationFlags Referenzseite für die Einstellung an, die in bestimmten Szenarien verwendet werden soll. (Standardmäßig deaktiviert.)
- ProcessIdentityConstraints--Prozessidentitätseinschränkungen (xs:ID, , xs:IDREFxs:key, xs:keyref, ), xs:uniquedie während der Überprüfung aufgetreten sind. (Standardmäßig aktiviert.)
- ProcessSchemaLocation --Process-Schemas, die durch das xsi:schemaLocation -Attribut oder xsi:noNamespaceSchemaLocation angegeben werden. (Standardmäßig aktiviert.)
- ProcessInlineSchema–- Verarbeiten von INLINE-XML-Schemas während der Überprüfung. (Standardmäßig deaktiviert.)
- ReportValidationWarnings- Melden Sie Ereignisse, wenn eine Validierungswarnung auftritt. Eine Warnung wird normalerweise ausgegeben, wenn keine DTD oder kein XML-Schema vorhanden ist, anhand derer bzw. dessen ein bestimmtes Attribut oder Element validiert werden kann. ValidationEventHandler wird zur Benachrichtigung verwendet. (Standardmäßig deaktiviert.)
Schemas Die für die Validierung zu verwendende XmlSchemaSet.
XmlResolver -Eigenschaft Die XmlResolver zum Auflösen und Zugreifen auf externe Ressourcen. Dies kann externe Entitäten wie DTD und Schemas sowie beliebige xs:include oder xs:import im XML-Schema enthaltene Elemente umfassen. Wenn Sie keinen angeben XmlResolver, verwendet der XmlReader eine Standardeinstellung XmlUrlResolver ohne Benutzeranmeldeinformationen.

Datenkonformität

XML-Reader, die von der Create -Methode erstellt werden, erfüllen standardmäßig die folgenden Complianceanforderungen:

  • Neue Zeilen und Attributwerte werden gemäß der W3C XML 1.0-Empfehlung normalisiert.

  • Alle Entitäten werden automatisch erweitert.

  • Standardattribute, die in der Dokumenttypdefinition deklariert sind, werden immer hinzugefügt, auch wenn der Leser nicht überprüft wird.

  • Die Deklaration eines XML-Präfixes, das dem richtigen XML-Namespace-URI zugeordnet ist, ist zulässig.

  • Die Notationsnamen in einer einzelnen NotationType Attributdeklaration und NmTokens in einer einzelnen Enumeration Attributdeklaration sind unterschiedlich.

Verwenden Sie diese XmlReaderSettings Eigenschaften, um den Typ der Konformitätsprüfungen anzugeben, die Sie aktivieren möchten:

Verwenden Dieser XmlReaderSettings Eigenschaft Beschreibung Standard
CheckCharacters -Eigenschaft Aktivieren oder deaktivieren Sie Überprüfungen für Folgendes:

- Zeichen befinden sich innerhalb des Bereichs der gesetzlichen XML-Zeichen, wie im Abschnitt 2.2 Zeichen der W3C XML 1.0-Empfehlung definiert.
– Alle XML-Namen sind gültig, wie im Abschnitt 2.3 Common Syntactic Constructs der W3C XML 1.0-Empfehlung definiert.

Wenn diese Eigenschaft auf true (Standard) festgelegt ist, wird eine XmlException Ausnahme ausgelöst, wenn die XML-Datei ungültige Zeichen oder ungültige XML-Namen enthält (z. B. beginnt ein Elementname mit einer Zahl).		 Die Zeichen- und Namensüberprüfung ist aktiviert.

Durch Festlegen von CheckCharacters auf false wird die Zeichenüberprüfung für Zeichenentitätsverweise deaktiviert. Wenn der Leser Textdaten verarbeitet, wird unabhängig von dieser Einstellung immer überprüft, ob XML-Namen gültig sind. Hinweis: Die XML 1.0-Empfehlung erfordert Konformität auf Dokumentebene, wenn eine DTD vorhanden ist. Wenn der Reader für die Unterstützung ConformanceLevel.Fragmentkonfiguriert ist, die XML-Daten jedoch eine Dokumenttypdefinition (DTD) enthalten, wird ein XmlException ausgelöst.
ConformanceLevel -Eigenschaft Wählen Sie die Konformitätsstufe aus, um Folgendes zu erzwingen:

- Document. Entspricht den Regeln für ein wohlgeformtes XML 1.0-Dokument.
- Fragment. Entspricht den Regeln für ein wohlgeformtes Dokumentfragment, das als externe analysierte Entität verwendet werden kann.
- Auto. Entspricht der vom Leser beschlossenen Ebene.

Wenn die Daten nicht konform sind, wird eine XmlException Ausnahme ausgelöst.		 Document

Der aktuelle Knoten ist der XML-Knoten, auf dem sich der XML-Reader derzeit befindet. Alle XmlReader Methoden führen Vorgänge in Bezug auf diesen Knoten aus, und alle XmlReader Eigenschaften spiegeln den Wert des aktuellen Knotens wider.

Mit den folgenden Methoden können Sie einfach durch Knoten navigieren und Daten analysieren.

Verwenden Sie diese XmlReaderSettings Methode Beschreibung
Read Lesen Sie den ersten Knoten, und durchlaufen Sie den Stream jeweils einen Knoten nach dem anderen. Solche Aufrufe werden in der Regel innerhalb einer while Schleife ausgeführt.

Verwenden Sie die NodeType -Eigenschaft, um den Typ (z. B. Attribut, Kommentar, Element usw.) des aktuellen Knotens abzurufen.
Skip Überspringen Sie die untergeordneten Elemente des aktuellen Knotens, und wechseln Sie zum nächsten Knoten.
MoveToContent und MoveToContentAsync Überspringen Sie Nichtinhaltsknoten, und wechseln Sie zum nächsten Inhaltsknoten oder zum Ende der Datei.

Zu den Nichtinhaltsknoten gehören ProcessingInstruction, DocumentType, Comment, Whitespaceund SignificantWhitespace.

Inhaltsknoten enthalten Nicht-Leerraumtext, CDATA, EntityReference und EndEntity.
ReadSubtree Lesen Sie ein Element und alle untergeordneten Elemente, und geben Sie eine neue XmlReader instance zurück, die auf ReadState.Initialfestgelegt ist.

Diese Methode ist nützlich, um Grenzen um XML-Elemente herum zu erstellen. Beispielsweise, wenn Sie Daten für die Verarbeitung an eine andere Komponente übergeben möchten und die Anzahl Ihrer Daten einschränken möchten, auf die die Komponente zugreifen kann.

Auf der XmlReader.Read Referenzseite finden Sie ein Beispiel für die knotenweise Navigation durch einen Textstream und die Anzeige des Typs der einzelnen Knoten.

In den folgenden Abschnitten wird beschrieben, wie Sie bestimmte Datentypen wie Elemente, Attribute und typisierte Daten lesen können.

Lesen von XML-Elementen

In der folgenden Tabelle sind die Methoden und Eigenschaften aufgeführt, die die -Klasse für die XmlReader Verarbeitung von Elementen bereitstellt. Nachdem der XmlReader auf einem Element platziert wurde, spiegeln die Knoteneigenschaften, z. B. Name, die Elementwerte wider. Zusätzlich zu den unten beschriebenen Membern können auch alle allgemeinen Methoden und Eigenschaften der XmlReader-Klasse zum Verarbeiten von Elementen verwendet werden. Sie können beispielsweise mit der ReadInnerXml-Methode den Inhalt eines Elements lesen.

Hinweis

Definitionen von Starttags, Endtags und leeren Elementtags finden Sie im Abschnitt 3.1 der W3C XML 1.0-Empfehlung .

Verwenden Dieses XmlReader Member Beschreibung
IsStartElement-Methode Überprüfen Sie, ob der aktuelle Knoten ein Starttag oder ein leeres Elementtag ist.
ReadStartElement-Methode Überprüfen Sie, ob es sich bei dem aktuellen Knoten um ein Element handelt, und führen Sie den Reader zum nächsten Knoten weiter (Aufrufe IsStartElement gefolgt von Read).
ReadEndElement-Methode Überprüfen Sie, ob es sich bei dem aktuellen Knoten um ein Endtag handelt, und führen Sie den Reader zum nächsten Knoten weiter.
ReadElementString-Methode Lesen sie ein reines Textelement.
ReadToDescendant-Methode Fahren Sie den XML-Reader zum nächsten untergeordneten (untergeordneten) Element mit dem angegebenen Namen weiter.
ReadToNextSibling-Methode Führen Sie den XML-Reader zum nächsten gleichgeordneten Element mit dem angegebenen Namen weiter.
IsEmptyElement -Eigenschaft Überprüfen Sie, ob das aktuelle Element über ein Endelementtag verfügt. Beispiel:

- <item num="123"/> (IsEmptyElement ist true.)
- <item num="123"> </item> (IsEmptyElement ist false, obwohl der Inhalt des Elements leer ist.)

Ein Beispiel für das Lesen des Textinhalts von Elementen finden Sie in der ReadString -Methode. Im folgenden Beispiel werden Elemente mithilfe einer while -Schleife verarbeitet.

while (reader.Read()) {
  if (reader.IsStartElement()) {
    if (reader.IsEmptyElement)
                {
                    Console.WriteLine("<{0}/>", reader.Name);
                }
                else {
      Console.Write("<{0}> ", reader.Name);
      reader.Read(); // Read the start tag.
      if (reader.IsStartElement())  // Handle nested elements.
        Console.Write("\r\n<{0}>", reader.Name);
      Console.WriteLine(reader.ReadString());  //Read the text content of the element.
    }
  }
}

While reader.Read()
  If reader.IsStartElement() Then
    If reader.IsEmptyElement Then
      Console.WriteLine("<{0}/>", reader.Name)
    Else
      Console.Write("<{0}> ", reader.Name)
      reader.Read() ' Read the start tag.
      If reader.IsStartElement() Then ' Handle nested elements.
        Console.Write(vbCr + vbLf + "<{0}>", reader.Name)
      End If
      Console.WriteLine(reader.ReadString()) 'Read the text content of the element.
    End If
  End If
End While

Lesen von XML-Attributen

XML-Attribute werden am häufigsten auf Elementen gefunden, sind aber auch auf XML-Deklarations- und Dokumenttypknoten zulässig.

Wenn die -Methode auf einem Elementknoten positioniert ist, MoveToAttribute können Sie die Attributliste des Elements durchlaufen. Beachten Sie, dass knoteneigenschaften wie Name, NamespaceURIund Prefix nach MoveToAttribute dem Aufruf die Eigenschaften dieses Attributs widerspiegeln, nicht die Eigenschaften des Elements, zu dem das Attribut gehört.

Die XmlReader -Klasse stellt diese Methoden und Eigenschaften zum Lesen und Verarbeiten von Attributen für Elemente bereit.

Verwenden Dieses XmlReader Member Beschreibung
HasAttributes -Eigenschaft Überprüfen Sie, ob der aktuelle Knoten über Attribute verfügt.
AttributeCount -Eigenschaft Ruft die Anzahl der Attribute für das aktuelle Element ab.
MoveToFirstAttribute-Methode Wechseln sie zum ersten Attribut in einem -Element.
MoveToNextAttribute-Methode Wechseln zum nächsten Attribut in einem Element.
MoveToAttribute-Methode Zu einem angegebenen Attribut wechseln.
GetAttribute Methode oder Item[] Eigenschaft Ruft den Wert eines angegebenen Attributs ab.
IsDefault -Eigenschaft Überprüfen Sie, ob der aktuelle Knoten ein Attribut ist, das aus dem Standardwert generiert wurde, der in der DTD oder im Schema definiert ist.
MoveToElement-Methode Wechseln Sie zu dem Element, das das aktuelle Attribut besitzt. Verwenden Sie diese Methode, um zu einem Element zurückzukehren, nachdem Sie durch seine Attribute navigiert haben.
ReadAttributeValue-Methode Analysieren Sie den Attributwert in einen oder Textmehrere Knoten , EntityReferenceoder EndEntity .

Alle allgemeinen Methoden und Eigenschaften von XmlReader können auch für die Verarbeitung von Attributen verwendet werden. Beispielsweise reflektieren die XmlReader-Eigenschaft und die Name-Eigenschaft nach dem Positionieren von Value auf einem Attribut die Werte des Attributs. Sie können den Wert des Attributs auch mit einer beliebigen Read-Methode für den Inhalt abrufen.

In diesem Beispiel wird die AttributeCount -Eigenschaft verwendet, um durch alle Attribute eines Elements zu navigieren.

// Display all attributes.
if (reader.HasAttributes) {
  Console.WriteLine("Attributes of <" + reader.Name + ">");
  for (int i = 0; i < reader.AttributeCount; i++) {
    Console.WriteLine("  {0}", reader[i]);
  }
  // Move the reader back to the element node.
  reader.MoveToElement();
}

' Display all attributes.
If reader.HasAttributes Then
  Console.WriteLine("Attributes of <" + reader.Name + ">")
  Dim i As Integer
  For i = 0 To (reader.AttributeCount - 1)
    Console.WriteLine("  {0}", reader(i))
  Next i
  ' Move the reader back to the element node.
  reader.MoveToElement() 
End If

In diesem Beispiel wird die MoveToNextAttribute -Methode in einer while Schleife verwendet, um durch die Attribute zu navigieren.

if (reader.HasAttributes) {
  Console.WriteLine("Attributes of <" + reader.Name + ">");
  while (reader.MoveToNextAttribute()) {
    Console.WriteLine(" {0}={1}", reader.Name, reader.Value);
  }
  // Move the reader back to the element node.
  reader.MoveToElement();
}

If reader.HasAttributes Then
  Console.WriteLine("Attributes of <" + reader.Name + ">")
  While reader.MoveToNextAttribute()
    Console.WriteLine(" {0}={1}", reader.Name, reader.Value)
  End While
  ' Move the reader back to the element node.
  reader.MoveToElement()
End If

Lesen von Attributen auf XML-Deklarationsknoten

Wenn der XML-Reader auf einem XML-Deklarationsknoten positioniert ist, gibt die Value Eigenschaft die Versions-, Eigenständig- und Codierungsinformationen als eine einzelne Zeichenfolge zurück. XmlReader -Objekte, die von der Create -Methode, der XmlTextReader -Klasse und der XmlValidatingReader -Klasse erstellt wurden, machen die Versions-, Eigenständigen- und Codierungselemente als Attribute verfügbar.

Lesen von Attributen auf Dokumenttypknoten

Wenn der XML-Reader auf einem Dokumenttypknoten positioniert ist, können die -Methode und Item[] die GetAttribute -Eigenschaft verwendet werden, um die Werte für die LITERALE SYSTEM und PUBLIC zurückzugeben. Durch das Aufrufen von reader.GetAttribute("PUBLIC") wird beispielsweise der Wert PUBLIC zurückgegeben.

Lesen von Attributen auf Verarbeitungsanweisungsknoten

Wenn der XmlReader auf einem Verarbeitungsanweisungsknoten positioniert ist, gibt die Value-Eigenschaft den gesamten Textinhalt zurück. Elemente im Verarbeitungsanweisungsknoten werden nicht als Attribute behandelt. Sie können nicht mit der - oder MoveToAttribute -GetAttributeMethode gelesen werden.

Lesen von XML-Inhalten

Die XmlReader-Klasse enthält die folgenden Member, die Inhalte aus einer XML-Datei lesen und den Inhalt als Zeichenfolgenwerte zurückgeben. (Informationen zum Zurückgeben von CLR-Typen finden Sie im nächsten Abschnitt.)

Verwenden Dieses XmlReader Member Beschreibung
Value -Eigenschaft Ruft den Textinhalt des aktuellen Knotens ab. Der zurückgegebene Wert hängt vom Knotentyp ab. Weitere Informationen finden Sie auf der Value Referenzseite.
ReadString-Methode Ruft den Inhalt eines Elements oder Textknotens als Zeichenfolge ab. Diese Methode beendet die Verarbeitung von Anweisungen und Kommentaren.

Ausführliche Informationen dazu, wie diese Methode bestimmte Knotentypen behandelt, finden Sie auf der ReadString Referenzseite.
Die Methoden ReadInnerXml und ReadInnerXmlAsync Rufen Sie den gesamten Inhalt des aktuellen Knotens ab, einschließlich des Markups, jedoch ohne Start- und Endtags. Beispiel:

<node>this<child id="123"/></node>

ReadInnerXml gibt Folgendes zurück:

this<child id="123"/>
Die Methoden ReadOuterXml und ReadOuterXmlAsync Rufen Sie den gesamten Inhalt des aktuellen Knotens und seiner untergeordneten Elemente ab, einschließlich Markup und Start/End-Tags. Beispiel:

<node>this<child id="123"/></node>

ReadOuterXml gibt Folgendes zurück:

<node>this<child id="123"/></node>

Konvertieren in CLR-Typen

Sie können die Member der -Klasse (in der XmlReader folgenden Tabelle aufgeführt) verwenden, um XML-Daten zu lesen und Werte als CLR-Typen (Common Language Runtime) anstelle von Zeichenfolgen zurückzugeben. Mit diesen Membern können Sie Werte in der Darstellung abrufen, die für Ihre Codierungsaufgabe am besten geeignet sind, ohne Zeichenfolgenwerte manuell analysieren oder konvertieren zu müssen.

  • Die ReadElementContentAs-Methoden können nur für Elementknotentypen aufgerufen werden. Diese Methoden können nur für Elemente verwendet werden, die untergeordnete Elemente oder gemischten Inhalt enthalten. Bei einem Aufruf liest das XmlReader-Objekt das Anfangstag und den Elementinhalt und wird hinter das Endelementtag verschoben. Verarbeitungsanweisungen und Kommentare werden ignoriert und Entitäten erweitert.

  • Die ReadContentAs-Methoden lesen den Textinhalt an der aktuellen Readerposition. Wenn den XML-Daten keine Schema- oder Datentypinformationen zugeordnet sind, konvertieren Sie den Textinhalt in den angeforderten Rückgabetyp. Text, Leerraum, signifikanter Leerraum und CDATA-Abschnitte sind verkettet. Kommentare und Verarbeitungsanweisungen werden übersprungen, und Entitätsverweise werden automatisch aufgelöst.

Die XmlReader -Klasse verwendet die Regeln, die durch die Empfehlung W3C XML Schema Part 2: Datatypes definiert sind.

Verwenden Sie diese XmlReader Methode. So geben Sie diesen CLR-Typ zurück
ReadContentAsBoolean und ReadElementContentAsBoolean Boolean
ReadContentAsDateTime und ReadElementContentAsDateTime DateTime
ReadContentAsDouble und ReadElementContentAsDouble Double
ReadContentAsLong und ReadElementContentAsLong Int64
ReadContentAsInt und ReadElementContentAsInt Int32
ReadContentAsString und ReadElementContentAsString String
ReadContentAs und ReadElementContentAs Der Typ, den Sie mit dem returnType Parameter angeben.
ReadContentAsObject und ReadElementContentAsObject Der am besten geeignete Typ, wie von der XmlReader.ValueType -Eigenschaft angegeben. Informationen zur Zuordnung finden Sie unter Typunterstützung im System.Xml Classes .

Wenn ein Element aufgrund seines Formats nicht einfach in einen CLR-Typ konvertiert werden kann, können Sie eine Schemazuordnung verwenden, um eine erfolgreiche Konvertierung sicherzustellen. Im folgenden Beispiel wird eine XSD-Datei verwendet, um das hire-date Element in den xs:date Typ zu konvertieren, und anschließend wird die ReadElementContentAsDateTime -Methode verwendet, um das Element als DateTime -Objekt zurückzugeben.

Eingabe (hireDate.xml):

<employee xmlns="urn:empl-hire">
    <ID>12365</ID>
    <hire-date>2003-01-08</hire-date>
    <title>Accountant</title>
</employee>

Schema (hireDate.xsd):

<?xml version="1.0"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="urn:empl-hire" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="employee">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="ID" type="xs:unsignedShort" />
        <xs:element name="hire-date" type="xs:date" />
        <xs:element name="title" type="xs:string" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

Code:

// Create a validating XmlReader object. The schema
// provides the necessary type information.
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas.Add("urn:empl-hire", "hireDate.xsd");
using (XmlReader reader = XmlReader.Create("hireDate.xml", settings)) {

  // Move to the hire-date element.
  reader.MoveToContent();
  reader.ReadToDescendant("hire-date");

  // Return the hire-date as a DateTime object.
  DateTime hireDate = reader.ReadElementContentAsDateTime();
  Console.WriteLine("Six Month Review Date: {0}", hireDate.AddMonths(6));
}

' Create a validating XmlReader object. The schema 
' provides the necessary type information.
Dim settings As XmlReaderSettings = New XmlReaderSettings()
settings.ValidationType = ValidationType.Schema
settings.Schemas.Add("urn:empl-hire", "hireDate.xsd")
Using reader As XmlReader = XmlReader.Create("hireDate.xml", settings) 
  ' Move to the hire-date element.
  reader.MoveToContent()
  reader.ReadToDescendant("hire-date")

  ' Return the hire-date as a DateTime object.
  Dim hireDate As DateTime = reader.ReadElementContentAsDateTime()
  Console.WriteLine("Six Month Review Date: {0}", hireDate.AddMonths(6))
End Using

Ausgabe:

Six Month Review Date:  7/8/2003 12:00:00 AM

Asynchrone Programmierung

XmlReader Die meisten Methoden verfügen über asynchrone Entsprechungen, die am Ende ihrer Methodennamen "Async" aufweisen. Beispielsweise ist ReadContentAsObjectAsyncdas asynchrone Äquivalent von ReadContentAsObject .

Die folgenden Methoden können mit asynchronen Methodenaufrufen verwendet werden:

In den folgenden Abschnitten wird die asynchrone Verwendung für Methoden ohne asynchrone Entsprechungen beschrieben.

ReadStartElement-Methode

public static async Task ReadStartElementAsync(this XmlReader reader, string localname, string ns)
{
    if (await reader.MoveToContentAsync() != XmlNodeType.Element)
    {
        throw new InvalidOperationException(reader.NodeType.ToString() + " is an invalid XmlNodeType");
    }
    if ((reader.LocalName == localname) && (reader.NamespaceURI == ns))
    {
        await reader.ReadAsync();
    }
    else
    {
        throw new InvalidOperationException("localName or namespace doesn’t match");
    }
}

<Extension()>
Public Async Function ReadStartElementAsync(reader As XmlReader, localname As String, ns As String) As Task
    If (Await reader.MoveToContentAsync() <> XmlNodeType.Element) Then
        Throw New InvalidOperationException(reader.NodeType.ToString() + " is an invalid XmlNodeType")
    End If

    If ((reader.LocalName = localname) And (reader.NamespaceURI = ns)) Then
        Await reader.ReadAsync()
    Else
        Throw New InvalidOperationException("localName or namespace doesn’t match")
    End If
End Function

ReadEndElement-Methode

public static async Task ReadEndElementAsync(this XmlReader reader)
{
    if (await reader.MoveToContentAsync() != XmlNodeType.EndElement)
    {
        throw new InvalidOperationException();
    }
    await reader.ReadAsync();
}

<Extension()>
Public Async Function ReadEndElementAsync(reader As XmlReader) As task
    If (Await reader.MoveToContentAsync() <> XmlNodeType.EndElement) Then
        Throw New InvalidOperationException()
    End If
    Await reader.ReadAsync()
End Function

ReadToNextSibling-Methode

public static async Task<bool> ReadToNextSiblingAsync(this XmlReader reader, string localName, string namespaceURI)
{
    if (localName == null || localName.Length == 0)
    {
        throw new ArgumentException("localName is empty or null");
    }
    if (namespaceURI == null)
    {
        throw new ArgumentNullException("namespaceURI");
    }

    // atomize local name and namespace
    localName = reader.NameTable.Add(localName);
    namespaceURI = reader.NameTable.Add(namespaceURI);

    // find the next sibling
    XmlNodeType nt;
    do
    {
        await reader.SkipAsync();
        if (reader.ReadState != ReadState.Interactive)
            break;
        nt = reader.NodeType;
        if (nt == XmlNodeType.Element &&
             ((object)localName == (object)reader.LocalName) &&
             ((object)namespaceURI ==(object)reader.NamespaceURI))
        {
            return true;
        }
    } while (nt != XmlNodeType.EndElement && !reader.EOF);
    
    return false;
}

<Extension()>
Public Async Function ReadToNextSiblingAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

    If (namespaceURI = Nothing) Then
        Throw New ArgumentNullException("namespaceURI")
    End If

    ' atomize local name and namespace
    localName = reader.NameTable.Add(localName)
    namespaceURI = reader.NameTable.Add(namespaceURI)

    ' find the next sibling
    Dim nt As XmlNodeType
    Do

        Await reader.SkipAsync()
        If (reader.ReadState <> ReadState.Interactive) Then
            Exit Do
        End If
        nt = reader.NodeType
        If ((nt = XmlNodeType.Element) And
           ((CObj(localName) = CObj(reader.LocalName))) And
           (CObj(namespaceURI) = CObj(reader.NamespaceURI))) Then
            Return True
        End If
    Loop While (nt <> XmlNodeType.EndElement And (Not reader.EOF))

    Return False

End Function

ReadToFollowing-Methode

public static async Task<bool> ReadToFollowingAsync(this XmlReader reader, string localName, string namespaceURI)
{
    if (localName == null || localName.Length == 0)
    {
        throw new ArgumentException("localName is empty or null");
    }
    if (namespaceURI == null)
    {
        throw new ArgumentNullException("namespaceURI");
    }

    // atomize local name and namespace
    localName = reader.NameTable.Add(localName);
    namespaceURI = reader.NameTable.Add(namespaceURI);

    // find element with that name
    while (await reader.ReadAsync())
    {
        if (reader.NodeType == XmlNodeType.Element && ((object)localName == (object)reader.LocalName) && ((object)namespaceURI == (object)reader.NamespaceURI))
        {
            return true;
        }
    }
    return false;
}

<Extension()>
Public Async Function ReadToFollowingAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

    If (namespaceURI = Nothing) Then
        Throw New ArgumentNullException("namespaceURI")
    End If

    ' atomize local name and namespace
    localName = reader.NameTable.Add(localName)
    namespaceURI = reader.NameTable.Add(namespaceURI)

    ' find element with that name
    While (Await reader.ReadAsync())
        If ((reader.NodeType = XmlNodeType.Element) And
           (CObj(localName) = CObj(reader.LocalName)) And
           (CObj(namespaceURI) = CObj(reader.NamespaceURI))) Then
            Return True
        End If
    End While

    Return False
End Function

ReadToDescendant-Methode

public static async Task<bool> ReadToDescendantAsync(this XmlReader reader, string localName, string namespaceURI)
{
    if (localName == null || localName.Length == 0)
    {
        throw new ArgumentException("localName is empty or null");
    }
    if (namespaceURI == null)
    {
        throw new ArgumentNullException("namespaceURI");
    }
    // save the element or root depth
    int parentDepth = reader.Depth;
    if (reader.NodeType != XmlNodeType.Element)
    {
        // adjust the depth if we are on root node
        if (reader.ReadState == ReadState.Initial)
        {
            parentDepth--;
        }
        else
        {
            return false;
        }
    }
    else if (reader.IsEmptyElement)
    {
        return false;
    }

    // atomize local name and namespace
    localName = reader.NameTable.Add(localName);
    namespaceURI = reader.NameTable.Add(namespaceURI);

    // find the descendant
    while (await reader.ReadAsync() && reader.Depth > parentDepth)
    {
        if (reader.NodeType == XmlNodeType.Element && ((object)localName == (object)reader.LocalName) && ((object)namespaceURI == (object)reader.NamespaceURI))
        {
            return true;
        }
    }
    return false;
}

<Extension()>
Public Async Function ReadToDescendantAsync(reader As XmlReader, localName As String, namespaceURI As String) As Task(Of Boolean)
    If (localName = Nothing Or localName.Length = 0) Then
        Throw New ArgumentException("localName is empty or null")
    End If

    If (namespaceURI = Nothing) Then
        Throw New ArgumentNullException("namespaceURI")
    End If

    ' save the element or root depth
    Dim parentDepth As Integer = reader.Depth
    If (reader.NodeType <> XmlNodeType.Element) Then
        ' adjust the depth if we are on root node
        If (reader.ReadState = ReadState.Initial) Then
            parentDepth -= 1
        Else
            Return False
        End If
    ElseIf (reader.IsEmptyElement) Then
        Return False
    End If
    ' atomize local name and namespace
    localName = reader.NameTable.Add(localName)
    namespaceURI = reader.NameTable.Add(namespaceURI)

    ' find the descendant
    While (Await reader.ReadAsync() And reader.Depth > parentDepth)
        If (reader.NodeType = XmlNodeType.Element And
           (CObj(localName) = CObj(reader.LocalName)) And
           (CObj(namespaceURI) = CObj(reader.NamespaceURI))) Then
            Return True
        End If
    End While

    Return False
End Function

Sicherheitshinweise

Beachten Sie folgendes, wenn Sie mit der XmlReader -Klasse arbeiten:

  • Ausnahmen, die von ausgelöst XmlReader werden, können Pfadinformationen offenlegen, die möglicherweise nicht in die App eingeblasen werden sollen. Ihre App muss Ausnahmen abfangen und entsprechend verarbeiten.

  • Aktivieren Sie die DTD-Verarbeitung nicht, wenn Sie sich Sorgen über Denial-of-Service-Probleme machen oder wenn Sie mit nicht vertrauenswürdigen Quellen zu tun haben. Die DTD-Verarbeitung ist für XmlReader Objekte, die mit der Create -Methode erstellt wurden, standardmäßig deaktiviert.

    Wenn die DTD-Verarbeitung aktiviert ist, können die Ressourcen, auf die der XmlSecureResolver Zugriff hat, mit dem XmlReader eingeschränkt werden. Sie können Ihre App auch so entwerfen, dass die XML-Verarbeitung arbeitsspeicher- und zeitlimitiert ist. Beispielsweise können Sie Timeoutlimits in Ihrer ASP.NET-App konfigurieren.

  • XML-Daten können Verweise auf externe Ressourcen (z. B. eine Schemadatei) enthalten. Standardmäßig werden externe Ressourcen mithilfe eines XmlUrlResolver Objekts ohne Benutzeranmeldeinformationen aufgelöst. Durch die folgenden Aktionen können Sie die Sicherheit weiter erhöhen:

  • Die ProcessInlineSchema Validierungsflags und ProcessSchemaLocation eines XmlReaderSettings Objekts sind nicht standardmäßig festgelegt. Dadurch wird der XmlReader bei der Verbarbeitung von XML-Daten aus einer nicht vertrauenswürdigen Quelle vor schemabasierten Angriffen geschützt. Wenn diese Flags festgelegt sind, wird der XmlResolver des XmlReaderSettings-Objekts verwendet, um die im Instanzdokument des XmlReader erkannten Schemaspeicherorte aufzulösen. Wenn die XmlResolver Eigenschaft auf nullfestgelegt ist, werden Schemaspeicherorte auch dann nicht aufgelöst, wenn die ProcessInlineSchema Validierungsflags und ProcessSchemaLocation festgelegt sind.

    Durch während der Validierung hinzugefügte Schemas werden neue Typen hinzugefügt, sodass das Validierungsergebnis des überprüften Dokuments möglicherweise geändert wird. Daher sollten externe Schemata nur von vertrauenswürdigen Quellen aufgelöst werden.

    Es wird empfohlen, das ProcessIdentityConstraints Flag zu deaktivieren, wenn nicht vertrauenswürdige, große XML-Dokumente in Hochverfügbarkeitsszenarien für ein Schema überprüft werden, das über Identitätseinschränkungen für einen großen Teil des Dokuments verfügt. Dieses Flag ist standardmäßig aktiviert.

  • XML-Daten können eine Vielzahl von Attributen, Namespacedeklarationen, geschachtelten Elementen usw. enthalten, deren Verarbeitung sehr zeitaufwendig ist. Um die Größe der Eingabe zu begrenzen, die XmlReaderan gesendet wird, können Sie:

    • Begrenzen Sie die Größe des Dokuments, indem Sie die MaxCharactersInDocument -Eigenschaft festlegen.

    • Begrenzen Sie die Anzahl von Zeichen, die sich aus dem Erweitern von Entitäten ergeben, indem Sie die MaxCharactersFromEntities -Eigenschaft festlegen.

    • Erstellen Sie eine benutzerdefinierte IStream Implementierung für .XmlReader

  • Die ReadValueChunk -Methode kann verwendet werden, um große Datenströme zu verarbeiten. Mit dieser Methode wird jeweils eine kleine Anzahl von Zeichen gelesen, anstatt dem ganzen Wert eine einzelne Zeichenfolge zuzuweisen.

  • Beim Lesen eines XML-Dokuments mit einer großen Anzahl eindeutiger lokaler Namen, Namespaces oder Präfixe kann ein Problem auftreten. Wenn Sie eine Klasse verwenden, die von abgeleitet wird XmlReader, und Sie die LocalNameEigenschaft , Prefixoder NamespaceURI für jedes Element aufrufen, wird die zurückgegebene Zeichenfolge zu einer NameTablehinzugefügt. Die Sammlung, die NameTable von gespeichert wird, nimmt nie an Größe ab, was zu einem virtuellen Speicherverlust der Zeichenfolgenhandles führt. Eine Gegenmaßnahme besteht darin, von der NameTable -Klasse abzuleiten und ein maximales Größenkontingent zu erzwingen. (Es gibt keine Möglichkeit, die Verwendung von NameTablezu verhindern oder zu NameTable wechseln, wenn es voll ist.) Eine weitere Entschärfung besteht darin, die Verwendung der erwähnten Eigenschaften zu vermeiden und stattdessen nach Möglichkeit die MoveToAttribute -Methode mit der IsStartElement -Methode zu verwenden. Diese Methoden geben keine Zeichenfolgen zurück und vermeiden somit das Problem, die NameTable Auflistung zu überfüllen.

  • XmlReaderSettings-Objekte können vertrauliche Informationen (z. B. Anmeldeinformationen des Benutzers) enthalten. Eine nicht vertrauenswürdige Komponente könnte mithilfe des XmlReaderSettings-Objekts und den Anmeldeinformationen des Benutzers XmlReader-Objekte erstellen, mit denen Daten gelesen werden können. Seien Sie beim Zwischenspeichern XmlReaderSettings von Objekten oder beim Übergeben des XmlReaderSettings Objekts von einer Komponente an eine andere vorsichtig.

  • Achten Sie darauf, keine Unterstützung für Komponenten aus einer nicht vertrauenswürdigen Quelle zu gewähren (z. B. den Objekten NameTable, XmlNamespaceManager und XmlResolver).

Konstruktoren

XmlReader()

Initialisiert eine neue Instanz der XmlReader-Klasse.

Eigenschaften

AttributeCount

Ruft beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Attribute für den aktuellen Knoten ab.
BaseURI

Ruft beim Überschreiben in einer abgeleiteten Klasse den Basis-URI des aktuellen Knotens ab.
CanReadBinaryContent

Ruft einen Wert ab, der angibt, ob der XmlReader die Methoden für das Lesen von Inhalt im Binärformat implementiert.
CanReadValueChunk

Ruft einen Wert ab, der angibt, ob der XmlReader die angegebene ReadValueChunk(Char[], Int32, Int32)-Methode implementiert.
CanResolveEntity

Ruft einen Wert ab, der angibt, ob dieser Reader Entitäten analysieren und auflösen kann.
Depth

Ruft beim Überschreiben in einer abgeleiteten Klasse die Tiefe des aktuellen Knotens im XML-Dokument ab.
EOF

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob sich der Reader am Ende des Streams befindet.
HasAttributes

Ruft einen Wert ab, der angibt, ob der aktuelle Knoten über Attribute verfügt.
HasValue

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Knoten einen Value aufweisen kann.
IsDefault

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Knoten ein Attribut ist, das aus dem in der DTD oder dem Schema definierten Standardwert generiert wurde.
IsEmptyElement

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob es sich bei dem aktuellen Knoten um ein leeres Element handelt (z. B <MyElement/>. ).
Item[Int32]

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Index ab.
Item[String, String]

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen LocalName und NamespaceURI ab.
Item[String]

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Name ab.
LocalName

Ruft beim Überschreiben in einer abgeleiteten Klasse den lokalen Namen des aktuellen Knotens ab.
Name

Ruft beim Überschreiben in einer abgeleiteten Klasse den qualifizierten Namen des aktuellen Knotens ab.
NamespaceURI

Ruft beim Überschreiben in einer abgeleiteten Klasse den Namespace-URI (entsprechend der Definition in der Namespacespezifikation des W3C) des Knotens ab, auf dem der Reader positioniert ist.
NameTable

Ruft beim Überschreiben in einer abgeleiteten Klasse die XmlNameTable ab, die dieser Implementierung zugeordnet ist.
NodeType

Ruft beim Überschreiben in einer abgeleiteten Klasse den Typ des aktuellen Knotens ab.
Prefix

Ruft beim Überschreiben in einer abgeleiteten Klasse das dem aktuellen Knoten zugeordnete Namespacepräfix ab.
QuoteChar

Ruft beim Überschreiben in einer abgeleiteten Klasse das Anführungszeichen ab, mit dem der Wert eines Attributknotens eingeschlossen wird.
ReadState

Ruft beim Überschreiben in einer abgeleiteten Klasse den Zustand des Readers ab.
SchemaInfo

Ruft die Schemainformationen ab, die dem aktuellen Knoten nach der Schemavalidierung zugewiesen wurden.
Settings

Ruft das zum Erstellen dieser XmlReaderSettings-Instanz verwendete XmlReader-Objekt ab.
Value

Ruft beim Überschreiben in einer abgeleiteten Klasse den Textwert des aktuellen Knotens ab.
ValueType

Ruft den CLR-Typ (Common Language Runtime) für den aktuellen Knoten ab.
XmlLang

Ruft beim Überschreiben in einer abgeleiteten Klasse den aktuellen xml:lang-Bereich ab.
XmlSpace

Ruft beim Überschreiben in einer abgeleiteten Klasse den aktuellen xml:space-Bereich ab.

Methoden

Close()

Ändert beim Überschreiben in einer abgeleiteten Klassen den ReadState in Closed.
Create(Stream)

Erstellt mit dem angegebenen Stream mit den Standardeinstellungen eine neue XmlReader-Instanz.
Create(Stream, XmlReaderSettings)

Erstellt eine neue XmlReader-Instanz mit dem angegebenen Stream und den angegebenen Einstellungen.
Create(Stream, XmlReaderSettings, String)

Erstellt mit dem angegebenen Stream, dem Basis-URI und den Einstellungen eine neue XmlReader-Instanz.
Create(Stream, XmlReaderSettings, XmlParserContext)

Erstellt mit dem angegebenen Stream, den Einstellungen und den Kontextinformationen für Analysezwecke eine neue XmlReader-Instanz.
Create(String)

Erstellt eine neue XmlReader-Instanz mit angegebenem URI.
Create(String, XmlReaderSettings)

Erstellt mit dem angegebenen URI und den angegebenen Einstellungen eine neue XmlReader-Instanz.
Create(String, XmlReaderSettings, XmlParserContext)

Erstellt mit dem angegebenen URI, den Einstellungen und den Kontextinformationen für Analysezwecke eine neue XmlReader-Instanz.
Create(TextReader)

Erstellt mit dem angegebenen Text-Reader eine neue XmlReader-Instanz.
Create(TextReader, XmlReaderSettings)

Erstellt mit dem angegebenen Text-Reader und den angegebenen Einstellungen eine neue XmlReader-Instanz.
Create(TextReader, XmlReaderSettings, String)

Erstellt mit dem angegebenen Text-Reader, den angegebenen Einstellungen und dem angegebenen Basis-URI eine neue XmlReader-Instanz.
Create(TextReader, XmlReaderSettings, XmlParserContext)

Erstellt mit dem angegebenen Text-Reader, den Einstellungen und den Kontextinformationen für Analysezwecke eine neue XmlReader-Instanz.
Create(XmlReader, XmlReaderSettings)

Erstellt mit dem angegebenen XML-Reader und den angegebenen Einstellungen eine neue XmlReader-Instanz.
Dispose()

Gibt alle von der aktuellen Instanz der XmlReader-Klasse verwendeten Ressourcen frei.
Dispose(Boolean)

Gibt die von XmlReader verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.
Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetAttribute(Int32)

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Index ab.
GetAttribute(String)

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Name ab.
GetAttribute(String, String)

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen LocalName und NamespaceURI ab.
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
GetValueAsync()

Ruft den Wert des aktuellen Knotens asynchron ab.
IsName(String)

Gibt einen Wert zurück, der angibt, ob das Zeichenfolgenargument ein gültiger XML-Name ist.
IsNameToken(String)

Gibt einen Wert zurück, der angibt, ob das Zeichenfolgenargument ein gültiges XML-Namenstoken ist.
IsStartElement()

Ruft MoveToContent() auf und überprüft, ob der aktuelle Inhaltsknoten ein Starttag oder ein leeres Elementtag ist.
IsStartElement(String)

Ruft MoveToContent() auf und überprüft, ob der aktuelle Inhaltsknoten ein Starttag oder ein leeres Elementtag ist und die Name-Eigenschaft des gefundenen Elements mit dem angegebenen Argument übereinstimmt.
IsStartElement(String, String)

Ruft MoveToContent() auf und überprüft, ob der aktuelle Inhaltsknoten ein Starttag oder ein leeres Elementtag ist und ob die LocalName-Eigenschaft und die NamespaceURI-Eigenschaft des gefundenen Elements mit den angegebenen Zeichenfolgen übereinstimmen.
LookupNamespace(String)

Löst beim Überschreiben in einer abgeleiteten Klasse ein Namespacepräfix im Gültigkeitsbereich des aktuellen Elements auf.
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MoveToAttribute(Int32)

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum Attribut mit dem angegebenen Index.
MoveToAttribute(String)

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum Attribut mit dem angegebenen Name.
MoveToAttribute(String, String)

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum Attribut mit dem angegebenen LocalName und dem angegebenen NamespaceURI.
MoveToContent()

Überprüft, ob der aktuelle Knoten ein Inhaltsknoten (Textknoten ohne Leerraum, CDATA-, Element-, EndElement-, EntityReference- oder EndEntity-Knoten) ist. Wenn der Knoten kein Inhaltsknoten ist, springt der Reader zum nächsten Inhaltsknoten oder an das Ende der Datei. Knoten folgender Typen werden übersprungen: ProcessingInstruction, DocumentType, Comment, Whitespace und SignificantWhitespace.
MoveToContentAsync()

Asynchrone Überprüfungen, ob der aktuelle Knoten ein Inhaltsknoten ist. Wenn der Knoten kein Inhaltsknoten ist, springt der Reader zum nächsten Inhaltsknoten oder an das Ende der Datei.
MoveToElement()

Wechselt beim Überschreiben in einer abgeleiteten Klasse zu dem Element, das den aktuellen Attributknoten enthält.
MoveToFirstAttribute()

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum ersten Attribut.
MoveToNextAttribute()

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum nächsten Attribut.
Read()

Liest beim Überschreiben in einer abgeleiteten Klasse den nächsten Knoten aus dem Stream.
ReadAsync()

Liest den nächsten Knoten aus dem Stream asynchron.
ReadAttributeValue()

Löst beim Überschreiben in einer abgeleiteten Klasse den Attributwert in einen oder mehrere Knoten vom Typ Text, EntityReference oder EndEntity auf.
ReadContentAs(Type, IXmlNamespaceResolver)

Liest den Inhalt als Objekt vom angegebenen Typ.
ReadContentAsAsync(Type, IXmlNamespaceResolver)

Liest den Inhalt asynchron als Objekt vom angegebenen Typ.
ReadContentAsBase64(Byte[], Int32, Int32)

Liest den Inhalt und gibt die Base64-decodierten binären Bytes zurück.
ReadContentAsBase64Async(Byte[], Int32, Int32)

Liest den Inhalt asynchron und gibt die Base64-decodierten binären Bytes zurück.
ReadContentAsBinHex(Byte[], Int32, Int32)

Liest den Inhalt und gibt die BinHex-decodierten binären Bytes zurück.
ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Liest den Inhalt asynchron und gibt die BinHex-decodierten binären Bytes zurück.
ReadContentAsBoolean()

Liest den Textinhalt an der aktuellen Position als Boolean.
ReadContentAsDateTime()

Liest den Textinhalt an der aktuellen Position als DateTime-Objekt.
ReadContentAsDateTimeOffset()

Liest den Textinhalt an der aktuellen Position als DateTimeOffset-Objekt.
ReadContentAsDecimal()

Liest den Textinhalt an der aktuellen Position als Decimal-Objekt.
ReadContentAsDouble()

Liest den Textinhalt an der aktuellen Position als Gleitkommazahl mit doppelter Genauigkeit.
ReadContentAsFloat()

Liest den Textinhalt an der aktuellen Position als Gleitkommazahl mit einfacher Genauigkeit.
ReadContentAsInt()

Liest den Textinhalt an der aktuellen Position als 32-Bit-Ganzzahl mit Vorzeichen.
ReadContentAsLong()

Liest den Textinhalt an der aktuellen Position als 64-Bit-Ganzzahl mit Vorzeichen.
ReadContentAsObject()

Liest den Textinhalt an der aktuellen Position als Object.
ReadContentAsObjectAsync()

Liest den Textinhalt asynchron an der aktuellen Position als ein Object.
ReadContentAsString()

Liest den Textinhalt an der aktuellen Position als String-Objekt.
ReadContentAsStringAsync()

Liest den Textinhalt asynchron an der aktuellen Position als String-Objekt.
ReadElementContentAs(Type, IXmlNamespaceResolver)

Liest den Elementinhalt als angeforderten Typ.
ReadElementContentAs(Type, IXmlNamespaceResolver, String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, und liest dann den Elementinhalt als angeforderten Typ.
ReadElementContentAsAsync(Type, IXmlNamespaceResolver)

Liest das Elementinhalt asynchron als angeforderten Typ.
ReadElementContentAsBase64(Byte[], Int32, Int32)

Liest das Element und decodiert den Base64-Inhalt.
ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Liest das Element asynchron und decodiert den Base64-Inhalt.
ReadElementContentAsBinHex(Byte[], Int32, Int32)

Liest das Element und decodiert den BinHex-Inhalt.
ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Liest das Element asynchron und decodiert den BinHex-Inhalt.
ReadElementContentAsBoolean()

Liest das aktuelle Element und gibt den Inhalt als Boolean-Objekt zurück.
ReadElementContentAsBoolean(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als Boolean-Objekt zurück.
ReadElementContentAsDateTime()

Liest das aktuelle Element und gibt den Inhalt als DateTime-Objekt zurück.
ReadElementContentAsDateTime(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als DateTime-Objekt zurück.
ReadElementContentAsDecimal()

Liest das aktuelle Element und gibt den Inhalt als Decimal-Objekt zurück.
ReadElementContentAsDecimal(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als Decimal-Objekt zurück.
ReadElementContentAsDouble()

Liest das aktuelle Element und gibt den Inhalt als Gleitkommazahl mit doppelter Genauigkeit zurück.
ReadElementContentAsDouble(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als Gleitkommazahl mit doppelter Genauigkeit zurück.
ReadElementContentAsFloat()

Liest das aktuelle Element und gibt den Inhalt als Gleitkommazahl mit einfacher Genauigkeit zurück.
ReadElementContentAsFloat(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als Gleitkommazahl mit einfacher Genauigkeit zurück.
ReadElementContentAsInt()

Liest das aktuelle Element und gibt den Inhalt als 32-Bit-Ganzzahl mit Vorzeichen zurück.
ReadElementContentAsInt(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als 32-Bit-Ganzzahl mit Vorzeichen zurück.
ReadElementContentAsLong()

Liest das aktuelle Element und gibt den Inhalt als 64-Bit-Ganzzahl mit Vorzeichen zurück.
ReadElementContentAsLong(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als 64-Bit-Ganzzahl mit Vorzeichen zurück.
ReadElementContentAsObject()

Liest das aktuelle Element und gibt den Inhalt als Object zurück.
ReadElementContentAsObject(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als Object zurück.
ReadElementContentAsObjectAsync()

Liest das aktuelle Element asynchron und gibt den Inhalt als Object zurück.
ReadElementContentAsString()

Liest das aktuelle Element und gibt den Inhalt als String-Objekt zurück.
ReadElementContentAsString(String, String)

Überprüft, ob der angegebene lokale Name und der angegebene Namespace-URI mit denen des aktuellen Elements übereinstimmen, liest dann das aktuelle Element und gibt den Inhalt als String-Objekt zurück.
ReadElementContentAsStringAsync()

Liest das aktuelle Element asynchron und gibt den Inhalt als String-Objekt zurück.
ReadElementString()

Liest ein Nur-Text-Element. Sie sollten stattdessen allerdings die ReadElementContentAsString()-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bereitstellt.
ReadElementString(String)

Überprüft vor dem Lesen eines Nur-Text-Elements, ob die Name-Eigenschaft des gefundenen Elements mit der angegebenen Zeichenfolge übereinstimmt. Sie sollten stattdessen allerdings die ReadElementContentAsString()-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bereitstellt.
ReadElementString(String, String)

Überprüft vor dem Lesen eines Nur-Text-Elements, ob die LocalName-Eigenschaft und die NamespaceURI-Eigenschaft des gefundenen Elements mit den angegebenen Zeichenfolgen übereinstimmen. Sie sollten stattdessen allerdings die ReadElementContentAsString(String, String)-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bereitstellt.
ReadEndElement()

Überprüft, ob der aktuelle Inhaltsknoten ein Endtag ist, und verschiebt den Reader auf den nächsten Knoten.
ReadInnerXml()

Liest beim Überschreiben in einer abgeleiteten Klasse den gesamten Inhalt, einschließlich Markup, als Zeichenfolge.
ReadInnerXmlAsync()

Liest asynchron den gesamten Inhalt, einschließlich Markup als Zeichenfolge.
ReadOuterXml()

Liest beim Überschreiben in einer abgeleiteten Klasse den Inhalt (einschließlich Markup) ab, der diesen Knoten und alle untergeordneten Elemente darstellt.
ReadOuterXmlAsync()

Liest den Inhalt, einschließlich Markup, das diesen Knoten und alle untergeordneten Elemente darstellt, asynchron.
ReadStartElement()

Überprüft, ob der aktuelle Knoten ein Element ist, und rückt den Reader zum nächsten Knoten vor.
ReadStartElement(String)

Überprüft, ob der aktuelle Inhaltsknoten ein Element mit dem angegebenen Name ist, und verschiebt den Reader auf den nächsten Knoten.
ReadStartElement(String, String)

Überprüft, ob der aktuelle Inhaltsknoten ein Element mit dem angegebenen LocalName und dem angegebenen NamespaceURI ist, und verschiebt den Reader auf den nächsten Knoten.
ReadString()

Liest beim Überschreiben in einer abgeleiteten Klasse den Inhalt eines Element- oder Textknotens als Zeichenfolge. Sie sollten stattdessen allerdings die ReadElementContentAsString-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bereitstellt.
ReadSubtree()

Gibt eine neue XmlReader-Instanz zurück, die zum Lesen des aktuellen Knotens und aller Nachfolgerknoten verwendet werden kann.
ReadToDescendant(String)

Verschiebt den XmlReader auf das nächste Nachfolgerelement mit dem angegebenen qualifizierten Namen.
ReadToDescendant(String, String)

Verschiebt den XmlReader auf das nächste Nachfolgerelement mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI.
ReadToFollowing(String)

Liest, bis ein Element mit dem angegebenen qualifizierten Namen gefunden wird.
ReadToFollowing(String, String)

Liest, bis ein Element mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI gefunden wird.
ReadToNextSibling(String)

Verschiebt den XmlReader auf das nächste nebengeordnete Element mit dem angegebenen qualifizierten Namen.
ReadToNextSibling(String, String)

Verschiebt den XmlReader auf das nächste nebengeordnete Element mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI.
ReadValueChunk(Char[], Int32, Int32)

Liest umfangreiche Streams von Text, der in ein XML-Dokument eingebettet ist.
ReadValueChunkAsync(Char[], Int32, Int32)

Liest asynchron umfangreiche Streams von Text, der in ein XML-Dokument eingebettet ist.
ResolveEntity()

Löst beim Überschreiben in einer abgeleiteten Klasse den Entitätsverweis für EntityReference-Knoten auf.
Skip()

Überspringt die untergeordneten Elemente des aktuellen Knotens.
SkipAsync()

Überspringt die untergeordneten Elemente des aktuellen Knotens asynchron.
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Eine Beschreibung dieses Elements finden Sie unter Dispose().

Gilt für:

Weitere Informationen