XmlReader Klasse

Referenz

Definition

Namespace:: System.Xml

Assembly:: System.Xml.ReaderWriter.dll

Assembly:: System.Xml.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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: System.Xml.XmlDictionaryReader

System.Xml.XmlNodeReader

System.Xml.XmlTextReader

System.Xml.XmlValidatingReader

Implementiert: IDisposable

Beispiele

Im folgenden Beispielcode wird gezeigt, 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 vorwärtsgeschützten, schreibgeschützten Zugriff auf XML-Daten in einem Dokument oder Stream. Diese Klasse entspricht den Empfehlungen für die W3C Extensible Markup Language (XML) 1.0 (vierte Edition) und die 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, der der Leser positioniert ist. Der ReadState Eigenschaftswert gibt den aktuellen Zustand des XML-Readers an. Die Eigenschaft wird beispielsweise durch die XmlReader.Read Methode und ReadState.Closed die XmlReader.Close Methode festgelegtReadState.Initial. XmlReader bietet auch Datenkonformitätsprüfungen und -überprüfungen für eine DTD oder ein Schema.

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

Vereinfacht die Zustandsverwaltung durch eine natürliche, top-down-Verfahrenseinschränkung.
Unterstützt mehrere Eingabeströme und Layering.
Ermöglicht es dem Client, dem Parser einen Puffer zu geben, in den die Zeichenfolge direkt geschrieben wird und daher die Notwendigkeit einer zusätzlichen Zeichenfolgenkopie vermieden wird.
Unterstützt die selektive Verarbeitung. Der Client kann Elemente überspringen und verarbeiten, die für die Anwendung von Interesse sind. Sie können auch eigenschaften im Voraus festlegen, um zu verwalten, wie der XML-Stream verarbeitet wird (z. B. Normalisierung).

In diesem Abschnitt

Erstellen eines XML-Readers Überprüfen von XML-Daten Datenkonformität Navigieren durch Knoten Lesen von XML-Elementen Lesen von XML-Attributen Lesen von XML-Inhalten Konvertieren in CLR-Typen asynchrone Programmierung Sicherheitsüberlegungen

Erstellen eines XML-Readers

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

Obwohl die .NET Framework konkrete Implementierungen der XmlReader Klasse bereitstellt, z. B. die XmlTextReaderKlassen , XmlNodeReaderund die XmlValidatingReader Klassen, empfehlen wir, 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 auf Anforderung erweitern müssen, möchten Sie ihren Textinhalt nicht normalisieren, oder Sie möchten keine Standardattribute zurückgeben, die Klasse verwenden XmlTextReader .

Um den Satz von Features anzugeben, die Sie auf dem 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 Leser mit derselben Funktionalität zu erstellen oder das System.Xml.XmlReaderSettings Objekt zu ändern, um einen neuen Leser mit einer anderen Reihe von Features zu erstellen. Sie können auch problemlos Features zu einem vorhandenen Leser hinzufügen.

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

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

Überprüfen von XML-Daten

Um die Struktur eines XML-Dokuments und deren Elementbeziehungen, Datentypen und Inhaltseinschränkungen zu definieren, verwenden Sie eine Dokumenttypdefinitionssprache (DTD) oder eine XML-Schemadefinitionssprache (XSD). Ein XML-Dokument gilt als gut gebildet, wenn es alle syntactischen Anforderungen erfüllt, die von der W3C XML 1.0-Empfehlung definiert sind. Es gilt als gültig, wenn es gut gebildet ist und auch den Einschränkungen entspricht, die durch sein DTD oder Schema definiert sind. (Siehe den W3C-XML-Schemateil 1: Strukturen und das W3C-XML-Schemapart 2: Empfehlungen für Datentypen .) Daher sind alle gültigen XML-Dokumente gut gebildet, nicht alle gut gebildeten XML-Dokumente sind gültig.

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

Sie verwenden die folgenden Einstellungen in der XmlReaderSettings Klasse, um anzugeben, welche Art der Überprüfung, falls vorhanden, die XmlReader Instanz unterstützt.

Verwenden dieses Members XmlReaderSettings	Angabe von
DtdProcessing -Eigenschaft	Ob die DTD-Verarbeitung zulässig ist. In der Standardeinstellung ist die DTD-Verarbeitung nicht zulässig.
ValidationType -Eigenschaft	Ob der Leser Daten überprüfen sollte und welche Art der Überprüfung ausgeführt werden soll (DTD oder Schema). In der Standardeinstellung erfolgt keine Validierung.
ValidationEventHandler -Ereignis	Ein Ereignishandler zum Empfangen von Informationen zu Überprüfungsereignissen. Wenn kein Ereignishandler bereitgestellt wird, wird beim ersten Validierungsfehler eine XmlException ausgelöst.
ValidationFlags -Eigenschaft	Zusätzliche Überprüfungsoptionen über die XmlSchemaValidationFlags Aufzählungselemente: - `AllowXmlAttributes`-- Zulassen von XML-Attributen (`xml:*`) in Instanzdokumenten auch dann, wenn sie im Schema nicht definiert sind. Die Attribute werden anhand ihres Datentyps validiert. Weitere Informationen finden Sie auf der XmlSchemaValidationFlags Referenzseite für die Einstellung, die in bestimmten Szenarien verwendet werden soll. (Standardmäßig deaktiviert.) - `ProcessIdentityConstraints`--Prozessidentitätseinschränkungen (`xs:ID`, , `xs:IDREF`, xs:unique``xs:key``xs:keyref) während der Überprüfung aufgetreten. (Standardmäßig aktiviert.) - `ProcessSchemaLocation`--Prozessschemas, die von dem oder `xsi:noNamespaceSchemaLocation` dem `xsi:schemaLocation` Attribut angegeben werden. (Standardmäßig aktiviert.) - `ProcessInlineSchema`-- Verarbeiten von Inline-XML-Schemas während der Überprüfung. (Standardmäßig deaktiviert.) - `ReportValidationWarnings`--Berichtereignisse, 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 Lösung und den Zugriff auf externe Ressourcen. Dies kann externe Entitäten wie DTD und Schemas und alle `xs:include` `xs:import` elemente enthalten, die im XML-Schema enthalten sind. Wenn Sie keine Angabe angeben XmlResolver, wird die XmlReader Standardeinstellung XmlUrlResolver ohne Benutzeranmeldeinformationen verwendet.

Datenkonformität

XML-Leser, 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 des XML-Präfixes, das dem richtigen XML-Namespace-URI zugeordnet ist, ist zulässig.
Die Notationnamen in einer einzelnen Attributdeklaration und NmTokens in einer einzelnen Enumeration NotationType Attributdeklaration sind unterschiedlich.

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

Verwenden dieser XmlReaderSettings Eigenschaft	Beschreibung	Standard
CheckCharacters -Eigenschaft	Aktivieren oder Deaktivieren von Überprüfungen für folgendes: - Zeichen befinden sich im Bereich der gesetzlichen XML-Zeichen, wie durch den Abschnitt 2.2 Zeichen des W3C XML 1.0-Empfehlungs definiert. - Alle XML-Namen sind gültig, wie durch den Abschnitt "2.3 Common Syntactic Constructs " der W3C XML 1.0-Empfehlung definiert. Wenn diese Eigenschaft auf `true` (Standardeinstellung) festgelegt ist, wird eine XmlException Ausnahme ausgelöst, wenn die XML-Datei illegale Zeichen oder ungültige XML-Namen enthält (z. B. ein Elementname beginnt 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, überprüft er immer, ob XML-Namen gültig sind, unabhängig von dieser Einstellung. Hinweis: Die XML 1.0-Empfehlung erfordert die Übereinstimmung auf Dokumentebene, wenn eine DTD vorhanden ist. Wenn der Leser daher für die Unterstützung ConformanceLevel.Fragmentkonfiguriert ist, aber die XML-Daten eine Dokumenttypdefinition (DTD) enthalten, wird eine XmlException Ausgelöst.
ConformanceLevel -Eigenschaft	Wählen Sie die Konformitätsstufe aus, um die Erzwingung zu erzwingen: - Document. Entspricht den Regeln für ein gut formiertes XML 1.0-Dokument. - Fragment. Entspricht den Regeln für ein gut gebildetes 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

Navigieren durch Knoten

Der aktuelle Knoten ist der XML-Knoten, auf dem der XML-Reader aktuell positioniert ist. 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 Datenstrom jeweils einen Knoten. Solche Aufrufe werden in der Regel in 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. Nicht-Inhaltsknoten umfassen 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 Instanz zurück, auf die ReadState.Initialsie festgelegt ist. Diese Methode ist hilfreich für das Erstellen von Grenzen um XML-Elemente; Wenn Sie z. B. Daten an eine andere Komponente zur Verarbeitung übergeben möchten und sie einschränken möchten, auf wie viel Daten die Komponente zugreifen kann.

Sehen Sie sich die XmlReader.Read Referenzseite an, um ein Beispiel für die Navigation durch einen Textdatenstrom jeweils einen Knoten anzuzeigen und den Typ der einzelnen Knoten anzuzeigen.

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

Lesen von XML-Elementen

In der folgenden Tabelle sind die Methoden und Eigenschaften aufgeführt, die die XmlReader Klasse für Verarbeitungselemente 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

Siehe Abschnitt 3.1 der W3C XML 1.0-Empfehlung für Definitionen von Starttags, Endtags und leeren Elementtags.

XmlReader Dieses Mitglied verwenden	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 den Reader zum nächsten Knoten weitergibt (gefolgt von Read).IsStartElement
ReadEndElement-Methode	Überprüfen Sie, ob der aktuelle Knoten ein Endtag ist und den Leser zum nächsten Knoten weitergibt.
ReadElementString-Methode	Lesen eines nur textgeschützten Elements.
ReadToDescendant-Methode	Wechseln Sie den XML-Reader zum nächsten untergeordneten (untergeordneten) Element mit dem angegebenen Namen.
ReadToNextSibling-Methode	Wechseln Sie den XML-Reader zum nächsten gleichgeordneten Element mit dem angegebenen Namen.
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 zum 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 für Elemente gefunden, sind aber auch für XML-Deklarations- und Dokumenttypknoten zulässig.

Wenn sie auf einem Elementknoten positioniert sind, können Sie mit der MoveToAttribute Methode die Attributliste des Elements durchlaufen. Beachten Sie, dass nach MoveToAttribute dem Aufruf knoteneigenschaften wie Name, NamespaceURIund Prefix spiegeln die Eigenschaften dieses Attributs wider, 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.

XmlReader Dieses Mitglied verwenden	Beschreibung
HasAttributes -Eigenschaft	Überprüfen Sie, ob der aktuelle Knoten über Attribute verfügt.
AttributeCount -Eigenschaft	Rufen Sie die Anzahl der Attribute für das aktuelle Element ab.
MoveToFirstAttribute-Methode	Wechseln zum ersten Attribut in einem Element.
MoveToNextAttribute-Methode	Wechseln zum nächsten Attribut in einem Element.
MoveToAttribute-Methode	Wechseln zu einem angegebenen Attribut.
GetAttribute Methode oder Item[] Eigenschaft	Rufen Sie den Wert eines angegebenen Attributs ab.
IsDefault -Eigenschaft	Überprüfen Sie, ob der aktuelle Knoten ein Attribut ist, das aus dem im DTD oder Schema definierten Standardwert generiert wurde.
MoveToElement-Methode	Wechseln Sie zum Element, das das aktuelle Attribut besitzt. Verwenden Sie diese Methode, um nach der Navigation durch die Attribute zu einem Element zurückzukehren.
ReadAttributeValue-Methode	Analysieren Sie den Attributwert in einen oder mehrere `Text`, `EntityReference`oder `EndEntity` Knoten.

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 wird, gibt die Value Eigenschaft die Version, eigenständige und Codierungsinformationen als einzelne Zeichenfolge zurück. XmlReader Objekte, die von der Methode, der Create XmlTextReader Klasse und der XmlValidatingReader Klasse erstellt wurden, stellen die Versions-, eigenständigen und Codierungselemente als Attribute zur Verfügung.

Lesen von Attributen für Dokumenttypknoten

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

Lesen von Attributen für die Verarbeitung von Anweisungsknoten

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 der GetAttribute Methode gelesen werden.

Lesen von XML-Inhalten

Die XmlReader-Klasse enthält die folgenden Elemente, 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.)

XmlReader Dieses Mitglied verwenden	Beschreibung
Value -Eigenschaft	Rufen Sie 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	Rufen Sie den Inhalt eines Elements oder Eines 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 alle Inhalte des aktuellen Knotens ab, einschließlich des Markups, aber 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 alle Inhalte des aktuellen Knotens und ihrer 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 Elemente der Klasse (in der XmlReader folgenden Tabelle aufgeführt) verwenden, um XML-Daten zu lesen und Werte als allgemeine Sprachlaufzeittypen (CLR) anstelle von Zeichenfolgen zurückzugeben. Diese Member ermöglichen es Ihnen, Werte in der Darstellung abzurufen, die für Ihre Codierungsaufgabe am besten geeignet ist, ohne Zeichenfolgenwerte manuell zu analysieren oder zu konvertieren.

Die ReadElementContentAs-Methoden können nur auf 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 Leseposition, und wenn die XML-Daten keine Schema- oder Datentypinformationen enthalten, die dem Text 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ätsbezüge werden automatisch aufgelöst.

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

Verwenden dieser 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. Siehe Typunterstützung in den System.Xml Klassen für Zuordnungsinformationen.

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 verwendet dann die Methode, um das ReadElementContentAsDateTime 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 Gegensätze, die am Ende ihrer Methodennamen über "Async" verfügen. Beispielsweise ist ReadContentAsObjectAsyncdas asynchrone Äquivalent von ReadContentAsObject .

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

In den folgenden Abschnitten werden asynchrone Verwendung für Methoden beschrieben, die keine asynchronen Gegenstücke haben.

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

Berücksichtigen Sie folgendes beim Arbeiten mit der XmlReader Klasse:

Ausnahmen, die von der XmlReader App ausgelöst werden, können Pfadinformationen offenlegen, die Möglicherweise nicht auf Ihre App eingeblasen werden sollen. Ihre App muss Ausnahmen abfangen und entsprechend verarbeiten.
Aktivieren Sie die DTD-Verarbeitung nicht, wenn Sie sich um Denial of Service-Probleme kümmern oder wenn Sie mit nicht vertrauenswürdigen Quellen arbeiten. Die DTD-Verarbeitung ist standardmäßig für XmlReader Objekte deaktiviert, die von der Create Methode erstellt wurden.

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 Zeit eingeschränkt ist. Sie können beispielsweise Zeitlimits 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:
- Beschränken Sie die Ressourcen, auf die der XmlReader zugreifen kann, indem Sie die XmlReaderSettings.XmlResolver-Eigenschaft auf ein XmlSecureResolver-Objekt festlegen.
- Wenn Sie die XmlReader-Eigenschaft auf XmlReaderSettings.XmlResolver festlegen, kann der null keine externen Ressourcen öffnen.
Die Und ProcessSchemaLocation Überprüfungszeichen ProcessInlineSchema eines XmlReaderSettings Objekts sind standardmäßig nicht 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 Eigenschaft auf null" festgelegt" festgelegt ist, werden Schemaspeicherorte nicht aufgelöst, auch wenn die XmlResolver ProcessInlineSchema Und ProcessSchemaLocation Validierungs-Flags 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 beim Überprüfen nicht vertrauenswürdiger, großer XML-Dokumente in hochverfügbarkeitsszenarien gegen ein Schema zu deaktivieren, das Identitätseinschränkungen über 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 beschränken, die an die XmlReaderEingabe gesendet wird, können Sie Folgendes ausführen:
- Beschränken Sie die Größe des Dokuments, indem Sie die MaxCharactersInDocument Eigenschaft festlegen.
- Beschränken Sie die Anzahl der Zeichen, die aus dem Erweitern von Entitäten resultieren, indem Sie die MaxCharactersFromEntities Eigenschaft festlegen.
- Erstellen einer benutzerdefinierten IStream Implementierung für die XmlReader.
Die ReadValueChunk Methode kann verwendet werden, um große Datenströme zu behandeln. 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 von eindeutigen lokalen Namen, Namespaces oder Präfixen kann ein Problem auftreten. Wenn Sie eine Klasse verwenden, die von XmlReader, und Sie die LocalNameEigenschaft Prefix NamespaceURI für jedes Element aufrufen, wird die zurückgegebene Zeichenfolge zu einem NameTablehinzugefügt. Die Sammlung, die von der NameTable nie verkleinert wird, erstellt ein virtuelles Speicherleck der Zeichenfolgenhandpunkte. Eine Entschärfung dafür besteht darin, aus der NameTable Klasse abzuleiten und ein maximales Größenkontingent zu erzwingen. (Es gibt keine Möglichkeit, die Verwendung eines NameTable, oder um zu NameTable wechseln, wenn es voll ist). Eine weitere Entschärfung besteht darin, die erwähnten Eigenschaften zu vermeiden und stattdessen die Methode mit der IsStartElement Methode zu verwendenMoveToAttribute, sofern möglich; diese Methoden geben keine Zeichenfolgen zurück und vermeiden somit das Problem, die Auflistung überfüllen NameTable zu können.
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. Achten Sie beim Zwischenspeichern XmlReaderSettings von Objekten oder beim Übergeben des XmlReaderSettings Objekts von einer Komponente an eine andere.
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 der aktuelle Knoten ein leeres Element ist (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:

Siehe auch

XML-Dokumente und XML-Daten