XmlReader Klasse

Definition

Stellt einen Reader dar, der einen schnellen Zugriff auf XML-Daten bietet, ohne Zwischenspeicher und welcher nur vorwärts möglich ist.Represents a reader that provides fast, noncached, forward-only access to XML data.

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

Beispiele

Der folgende Beispielcode zeigt, wie Sie die asynchrone API verwenden, um XML zu analysieren.The following example code shows how to use the asynchronous API to parse XML.

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ärts Zugriff auf XML-Daten in einem Dokument oder Stream.XmlReader provides forward-only, read-only access to XML data in a document or stream. Diese Klasse entspricht der W3C- Extensible Markup Language (XML) 1,0 (Fourth Edition) und den Namespaces in den Empfehlungen von XML 1,0 (dritte Edition) .This class conforms to the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and the Namespaces in XML 1.0 (third edition) recommendations.

mit XmlReader-Methoden können Sie durch XML-Daten navigieren und den Inhalt eines Knotens lesen.XmlReader methods let you move through XML data and read the contents of a node. Die Eigenschaften der-Klasse geben den Wert des aktuellen Knotens an, in dem der Reader positioniert ist. Der ReadState-Eigenschafts Wert gibt den aktuellen Status des XML-Readers an.The properties of the class reflect the value of the current node, which is where the reader is positioned.The ReadState property value indicates the current state of the XML reader. Beispielsweise wird die-Eigenschaft von der XmlReader.Read-Methode auf ReadState.Initial festgelegt und von der XmlReader.Close-Methode ReadState.Closed.For example, the property is set to ReadState.Initial by the XmlReader.Read method and ReadState.Closed by the XmlReader.Close method. XmlReader bietet auch Überprüfungen der Daten Konformität und Validierung anhand einer DTD oder eines Schemas.XmlReader also provides data conformance checks and validation against a DTD or schema.

XmlReader verwendet ein pullabmodell zum Abrufen von Daten.XmlReader uses a pull model to retrieve data. Dieses Modell:This model:

  • Vereinfacht die Zustands Verwaltung durch eine natürliche, von oben nach unten vorliegende Verfahrensweise.Simplifies state management by a natural, top-down procedural refinement.

  • Unterstützt mehrere Eingabestreams und Schichten.Supports multiple input streams and layering.

  • Ermöglicht dem Client, dem Parser einen Puffer zuzuweisen, in den die Zeichenfolge direkt geschrieben wird, und dadurch die Notwendigkeit einer zusätzlichen Zeichen folgen Kopie zu vermeiden.Enables the client to give the parser a buffer into which the string is directly written, and thus avoids the necessity of an extra string copy.

  • Unterstützt die selektive Verarbeitung.Supports selective processing. Der Client kann Elemente überspringen und die Elemente verarbeiten, die für die Anwendung von Interesse sind.The client can skip items and process those that are of interest to the application. Sie können im Voraus auch Eigenschaften festlegen, um zu verwalten, wie der XML-Stream verarbeitet wird (z. b. Normalisierung).You can also set properties in advance to manage how the XML stream is processed (for example, normalization).

In diesem AbschnittIn this section:

Erstellen eines XML-Readers Creating an XML reader
Validieren von XML-Daten Validating XML data
Daten Konformität Data conformance
Navigieren durch Knoten Navigating through nodes
Lesen von XML-Elementen Reading XML elements
Lesen von XML-Attributen Reading XML attributes
Lesen von XML-Inhalten Reading XML content
In CLR-Typen werden Converting to CLR types
Asynchrone Programmierung Asynchronous programming
Überlegungen zur SicherheitSecurity considerations

Erstellen eines XML-ReadersCreating an XML reader

Verwenden Sie die Create-Methode, um eine XmlReader-Instanz zu erstellen.Use the Create method to create an XmlReader instance.

Obwohl die .NET Framework konkrete Implementierungen der XmlReader-Klasse bereitstellt, wie z. b. die XmlTextReader, XmlNodeReaderund die XmlValidatingReader Klassen, empfiehlt es sich, die spezialisierten Klassen nur in den folgenden Szenarien zu verwenden:Although the .NET Framework provides concrete implementations of the XmlReader class, such as the XmlTextReader, XmlNodeReader, and the XmlValidatingReader classes, we recommend that you use the specialized classes only in these scenarios:

  • Wenn Sie eine XML-DOM-Unterstruktur aus einem XmlNode Objekt lesen möchten, verwenden Sie die XmlNodeReader-Klasse.When you want to read an XML DOM subtree from an XmlNode object, use the XmlNodeReader class. (Diese Klasse unterstützt jedoch keine DTD-oder Schema Validierung.)(However, this class doesn't support DTD or schema validation.)

  • Wenn Sie Entitäten auf Anforderung erweitern müssen, Sie möchten, dass der Text Inhalt normalisiert wird, oder wenn Sie nicht möchten, dass Standard Attribute zurückgegeben werden, verwenden Sie die XmlTextReader-Klasse.If you must expand entities on request, you don't want your text content normalized, or you don't want default attributes returned, use the XmlTextReader class.

Um den Satz von Features anzugeben, den Sie für den XML-Reader aktivieren möchten, übergeben Sie ein System.Xml.XmlReaderSettings-Objekt an die Create-Methode.To specify the set of features you want to enable on the XML reader, pass an System.Xml.XmlReaderSettings object to the Create method. Sie können ein einzelnes System.Xml.XmlReaderSettings Objekt verwenden, um mehrere Reader mit der gleichen Funktionalität zu erstellen, oder das System.Xml.XmlReaderSettings Objekt ändern, um einen neuen Reader mit einem anderen Satz von Funktionen zu erstellen.You can use a single System.Xml.XmlReaderSettings object to create multiple readers with the same functionality, or modify the System.Xml.XmlReaderSettings object to create a new reader with a different set of features. Sie können einem vorhandenen Reader auch problemlos Funktionen hinzufügen.You can also easily add features to an existing reader.

Wenn Sie kein System.Xml.XmlReaderSettings Objekt verwenden, werden die Standardeinstellungen verwendet.If you don't use a System.Xml.XmlReaderSettings object, default settings are used. Weitere Informationen finden Sie auf der Seite Create Referenz.See the Create reference page for details.

XmlReader löst eine XmlException für XML-Analysefehler aus.XmlReader throws an XmlException on XML parse errors. Nachdem eine Ausnahme ausgelöst wurde, ist der Status des Readers nicht vorhersagbar.After an exception is thrown, the state of the reader is not predictable. Beispielsweise kann sich der gemeldete Knotentyp von dem tatsächlichen Knotentyp des aktuellen Knotens unterscheiden.For example, the reported node type may be different from the actual node type of the current node. Verwenden Sie die ReadState-Eigenschaft, um zu überprüfen, ob der Reader den Status Fehler aufweist.Use the ReadState property to check whether the reader is in error state.

Validieren von XML-DatenValidating XML data

Zum Definieren der Struktur eines XML-Dokuments und seiner Element Beziehungen, Datentypen und Inhalts Einschränkungen verwenden Sie eine DTD (Document Type Definition) oder ein XSD-Schema (XML Schema Definition Language).To define the structure of an XML document and its element relationships, data types, and content constraints, you use a document type definition (DTD) or XML Schema definition language (XSD) schema. Ein XML-Dokument wird als wohl geformt betrachtet, wenn es alle syntaktischen Anforderungen erfüllt, die von der W3C-Empfehlung zu XML 1,0definiert werden.An XML document is considered to be well formed if it meets all the syntactical requirements defined by the W3C XML 1.0 Recommendation. Sie wird als gültig betrachtet, wenn Sie wohl geformt ist, und entspricht den Einschränkungen, die durch die DTD oder das Schema definiert sind.It's considered valid if it's well formed and also conforms to the constraints defined by its DTD or schema. (Weitere Informationen finden Sie in den Empfehlungen zum W3C XML Schema Part 1: Structures und W3C XML Schema Part 2: Datatypes .) Obwohl alle gültigen XML-Dokumente wohl geformt sind, sind nicht alle wohlgeformten XML-Dokumente gültig.(See the W3C XML Schema Part 1: Structures and the W3C XML Schema Part 2: Datatypes recommendations.) Therefore, although all valid XML documents are well formed, not all well-formed XML documents are valid.

Sie können die Daten anhand einer DTD, eines XSD-Inline Schemas oder eines XSD-Schemas, das in einem XmlSchemaSet Objekt (einem Cache) gespeichert ist, überprüfen. Diese Szenarien werden auf der Seite Create Referenz beschrieben.You can validate the data against a DTD, an inline XSD Schema, or an XSD Schema stored in an XmlSchemaSet object (a cache); these scenarios are described on the Create reference page. XmlReader unterstützt keine XDR-Schema Validierung (XML-Data Reduced).XmlReader doesn't support XML-Data Reduced (XDR) schema validation.

Verwenden Sie die folgenden Einstellungen für die XmlReaderSettings-Klasse, um anzugeben, welcher Validierungstyp, sofern vorhanden, von der XmlReader Instanz unterstützt wird.You use the following settings on the XmlReaderSettings class to specify what type of validation, if any, the XmlReader instance supports.

Dieses XmlReaderSettings Mitglied verwendenUse this XmlReaderSettings member Angabe vonTo specify
DtdProcessing -EigenschaftDtdProcessing property Gibt an, ob die DTD-Verarbeitung zulässig ist.Whether to allow DTD processing. In der Standardeinstellung ist die DTD-Verarbeitung nicht zulässig.The default is to disallow DTD processing.
ValidationType -EigenschaftValidationType property Gibt an, ob der Reader Daten überprüfen soll und welcher Validierungstyp (DTD oder Schema) durchgeführt werden soll.Whether the reader should validate data, and what type of validation to perform (DTD or schema). In der Standardeinstellung erfolgt keine Validierung.The default is no data validation.
ValidationEventHandler -EreignisValidationEventHandler event Ein Ereignishandler zum Empfangen von Informationen zu Validierungs Ereignissen.An event handler for receiving information about validation events. Wenn kein Ereignishandler bereitgestellt wird, wird beim ersten Validierungsfehler eine XmlException ausgelöst.If an event handler is not provided, an XmlException is thrown on the first validation error.
ValidationFlags -EigenschaftValidationFlags property Zusätzliche Validierungs Optionen durch die XmlSchemaValidationFlags Enumerationsmember:Additional validation options through the XmlSchemaValidationFlags enumeration members:

- AllowXmlAttributes--XML-Attribute (xml:*) in Instanzdokumenten, auch wenn Sie nicht im Schema definiert sind.- AllowXmlAttributes-- Allow XML attributes (xml:*) in instance documents even when they're not defined in the schema. Die Attribute werden anhand ihres Datentyps validiert.The attributes are validated based on their data type. Die in bestimmten Szenarien zu verwendende Einstellung finden Sie auf der XmlSchemaValidationFlags-Referenzseite.See the XmlSchemaValidationFlags reference page for the setting to use in specific scenarios. (Standardmäßig deaktiviert.)(Disabled by default.)
- ProcessIdentityConstraints--Prozess Identitäts Einschränkungen (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique), die während der Validierung aufgetreten sind.- ProcessIdentityConstraints --Process identity constraints (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encountered during validation. (Standardmäßig aktiviert.)(Enabled by default.)
- ProcessSchemaLocation--Prozess Schemas, die durch das xsi:schemaLocation-oder xsi:noNamespaceSchemaLocation-Attribut angegeben werden.- ProcessSchemaLocation --Process schemas specified by the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute. (Standardmäßig aktiviert.)(Enabled by default.)
- ProcessInlineSchema--Inline-XML-Schemas während der Überprüfung verarbeiten.- ProcessInlineSchema-- Process inline XML Schemas during validation. (Standardmäßig deaktiviert.)(Disabled by default.)
- ReportValidationWarningsEreignisse aus, wenn eine Validierungs Warnung auftritt.- ReportValidationWarnings--Report events if a validation warning occurs. 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.A warning is typically issued when there is no DTD or XML Schema to validate a particular element or attribute against. ValidationEventHandler wird zur Benachrichtigung verwendet.The ValidationEventHandler is used for notification. (Standardmäßig deaktiviert.)(Disabled by default.)
Schemas Die für die Validierung zu verwendende XmlSchemaSet.The XmlSchemaSet to use for validation.
XmlResolver -EigenschaftXmlResolver property Der XmlResolver zum Auflösen und Zugreifen auf externe Ressourcen.The XmlResolver for resolving and accessing external resources. Dies kann externe Entitäten wie z. b. DTD und Schemas sowie alle xs:include oder xs:import Elemente enthalten, die im XML-Schema enthalten sind.This can include external entities such as DTD and schemas, and any xs:include or xs:import elements contained in the XML Schema. Wenn Sie keine XmlResolverangeben, wird für die XmlReader ein Standard XmlUrlResolver ohne Benutzer Anmelde Informationen verwendet.If you don't specify an XmlResolver, the XmlReader uses a default XmlUrlResolver with no user credentials.

Daten KonformitätData conformance

XML-Reader, die von der Create-Methode erstellt werden, erfüllen standardmäßig die folgenden Konformitätsanforderungen:XML readers that are created by the Create method meet the following compliance requirements by default:

  • Neue Zeilen und Attributwerte werden gemäß der W3C-Empfehlung für XML 1,0normalisiert.New lines and attribute value are normalized according to the W3C XML 1.0 Recommendation.

  • Alle Entitäten werden automatisch erweitert.All entities are automatically expanded.

  • In der Dokumenttyp Definition deklarierte Standard Attribute werden immer hinzugefügt, auch wenn der Reader nicht validiert wird.Default attributes declared in the document type definition are always added even when the reader doesn't validate.

  • Deklaration des dem richtigen XML-Namespace-URI zugeordneten XML-Präfixes ist zulässig.Declaration of XML prefix mapped to the correct XML namespace URI is allowed.

  • Die Notations Namen in einer einzelnen NotationType Attribut Deklaration und NmTokens in einer einzelnen Enumeration Attribut Deklaration sind unterschiedlich.The notation names in a single NotationType attribute declaration and NmTokens in a single Enumeration attribute declaration are distinct.

Verwenden Sie diese XmlReaderSettings Eigenschaften, um den Typ der Übereinstimmungs Prüfungen anzugeben, die Sie aktivieren möchten:Use these XmlReaderSettings properties to specify the type of conformance checks you want to enable:

Diese XmlReaderSettings Eigenschaft verwendenUse this XmlReaderSettings property BeschreibungTo StandardDefault
CheckCharacters -EigenschaftCheckCharacters property Aktivieren oder deaktivieren Sie folgende Prüfungen:Enable or disable checks for the following:

-Zeichen liegen innerhalb des Bereichs zulässiges XML-Zeichen, wie im Abschnitt 2,2-Zeichen der W3C-Empfehlung zu XML 1,0 definiert.- Characters are within the range of legal XML characters, as defined by the 2.2 Characters section of the W3C XML 1.0 Recommendation.
-Alle XML-Namen sind gültig, wie im Abschnitt 2,3 common syntaktische Konstrukte der W3C-Empfehlung zu XML 1,0 definiert.- All XML names are valid, as defined by the 2.3 Common Syntactic Constructs section of the W3C XML 1.0 Recommendation.

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).When this property is set to true (default), an XmlException exception is thrown if the XML file contains illegal characters or invalid XML names (for example, an element name starts with a number).
Die Überprüfung von Zeichen und Namen ist aktiviert.Character and name checking is enabled.

Durch Festlegen von CheckCharacters auf false wird die Zeichenüberprüfung für Zeichenentitätsverweise deaktiviert.Setting CheckCharacters to false turns off character checking for character entity references. Wenn der Reader Textdaten verarbeitet, überprüft er unabhängig von dieser Einstellung immer, ob die XML-Namen gültig sind.If the reader is processing text data, it always checks that XML names are valid, regardless of this setting. Hinweis: Die XML 1,0-Empfehlung erfordert Konformität auf Dokument Ebene, wenn eine DTD vorhanden ist.Note: The XML 1.0 recommendation requires document-level conformance when a DTD is present. Wenn der Reader für die Unterstützung von ConformanceLevel.Fragmentkonfiguriert ist, die XML-Daten jedoch eine DTD (Document Type Definition) enthalten, wird eine XmlException ausgelöst.Therefore, if the reader is configured to support ConformanceLevel.Fragment, but the XML data contains a document type definition (DTD), an XmlException is thrown.
ConformanceLevel -EigenschaftConformanceLevel property Wählen Sie die zu erzwingende Ebene der Konformität:Choose the level of conformance to enforce:

- Document.- Document. Entspricht den Regeln für ein wohl geformtes XML 1,0-Dokument.Conforms to the rules for a well-formed XML 1.0 document.
- Fragment.- Fragment. Entspricht den Regeln für ein wohl geformtes Dokument Fragment, das als externe analysierte Entitätverwendet werden kann.Conforms to the rules for a well-formed document fragment that can be consumed as an external parsed entity.
- Auto.- Auto. Entspricht der vom Reader festgelegt Ebene.Conforms to the level decided by the reader.

Wenn die Daten nicht übereinstimmen, wird eine XmlException Ausnahme ausgelöst.If the data isn't in conformance, an XmlException exception is thrown.
Document

Der aktuelle Knoten ist der XML-Knoten, auf dem der XML-Reader gerade positioniert ist.The current node is the XML node on which the XML reader is currently positioned. Alle XmlReader Methoden führen Vorgänge in Bezug auf diesen Knoten aus, und alle XmlReader Eigenschaften reflektieren den Wert des aktuellen Knotens.All XmlReader methods perform operations in relation to this node, and all XmlReader properties reflect the value of the current node.

Mithilfe der folgenden Methoden können Sie problemlos durch Knoten navigieren und Daten analysieren.The following methods make it easy to navigate through nodes and parse data.

Diese XmlReaderSettings Methode verwendenUse this XmlReaderSettings method BeschreibungTo
Read Lesen Sie den ersten Knoten, und durchlaufen Sie den Stream einen Knoten gleichzeitig.Read the first node, and advance through the stream one node at a time. Solche Aufrufe werden in der Regel in einer while Schleife ausgeführt.Such calls are typically performed inside a while loop.

Verwenden Sie die NodeType-Eigenschaft, um den Typ (z. b. Attribut, Kommentar, Element usw.) des aktuellen Knotens zu erhalten.Use the NodeType property to get the type (for example, attribute, comment, element, and so on) of the current node.
Skip Überspringt die untergeordneten Elemente des aktuellen Knotens und wechselt zum nächsten Knoten.Skip the children of the current node and move to the next node.
MoveToContent und MoveToContentAsyncMoveToContent and MoveToContentAsync Überspringen Sie nicht-Inhalts Knoten, und wechseln Sie zum nächsten Inhalts Knoten oder zum Ende der Datei.Skip non-content nodes and move to the next content node or to the end of the file.

Nicht-Inhalts Knoten umfassen ProcessingInstruction, DocumentType, Comment, Whitespaceund SignificantWhitespace.Non-content nodes include ProcessingInstruction, DocumentType, Comment, Whitespace, and SignificantWhitespace.

Inhalts Knoten enthalten Text, CDATA, EntityReference und EndEntity, die nicht leer sind.Content nodes include non-white space text, CDATA, EntityReference , and EndEntity.
ReadSubtree Liest ein Element und alle untergeordneten Elemente und gibt eine neue XmlReader-Instanz zurück, die auf ReadState.Initialfestgelegt ist.Read an element and all its children, and return a new XmlReader instance set to ReadState.Initial.

Diese Methode ist nützlich zum Erstellen von Grenzen um XML-Elemente. Wenn Sie z. b. Daten zur Verarbeitung an eine andere Komponente übergeben möchten und den Umfang der Daten einschränken möchten, auf die die Komponente zugreifen kann.This method is useful for creating boundaries around XML elements; for example, if you want to pass data to another component for processing and you want to limit how much of your data the component can access.

Ein Beispiel für die Navigation eines einzelnen Knotens durch einen Textstream und das Anzeigen des Typs der einzelnen Knoten finden Sie auf der XmlReader.Read-Referenzseite.See the XmlReader.Read reference page for an example of navigating through a text stream one node at a time and displaying the type of each node.

In den folgenden Abschnitten wird beschrieben, wie Sie bestimmte Datentypen (z. b. Elemente, Attribute und typisierte Daten) lesen können.The following sections describe how you can read specific types of data, such as elements, attributes, and typed data.

Lesen von XML-ElementenReading XML elements

In der folgenden Tabelle sind die Methoden und Eigenschaften aufgeführt, die die XmlReader-Klasse für die Verarbeitung von Elementen bereitstellt.The following table lists the methods and properties that the XmlReader class provides for processing elements. Nachdem der XmlReader auf einem Element platziert wurde, spiegeln die Knoteneigenschaften, z. B. Name, die Elementwerte wider.After the XmlReader is positioned on an element, the node properties, such as Name, reflect the element values. Zusätzlich zu den unten beschriebenen Membern können auch alle allgemeinen Methoden und Eigenschaften der XmlReader-Klasse zum Verarbeiten von Elementen verwendet werden.In addition to the members described below, any of the general methods and properties of the XmlReader class can also be used to process elements. Sie können beispielsweise mit der ReadInnerXml-Methode den Inhalt eines Elements lesen.For example, you can use the ReadInnerXml method to read the contents of an element.

Hinweis

Informationen zu den Definitionen von Start Tags, Endtags und leeren Element Tags finden Sie in Abschnitt 3,1 der W3C-Empfehlung zu XML 1,0 .See section 3.1 of the W3C XML 1.0 Recommendation for definitions of start tags, end tags, and empty element tags.

Dieses XmlReader Mitglied verwendenUse this XmlReader member BeschreibungTo
IsStartElement-MethodeIsStartElement method Überprüfen Sie, ob der aktuelle Knoten ein Starttag oder ein leeres Elementtag ist.Check if the current node is a start tag or an empty element tag.
ReadStartElement-MethodeReadStartElement method Überprüfen Sie, ob der aktuelle Knoten ein Element ist, und leiten Sie den Reader zum nächsten Knoten (Ruft IsStartElement gefolgt von Read) ab.Check that the current node is an element and advance the reader to the next node (calls IsStartElement followed by Read).
ReadEndElement-MethodeReadEndElement method Überprüfen Sie, ob der aktuelle Knoten ein Endtag ist, und setzen Sie den Reader auf den nächsten Knoten.Check that the current node is an end tag and advance the reader to the next node.
ReadElementString-MethodeReadElementString method Liest ein nur-Text-Element.Read a text-only element.
ReadToDescendant-MethodeReadToDescendant method Der XML-Reader wird zum nächsten untergeordneten Element (untergeordnetes Element), das über den angegebenen Namen verfügt.Advance the XML reader to the next descendant (child) element that has the specified name.
ReadToNextSibling-MethodeReadToNextSibling method Setzen Sie den XML-Reader auf das nächste neben geordnete Element mit dem angegebenen Namen.Advance the XML reader to the next sibling element that has the specified name.
IsEmptyElement -EigenschaftIsEmptyElement property Überprüfen Sie, ob das aktuelle Element über ein Endelementtag verfügt.Check if the current element has an end element tag. Beispiel:For example:

- <item num="123"/> (IsEmptyElement true.)- <item num="123"/> (IsEmptyElement is true.)
- <item num="123"> </item> (IsEmptyElement ist false, obwohl der Inhalt des Elements leer ist.)- <item num="123"> </item> (IsEmptyElement is false, although the element's content is empty.)

Ein Beispiel für das Lesen des Text Inhalts von Elementen finden Sie in der ReadString-Methode.For an example of reading the text content of elements, see the ReadString method. Im folgenden Beispiel werden-Elemente mithilfe einer while-Schleife verarbeitet.The following example processes elements by using a while loop.

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-AttributenReading XML attributes

XML-Attribute werden am häufigsten in-Elementen gefunden, Sie sind jedoch auch auf der XML-Deklaration und den Dokumenttyp Knoten zulässig.XML attributes are most commonly found on elements, but they're also allowed on XML declaration and document type nodes.

Wenn Sie auf einem Elementknoten positioniert ist, können Sie mit der MoveToAttribute-Methode die Attribut Liste des Elements durchgehen.When positioned on an element node, the MoveToAttribute method lets you go through the attribute list of the element. Beachten Sie, dass, nachdem MoveToAttribute aufgerufen wurde, Knoten Eigenschaften wie Name, NamespaceURIund Prefix die Eigenschaften dieses Attributs und nicht die Eigenschaften des Elements, zu dem das Attribut gehört, widerspiegeln.Note that after MoveToAttribute has been called, node properties such as Name, NamespaceURI, and Prefix reflect the properties of that attribute, not the properties of the element the attribute belongs to.

Die XmlReader-Klasse stellt diese Methoden und Eigenschaften bereit, um Attribute für Elemente zu lesen und zu verarbeiten.The XmlReader class provides these methods and properties to read and process attributes on elements.

Dieses XmlReader Mitglied verwendenUse this XmlReader member BeschreibungTo
HasAttributes -EigenschaftHasAttributes property Überprüfen Sie, ob der aktuelle Knoten über Attribute verfügt.Check whether the current node has any attributes.
AttributeCount -EigenschaftAttributeCount property Gibt die Anzahl der Attribute für das aktuelle Element an.Get the number of attributes on the current element.
MoveToFirstAttribute-MethodeMoveToFirstAttribute method Wechselt zum ersten Attribut in einem Element.Move to the first attribute in an element.
MoveToNextAttribute-MethodeMoveToNextAttribute method Wechselt zum nächsten Attribut in einem Element.Move to the next attribute in an element.
MoveToAttribute-MethodeMoveToAttribute method Wechselt zu einem angegebenen Attribut.Move to a specified attribute.
GetAttribute-Methode oder Item[String, String]-EigenschaftGetAttribute method or Item[String, String] property Den Wert eines angegebenen Attributs erhalten.Get the value of a specified attribute.
IsDefault -EigenschaftIsDefault property Überprüfen Sie, ob der aktuelle Knoten ein Attribut ist, das aus dem in der DTD oder dem Schema definierten Standardwert generiert wurde.Check whether the current node is an attribute that was generated from the default value defined in the DTD or schema.
MoveToElement-MethodeMoveToElement method Wechseln Sie zu dem Element, das das aktuelle Attribut besitzt.Move to the element that owns the current attribute. Verwenden Sie diese Methode, um zu einem Element zurückzukehren, nachdem die Attribute durchlaufen wurden.Use this method to return to an element after navigating through its attributes.
ReadAttributeValue-MethodeReadAttributeValue method Analysieren Sie den Attribut Wert in einen oder mehrere Text-, EntityReference-oder EndEntity-Knoten.Parse the attribute value into one or more Text, EntityReference, or EndEntity nodes.

Alle allgemeinen Methoden und Eigenschaften von XmlReader können auch für die Verarbeitung von Attributen verwendet werden.Any of the general XmlReader methods and properties can also be used to process attributes. Beispielsweise reflektieren die XmlReader-Eigenschaft und die Name-Eigenschaft nach dem Positionieren von Value auf einem Attribut die Werte des Attributs.For example, after the XmlReader is positioned on an attribute, the Name and Value properties reflect the values of the attribute. Sie können den Wert des Attributs auch mit einer beliebigen Read-Methode für den Inhalt abrufen.You can also use any of the content Read methods to get the value of the attribute.

In diesem Beispiel wird die AttributeCount-Eigenschaft verwendet, um durch alle Attribute eines Elements zu navigieren.This example uses the AttributeCount property to navigate through all the attributes on an element.

// 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.This example uses the MoveToNextAttribute method in a while loop to navigate through the attributes.

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 für XML-Deklarations KnotenReading attributes on XML declaration nodes

Wenn der XML-Reader auf einem XML-Deklarations Knoten positioniert ist, gibt die Value-Eigenschaft die Versions-, eigenständige und Codierungsinformationen als eine einzelne Zeichenfolge zurück.When the XML reader is positioned on an XML declaration node, the Value property returns the version, standalone, and encoding information as a single string. XmlReader Objekte, die von der Create-Methode, der XmlTextReader-Klasse und der XmlValidatingReader-Klasse erstellt werden, machen die Versions-, eigenständigen und Codierungs Elemente als Attribute verfügbar.XmlReader objects created by the Create method, the XmlTextReader class, and the XmlValidatingReader class expose the version, standalone, and encoding items as attributes.

Lesen von Attributen für Dokumenttyp KnotenReading attributes on document type nodes

Wenn der XML-Reader auf einem Dokumenttyp Knoten positioniert ist, können die-GetAttribute-Methode und die-Eigenschaft Item[String, String] verwendet werden, um die Werte für das System und öffentliche Literale zurückzugeben.When the XML reader is positioned on a document type node, the GetAttribute method and Item[String, String] property can be used to return the values for the SYSTEM and PUBLIC literals. Durch das Aufrufen von reader.GetAttribute("PUBLIC") wird beispielsweise der Wert PUBLIC zurückgegeben.For example, calling reader.GetAttribute("PUBLIC") returns the PUBLIC value.

Lesen von Attributen für Verarbeitungs Anweisungs KnotenReading attributes on processing instruction nodes

Wenn der XmlReader auf einem Verarbeitungsanweisungsknoten positioniert ist, gibt die Value-Eigenschaft den gesamten Textinhalt zurück.When the XmlReader is positioned on a processing instruction node, the Value property returns the entire text content. Elemente im Verarbeitungs Anweisungs Knoten werden nicht als Attribute behandelt.Items in the processing instruction node aren't treated as attributes. Sie können nicht mit der GetAttribute-oder MoveToAttribute-Methode gelesen werden.They can't be read with the GetAttribute or MoveToAttribute method.

Lesen von XML-InhaltenReading XML content

Die XmlReader-Klasse enthält die folgenden Member, die Inhalt aus einer XML-Datei lesen und den Inhalt als Zeichen folgen Werte zurückgeben.The XMLReader class includes the following members that read content from an XML file and return the content as string values. (Informationen zum Zurückgeben von CLR-Typen finden Sie im nächsten Abschnitt.)(To return CLR types, see the next section.)

Dieses XmlReader Mitglied verwendenUse this XmlReader member BeschreibungTo
Value -EigenschaftValue property Den Text Inhalt des aktuellen Knotens erhalten.Get the text content of the current node. Der zurückgegebene Wert hängt vom Knotentyp ab. Weitere Informationen finden Sie auf der Seite Value Referenz.The value returned depends on the node type; see the Value reference page for details.
ReadString-MethodeReadString method Den Inhalt eines Element-oder Text Knotens als Zeichenfolge erhalten.Get the content of an element or text node as a string. Diese Methode hält bei Verarbeitungsanweisungen und Kommentaren an.This method stops on processing instructions and comments.

Ausführliche Informationen dazu, wie diese Methode bestimmte Knoten Typen verarbeitet, finden Sie auf der ReadString-Referenzseite.For details on how this method handles specific node types, see the ReadString reference page.
Die Methoden ReadInnerXml und ReadInnerXmlAsyncReadInnerXml and ReadInnerXmlAsync methods Den gesamten Inhalt des aktuellen Knotens, einschließlich des Markups, ohne Start-und Endtags.Get all the content of the current node, including the markup, but excluding start and end tags. Beispiel für:For example, for:

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

ReadInnerXml gibt Folgendes zurück:ReadInnerXml returns:

this<child id="123"/>
Die Methoden ReadOuterXml und ReadOuterXmlAsyncReadOuterXml and ReadOuterXmlAsync methods Alle Inhalte des aktuellen Knotens und seiner untergeordneten Elemente, einschließlich Markup-und Start-/Endtags, erhalten.Get all the content of the current node and its children, including markup and start/end tags. Beispiel für:For example, for:

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

ReadOuterXml gibt Folgendes zurück:ReadOuterXml returns:

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

Wandeln in CLR-TypenConverting to CLR types

Sie können die Member der XmlReader-Klasse (aufgelistet in der folgenden Tabelle) verwenden, um XML-Daten zu lesen und Werte als Common Language Runtime (CLR)-Typen anstelle von Zeichen folgen zurückzugeben.You can use the members of the XmlReader class (listed in the following table) to read XML data and return values as common language runtime (CLR) types instead of strings. Diese Member ermöglichen es Ihnen, Werte in der Darstellung zu erhalten, die für die Codierungs Aufgabe am besten geeignet ist, ohne die Zeichen folgen Werte manuell analysieren oder konvertieren zu müssen.These members enable you to get values in the representation that is most appropriate for your coding task without having to manually parse or convert string values.

  • Die "Read Element contentas "-Methoden können nur für Elementknoten Typen aufgerufen werden.The ReadElementContentAs methods can only be called on element node types. Diese Methoden können nur für Elemente verwendet werden, die untergeordnete Elemente oder gemischten Inhalt enthalten.These methods cannot be used on elements that contain child elements or mixed content. Bei einem Aufruf liest das XmlReader-Objekt das Anfangstag und den Elementinhalt und wird hinter das Endelementtag verschoben.When called, the XmlReader object reads the start tag, reads the element content, and then moves past the end element tag. Verarbeitungsanweisungen und Kommentare werden ignoriert und Entitäten erweitert.Processing instructions and comments are ignored and entities are expanded.

  • Die "read contentas "-Methoden lesen den Text Inhalt an der aktuellen Readerposition, und wenn den XML-Daten keine Schema-oder Datentyp Informationen zugeordnet sind, konvertieren Sie den Text Inhalt in den angeforderten Rückgabetyp.The ReadContentAs methods read the text content at the current reader position, and if the XML data doesn't have any schema or data type information associated with it, convert the text content to the requested return type. Text, Leerraum, signifikanter Leerraum und CDATA-Abschnitte sind verkettet.Text, white space, significant white space and CDATA sections are concatenated. Kommentare und Verarbeitungsanweisungen werden übersprungen, und Entitäts Verweise werden automatisch aufgelöst.Comments and processing instructions are skipped, and entity references are automatically resolved.

Die XmlReader-Klasse verwendet die durch die Empfehlung W3C XML Schema Part 2: Datatypes definierten Regeln.The XmlReader class uses the rules defined by the W3C XML Schema Part 2: Datatypes recommendation.

Diese XmlReader Methode verwendenUse this XmlReader method So geben Sie den CLR-Typ zurückTo return this CLR type
ReadContentAsBoolean und ReadElementContentAsBooleanReadContentAsBoolean and ReadElementContentAsBoolean Boolean
ReadContentAsDateTime und ReadElementContentAsDateTimeReadContentAsDateTime and ReadElementContentAsDateTime DateTime
ReadContentAsDouble und ReadElementContentAsDoubleReadContentAsDouble and ReadElementContentAsDouble Double
ReadContentAsLong und ReadElementContentAsLongReadContentAsLong and ReadElementContentAsLong Int64
ReadContentAsInt und ReadElementContentAsIntReadContentAsInt and ReadElementContentAsInt Int32
ReadContentAsString und ReadElementContentAsStringReadContentAsString and ReadElementContentAsString String
ReadContentAs und ReadElementContentAsReadContentAs and ReadElementContentAs Der Typ, den Sie mit dem returnType-Parameter angeben.The type you specify with the returnType parameter
ReadContentAsObject und ReadElementContentAsObjectReadContentAsObject and ReadElementContentAsObject Der am besten geeignete Typ, wie von der XmlReader.ValueType-Eigenschaft angegeben.The most appropriate type, as specified by the XmlReader.ValueType property. Informationen zur Zuordnung finden Sie unter Typunterstützung in den System. XML-Klassen .See Type Support in the System.Xml Classes for mapping information.

Wenn ein Element aufgrund seines Formats nicht leicht in einen CLR-Typ konvertiert werden kann, können Sie eine Schema Zuordnung verwenden, um eine erfolgreiche Konvertierung sicherzustellen.If an element can't easily be converted to a CLR type because of its format, you can use a schema mapping to ensure a successful conversion. 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.The following example uses an .xsd file to convert the hire-date element to the xs:date type, and then uses the ReadElementContentAsDateTime method to return the element as a DateTime object.

Eingabe (hireDate. Xml):Input (hireDate.xml):

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

Schema (hireDate. xsd):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>

OrdnungCode:

// 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:Output:

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

Asynchrone ProgrammierungAsynchronous programming

Die meisten XmlReader Methoden verfügen über asynchrone Entsprechungen, deren Methodennamen "Async" aufweisen.Most of the XmlReader methods have asynchronous counterparts that have "Async" at the end of their method names. Beispielsweise ist das asynchrone Äquivalent von ReadContentAsObject ReadContentAsObjectAsync.For example, the asynchronous equivalent of ReadContentAsObject is ReadContentAsObjectAsync.

Die folgenden Methoden können mit asynchronen Methoden aufrufen verwendet werden:The following methods can be used with asynchronous method calls:

In den folgenden Abschnitten wird die asynchrone Verwendung von Methoden beschrieben, die keine asynchronen Entsprechungen aufweisen.The following sections describe asynchronous usage for methods that don't have asynchronous counterparts.

Read Startelements-MethodeReadStartElement method

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

Read-Delta-MethodeReadEndElement method

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

Methode "lesertonextsigend"ReadToNextSibling method

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

Read-by-MethodeReadToFollowing method

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

Methode "read to Nachfolger"ReadToDescendant method

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

SicherheitsüberlegungenSecurity considerations

Beachten Sie Folgendes, wenn Sie mit der XmlReader-Klasse arbeiten:Consider the following when working with the XmlReader class:

  • Ausnahmen, die vom XmlReader ausgelöst werden, können Pfadinformationen offenlegen, die Sie möglicherweise nicht zu ihrer app hinzugefügt haben.Exceptions thrown from the XmlReader can disclose path information that you might not want bubbled up to your app. Ihre APP muss Ausnahmen abfangen und entsprechend verarbeiten.Your app must catch exceptions and process them appropriately.

  • Aktivieren Sie die DTD-Verarbeitung nicht, wenn Sie Probleme mit Denial-of-Service-Problemen haben oder wenn Sie mit nicht vertrauenswürdigen Quellen arbeiten.Do not enable DTD processing if you're concerned about denial of service issues or if you're dealing with untrusted sources. Die DTD-Verarbeitung ist für XmlReader von der Create-Methode erstellten Objekte standardmäßig deaktiviert.DTD processing is disabled by default for XmlReader objects created by the Create method.

    Wenn die DTD-Verarbeitung aktiviert ist, können die Ressourcen, auf die der XmlSecureResolver Zugriff hat, mit dem XmlReader eingeschränkt werden.If you have DTD processing enabled, you can use the XmlSecureResolver to restrict the resources that the XmlReader can access. Sie können Ihre APP auch so entwerfen, dass die XML-Verarbeitung Speicher und Zeit eingeschränkt ist.You can also design your app so that the XML processing is memory and time constrained. Beispielsweise können Sie Timeout Limits in Ihrer ASP.net-App konfigurieren.For example, you can configure time-out limits in your ASP.NET app.

  • XML-Daten können Verweise auf externe Ressourcen (z. B. eine Schemadatei) enthalten.XML data can include references to external resources such as a schema file. Externe Ressourcen werden standardmäßig mithilfe eines XmlUrlResolver Objekts ohne Benutzer Anmelde Informationen aufgelöst.By default, external resources are resolved by using an XmlUrlResolver object with no user credentials. Durch die folgenden Aktionen können Sie die Sicherheit weiter erhöhen:You can secure this further by doing one of the following:

  • Die ProcessInlineSchema-und ProcessSchemaLocation-Validierungsflags eines XmlReaderSettings-Objekts sind nicht standardmäßig festgelegt.The ProcessInlineSchema and ProcessSchemaLocation validation flags of an XmlReaderSettings object aren't set by default. Dadurch wird der XmlReader bei der Verbarbeitung von XML-Daten aus einer nicht vertrauenswürdigen Quelle vor schemabasierten Angriffen geschützt.This helps to protect the XmlReader against schema-based attacks when it is processing XML data from an untrusted source. Wenn diese Flags festgelegt sind, wird der XmlResolver des XmlReaderSettings-Objekts verwendet, um die im Instanzdokument des XmlReader erkannten Schemaspeicherorte aufzulösen.When these flags are set, the XmlResolver of the XmlReaderSettings object is used to resolve schema locations encountered in the instance document in the XmlReader. Wenn die XmlResolver-Eigenschaft auf nullfestgelegt ist, werden Schema Speicherorte nicht aufgelöst, auch wenn die ProcessInlineSchema und ProcessSchemaLocation-Validierungsflags festgelegt sind.If the XmlResolver property is set to null, schema locations aren't resolved even if the ProcessInlineSchema and ProcessSchemaLocation validation flags are set.

    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.Schemas added during validation add new types and can change the validation outcome of the document being validated. Daher sollten externe Schemata nur von vertrauenswürdigen Quellen aufgelöst werden.As a result, external schemas should only be resolved from trusted sources.

    Es wird empfohlen, das ProcessIdentityConstraints-Flag zu deaktivieren, wenn nicht vertrauenswürdige, große XML-Dokumente in Szenarios mit hoher Verfügbarkeit auf ein Schema überprüft werden, das über Identitäts Einschränkungen für einen großen Teil des Dokuments verfügt.We recommend disabling the ProcessIdentityConstraints flag when validating untrusted, large XML documents in high availability scenarios against a schema that has identity constraints over a large part of the document. Dieses Flag ist standardmäßig aktiviert.This flag is enabled by default.

  • XML-Daten können eine Vielzahl von Attributen, Namespacedeklarationen, geschachtelten Elementen usw. enthalten, deren Verarbeitung sehr zeitaufwendig ist.XML data can contain a large number of attributes, namespace declarations, nested elements and so on that require a substantial amount of time to process. Um die Größe der Eingabe einzuschränken, die an den XmlReadergesendet wird, können Sie folgende Aktionen ausführen:To limit the size of the input that is sent to the XmlReader, you can:

    • Schränken Sie die Größe des Dokuments ein, indem Sie die MaxCharactersInDocument-Eigenschaft festlegen.Limit the size of the document by setting the MaxCharactersInDocument property.

    • Begrenzen Sie die Anzahl der Zeichen, die sich aus dem Erweitern von Entitäten ergeben, indem Sie die MaxCharactersFromEntities-EigenschaftLimit the number of characters that result from expanding entities by setting the MaxCharactersFromEntities property.

    • Erstellen Sie eine benutzerdefinierte IStream Implementierung für die XmlReader.Create a custom IStream implementation for the XmlReader.

  • Die ReadValueChunk-Methode kann verwendet werden, um große Datenströme zu verarbeiten.The ReadValueChunk method can be used to handle large streams of data. Mit dieser Methode wird jeweils eine kleine Anzahl von Zeichen gelesen, anstatt dem ganzen Wert eine einzelne Zeichenfolge zuzuweisen.This method reads a small number of characters at a time instead of allocating a single string for the whole value.

  • Beim Lesen eines XML-Dokuments mit einer großen Anzahl von eindeutigen lokalen Namen, Namespaces oder Präfixen kann ein Problem auftreten.When reading an XML document with a large number of unique local names, namespaces, or prefixes, a problem can occur. Wenn Sie eine Klasse verwenden, die von XmlReaderabgeleitet ist, und Sie die Eigenschaft LocalName, Prefixoder NamespaceURI für jedes Element aufzurufen, wird die zurückgegebene Zeichenfolge zu einer NameTablehinzugefügt.If you are using a class that derives from XmlReader, and you call the LocalName, Prefix, or NamespaceURI property for each item, the returned string is added to a NameTable. Die Auflistung, die vom NameTable gehalten wird, verringert die Größe nie, was zu einem virtuellen Arbeitsspeicher-Leck der Zeichen folgen Handles führt.The collection held by the NameTable never decreases in size, creating a virtual memory leak of the string handles. Eine Entschärfung hierfür besteht darin, von der NameTable Klasse abzuleiten und ein Kontingent für die maximale Größe zu erzwingen.One mitigation for this is to derive from the NameTable class and enforce a maximum size quota. (Es gibt keine Möglichkeit, die Verwendung einer NameTablezu verhindern oder die NameTable zu wechseln, wenn Sie voll ist.)(There is no way to prevent the use of a NameTable, or to switch the NameTable when it is full). Eine weitere Entschärfung besteht darin, die Verwendung der erwähnten Eigenschaften zu vermeiden und stattdessen die MoveToAttribute Methode mit der IsStartElement-Methode zu verwenden, sofern möglich. Diese Methoden geben keine Zeichen folgen zurück und vermeiden so das Problem der Überfüllung der NameTable Auflistung.Another mitigation is to avoid using the properties mentioned and instead use the MoveToAttribute method with the IsStartElement method where possible; those methods don't return strings and thus avoid the problem of overfilling the NameTable collection.

  • XmlReaderSettings-Objekte können vertrauliche Informationen (z. B. Anmeldeinformationen des Benutzers) enthalten.XmlReaderSettings objects can contain sensitive information such as user credentials. 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.An untrusted component could use the XmlReaderSettings object and its user credentials to create XmlReader objects to read data. Seien Sie vorsichtig, wenn Sie XmlReaderSettings Objekte zwischenspeichern oder das XmlReaderSettings Objekt von einer Komponente an eine andere übergeben.Be careful when caching XmlReaderSettings objects, or when passing the XmlReaderSettings object from one component to another.

  • 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).Do not accept supporting components, such as NameTable, XmlNamespaceManager, and XmlResolver objects, from an untrusted source.

Konstruktoren

XmlReader()

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

Eigenschaften

AttributeCount

Ruft beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Attribute für den aktuellen Knoten ab.When overridden in a derived class, gets the number of attributes on the current node.

BaseURI

Ruft beim Überschreiben in einer abgeleiteten Klasse den Basis-URI des aktuellen Knotens ab.When overridden in a derived class, gets the base URI of the current node.

CanReadBinaryContent

Ruft einen Wert ab, der angibt, ob der XmlReader die Methoden für das Lesen von Inhalt im Binärformat implementiert.Gets a value indicating whether the XmlReader implements the binary content read methods.

CanReadValueChunk

Ruft einen Wert ab, der angibt, ob der XmlReader die angegebene ReadValueChunk(Char[], Int32, Int32)-Methode implementiert.Gets a value indicating whether the XmlReader implements the ReadValueChunk(Char[], Int32, Int32) method.

CanResolveEntity

Ruft einen Wert ab, der angibt, ob dieser Reader Entitäten analysieren und auflösen kann.Gets a value indicating whether this reader can parse and resolve entities.

Depth

Ruft beim Überschreiben in einer abgeleiteten Klasse die Tiefe des aktuellen Knotens im XML-Dokument ab.When overridden in a derived class, gets the depth of the current node in the XML document.

EOF

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob sich der Reader am Ende des Streams befindet.When overridden in a derived class, gets a value indicating whether the reader is positioned at the end of the stream.

HasAttributes

Ruft einen Wert ab, der angibt, ob der aktuelle Knoten über Attribute verfügt.Gets a value indicating whether the current node has any attributes.

HasValue

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Knoten einen Value aufweisen kann.When overridden in a derived class, gets a value indicating whether the current node can have a Value.

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.When overridden in a derived class, gets a value indicating whether the current node is an attribute that was generated from the default value defined in the DTD or schema.

IsEmptyElement

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Knoten ein leeres Element ist (z.B. <MyElement/>).When overridden in a derived class, gets a value indicating whether the current node is an empty element (for example, <MyElement/>).

Item[Int32]

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Index ab.When overridden in a derived class, gets the value of the attribute with the specified index.

Item[String, String]

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen LocalName und NamespaceURI ab.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

Item[String]

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Name ab.When overridden in a derived class, gets the value of the attribute with the specified Name.

LocalName

Ruft beim Überschreiben in einer abgeleiteten Klasse den lokalen Namen des aktuellen Knotens ab.When overridden in a derived class, gets the local name of the current node.

Name

Ruft beim Überschreiben in einer abgeleiteten Klasse den qualifizierten Namen des aktuellen Knotens ab.When overridden in a derived class, gets the qualified name of the current node.

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.When overridden in a derived class, gets the namespace URI (as defined in the W3C Namespace specification) of the node on which the reader is positioned.

NameTable

Ruft beim Überschreiben in einer abgeleiteten Klasse die XmlNameTable ab, die dieser Implementierung zugeordnet ist.When overridden in a derived class, gets the XmlNameTable associated with this implementation.

NodeType

Ruft beim Überschreiben in einer abgeleiteten Klasse den Typ des aktuellen Knotens ab.When overridden in a derived class, gets the type of the current node.

Prefix

Ruft beim Überschreiben in einer abgeleiteten Klasse das dem aktuellen Knoten zugeordnete Namespacepräfix ab.When overridden in a derived class, gets the namespace prefix associated with the current node.

QuoteChar

Ruft beim Überschreiben in einer abgeleiteten Klasse das Anführungszeichen ab, mit dem der Wert eines Attributknotens eingeschlossen wird.When overridden in a derived class, gets the quotation mark character used to enclose the value of an attribute node.

ReadState

Ruft beim Überschreiben in einer abgeleiteten Klasse den Zustand des Readers ab.When overridden in a derived class, gets the state of the reader.

SchemaInfo

Ruft die Schemainformationen ab, die dem aktuellen Knoten nach der Schemavalidierung zugewiesen wurden.Gets the schema information that has been assigned to the current node as a result of schema validation.

Settings

Ruft das zum Erstellen dieser XmlReaderSettings-Instanz verwendete XmlReader-Objekt ab.Gets the XmlReaderSettings object used to create this XmlReader instance.

Value

Ruft beim Überschreiben in einer abgeleiteten Klasse den Textwert des aktuellen Knotens ab.When overridden in a derived class, gets the text value of the current node.

ValueType

Ruft den CLR-Typ (Common Language Runtime) für den aktuellen Knoten ab.Gets The Common Language Runtime (CLR) type for the current node.

XmlLang

Ruft beim Überschreiben in einer abgeleiteten Klasse den aktuellen xml:lang-Bereich ab.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace

Ruft beim Überschreiben in einer abgeleiteten Klasse den aktuellen xml:space-Bereich ab.When overridden in a derived class, gets the current xml:space scope.

Methoden

Close()

Ändert beim Überschreiben in einer abgeleiteten Klassen den ReadState in Closed.When overridden in a derived class, changes the ReadState to Closed.

Create(Stream)

Erstellt mit dem angegebenen Stream mit den Standardeinstellungen eine neue XmlReader-Instanz.Creates a new XmlReader instance using the specified stream with default settings.

Create(Stream, XmlReaderSettings)

Erstellt eine neue XmlReader-Instanz mit dem angegebenen Stream und den angegebenen Einstellungen.Creates a new XmlReader instance with the specified stream and settings.

Create(Stream, XmlReaderSettings, String)

Erstellt mit dem angegebenen Stream, dem Basis-URI und den Einstellungen eine neue XmlReader-Instanz.Creates a new XmlReader instance using the specified stream, base URI, and settings.

Create(Stream, XmlReaderSettings, XmlParserContext)

Erstellt mit dem angegebenen Stream, den Einstellungen und den Kontextinformationen für Analysezwecke eine neue XmlReader-Instanz.Creates a new XmlReader instance using the specified stream, settings, and context information for parsing.

Create(String)

Erstellt eine neue XmlReader-Instanz mit angegebenem URI.Creates a new XmlReader instance with specified URI.

Create(String, XmlReaderSettings)

Erstellt mit dem angegebenen URI und den angegebenen Einstellungen eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified URI and settings.

Create(String, XmlReaderSettings, XmlParserContext)

Erstellt mit dem angegebenen URI, den Einstellungen und den Kontextinformationen für Analysezwecke eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified URI, settings, and context information for parsing.

Create(TextReader)

Erstellt mit dem angegebenen Text-Reader eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified text reader.

Create(TextReader, XmlReaderSettings)

Erstellt mit dem angegebenen Text-Reader und den angegebenen Einstellungen eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified text reader and settings.

Create(TextReader, XmlReaderSettings, String)

Erstellt mit dem angegebenen Text-Reader, den angegebenen Einstellungen und dem angegebenen Basis-URI eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified text reader, settings, and base URI.

Create(TextReader, XmlReaderSettings, XmlParserContext)

Erstellt mit dem angegebenen Text-Reader, den Einstellungen und den Kontextinformationen für Analysezwecke eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified text reader, settings, and context information for parsing.

Create(XmlReader, XmlReaderSettings)

Erstellt mit dem angegebenen XML-Reader und den angegebenen Einstellungen eine neue XmlReader-Instanz.Creates a new XmlReader instance by using the specified XML reader and settings.

Dispose()

Gibt alle von der aktuellen Instanz der XmlReader-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the XmlReader class.

Dispose(Boolean)

Gibt die von XmlReader verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the XmlReader and optionally releases the managed resources.

Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetAttribute(Int32)

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Index ab.When overridden in a derived class, gets the value of the attribute with the specified index.

GetAttribute(String)

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen Name ab.When overridden in a derived class, gets the value of the attribute with the specified Name.

GetAttribute(String, String)

Ruft beim Überschreiben in einer abgeleiteten Klasse den Wert des Attributs mit dem angegebenen LocalName und NamespaceURI ab.When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetType()

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

(Geerbt von Object)
GetValueAsync()

Ruft den Wert des aktuellen Knotens asynchron ab.Asynchronously gets the value of the current node.

IsName(String)

Gibt einen Wert zurück, der angibt, ob das Zeichenfolgenargument ein gültiger XML-Name ist.Returns a value indicating whether the string argument is a valid XML name.

IsNameToken(String)

Gibt einen Wert zurück, der angibt, ob das Zeichenfolgenargument ein gültiges XML-Namenstoken ist.Returns a value indicating whether or not the string argument is a valid XML name token.

IsStartElement()

Ruft MoveToContent() auf und überprüft, ob der aktuelle Inhaltsknoten ein Starttag oder ein leeres Elementtag ist.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag.

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.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag and if the Name property of the element found matches the given argument.

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.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag and if the LocalName and NamespaceURI properties of the element found match the given strings.

LookupNamespace(String)

Löst beim Überschreiben in einer abgeleiteten Klasse ein Namespacepräfix im Gültigkeitsbereich des aktuellen Elements auf.When overridden in a derived class, resolves a namespace prefix in the current element's scope.

MemberwiseClone()

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

(Geerbt von Object)
MoveToAttribute(Int32)

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum Attribut mit dem angegebenen Index.When overridden in a derived class, moves to the attribute with the specified index.

MoveToAttribute(String)

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum Attribut mit dem angegebenen Name.When overridden in a derived class, moves to the attribute with the specified Name.

MoveToAttribute(String, String)

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum Attribut mit dem angegebenen LocalName und dem angegebenen NamespaceURI.When overridden in a derived class, moves to the attribute with the specified LocalName and NamespaceURI.

MoveToContent()

Überprüft, ob der aktuelle Knoten ein Inhaltsknoten (Textknoten ohne Leerraum, CDATA-, Element-, EndElement-, EntityReference- oder EndEntity-Knoten) ist.Checks whether the current node is a content (non-white space text, CDATA, Element, EndElement, EntityReference, or EndEntity) node. Wenn der Knoten kein Inhaltsknoten ist, springt der Reader zum nächsten Inhaltsknoten oder an das Ende der Datei.If the node is not a content node, the reader skips ahead to the next content node or end of file. Knoten folgender Typen werden übersprungen: ProcessingInstruction, DocumentType, Comment, Whitespace und SignificantWhitespace.It skips over nodes of the following type: ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.

MoveToContentAsync()

Asynchrone Überprüfungen, ob der aktuelle Knoten ein Inhaltsknoten ist.Asynchronously checks whether the current node is a content node. Wenn der Knoten kein Inhaltsknoten ist, springt der Reader zum nächsten Inhaltsknoten oder an das Ende der Datei.If the node is not a content node, the reader skips ahead to the next content node or end of file.

MoveToElement()

Wechselt beim Überschreiben in einer abgeleiteten Klasse zu dem Element, das den aktuellen Attributknoten enthält.When overridden in a derived class, moves to the element that contains the current attribute node.

MoveToFirstAttribute()

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum ersten Attribut.When overridden in a derived class, moves to the first attribute.

MoveToNextAttribute()

Wechselt beim Überschreiben in einer abgeleiteten Klasse zum nächsten Attribut.When overridden in a derived class, moves to the next attribute.

Read()

Liest beim Überschreiben in einer abgeleiteten Klasse den nächsten Knoten aus dem Stream.When overridden in a derived class, reads the next node from the stream.

ReadAsync()

Liest den nächsten Knoten aus dem Stream asynchron.Asynchronously reads the next node from the stream.

ReadAttributeValue()

Löst beim Überschreiben in einer abgeleiteten Klasse den Attributwert in einen oder mehrere Knoten vom Typ Text, EntityReference oder EndEntity auf.When overridden in a derived class, parses the attribute value into one or more Text, EntityReference, or EndEntity nodes.

ReadContentAs(Type, IXmlNamespaceResolver)

Liest den Inhalt als Objekt vom angegebenen Typ.Reads the content as an object of the type specified.

ReadContentAsAsync(Type, IXmlNamespaceResolver)

Liest den Inhalt asynchron als Objekt vom angegebenen Typ.Asynchronously reads the content as an object of the type specified.

ReadContentAsBase64(Byte[], Int32, Int32)

Liest den Inhalt und gibt die Base64-decodierten binären Bytes zurück.Reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBase64Async(Byte[], Int32, Int32)

Liest den Inhalt asynchron und gibt die Base64-decodierten binären Bytes zurück.Asynchronously reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBinHex(Byte[], Int32, Int32)

Liest den Inhalt und gibt die BinHex-decodierten binären Bytes zurück.Reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Liest den Inhalt asynchron und gibt die BinHex-decodierten binären Bytes zurück.Asynchronously reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBoolean()

Liest den Textinhalt an der aktuellen Position als Boolean.Reads the text content at the current position as a Boolean.

ReadContentAsDateTime()

Liest den Textinhalt an der aktuellen Position als DateTime-Objekt.Reads the text content at the current position as a DateTime object.

ReadContentAsDateTimeOffset()

Liest den Textinhalt an der aktuellen Position als DateTimeOffset-Objekt.Reads the text content at the current position as a DateTimeOffset object.

ReadContentAsDecimal()

Liest den Textinhalt an der aktuellen Position als Decimal-Objekt.Reads the text content at the current position as a Decimal object.

ReadContentAsDouble()

Liest den Textinhalt an der aktuellen Position als Gleitkommazahl mit doppelter Genauigkeit.Reads the text content at the current position as a double-precision floating-point number.

ReadContentAsFloat()

Liest den Textinhalt an der aktuellen Position als Gleitkommazahl mit einfacher Genauigkeit.Reads the text content at the current position as a single-precision floating point number.

ReadContentAsInt()

Liest den Textinhalt an der aktuellen Position als 32-Bit-Ganzzahl mit Vorzeichen.Reads the text content at the current position as a 32-bit signed integer.

ReadContentAsLong()

Liest den Textinhalt an der aktuellen Position als 64-Bit-Ganzzahl mit Vorzeichen.Reads the text content at the current position as a 64-bit signed integer.

ReadContentAsObject()

Liest den Textinhalt an der aktuellen Position als Object.Reads the text content at the current position as an Object.

ReadContentAsObjectAsync()

Liest den Textinhalt asynchron an der aktuellen Position als ein Object.Asynchronously reads the text content at the current position as an Object.

ReadContentAsString()

Liest den Textinhalt an der aktuellen Position als String-Objekt.Reads the text content at the current position as a String object.

ReadContentAsStringAsync()

Liest den Textinhalt asynchron an der aktuellen Position als String-Objekt.Asynchronously reads the text content at the current position as a String object.

ReadElementContentAs(Type, IXmlNamespaceResolver)

Liest den Elementinhalt als angeforderten Typ.Reads the element content as the requested type.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the element content as the requested type.

ReadElementContentAsAsync(Type, IXmlNamespaceResolver)

Liest das Elementinhalt asynchron als angeforderten Typ.Asynchronously reads the element content as the requested type.

ReadElementContentAsBase64(Byte[], Int32, Int32)

Liest das Element und decodiert den Base64-Inhalt.Reads the element and decodes the Base64 content.

ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Liest das Element asynchron und decodiert den Base64-Inhalt.Asynchronously reads the element and decodes the Base64 content.

ReadElementContentAsBinHex(Byte[], Int32, Int32)

Liest das Element und decodiert den BinHex-Inhalt.Reads the element and decodes the BinHex content.

ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Liest das Element asynchron und decodiert den BinHex-Inhalt.Asynchronously reads the element and decodes the BinHex content.

ReadElementContentAsBoolean()

Liest das aktuelle Element und gibt den Inhalt als Boolean-Objekt zurück.Reads the current element and returns the contents as a Boolean object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a Boolean object.

ReadElementContentAsDateTime()

Liest das aktuelle Element und gibt den Inhalt als DateTime-Objekt zurück.Reads the current element and returns the contents as a DateTime object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a DateTime object.

ReadElementContentAsDecimal()

Liest das aktuelle Element und gibt den Inhalt als Decimal-Objekt zurück.Reads the current element and returns the contents as a Decimal object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a Decimal object.

ReadElementContentAsDouble()

Liest das aktuelle Element und gibt den Inhalt als Gleitkommazahl mit doppelter Genauigkeit zurück.Reads the current element and returns the contents as a double-precision floating-point number.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a double-precision floating-point number.

ReadElementContentAsFloat()

Liest das aktuelle Element und gibt den Inhalt als Gleitkommazahl mit einfacher Genauigkeit zurück.Reads the current element and returns the contents as single-precision floating-point number.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a single-precision floating-point number.

ReadElementContentAsInt()

Liest das aktuelle Element und gibt den Inhalt als 32-Bit-Ganzzahl mit Vorzeichen zurück.Reads the current element and returns the contents as a 32-bit signed integer.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a 32-bit signed integer.

ReadElementContentAsLong()

Liest das aktuelle Element und gibt den Inhalt als 64-Bit-Ganzzahl mit Vorzeichen zurück.Reads the current element and returns the contents as a 64-bit signed integer.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a 64-bit signed integer.

ReadElementContentAsObject()

Liest das aktuelle Element und gibt den Inhalt als Object zurück.Reads the current element and returns the contents as an Object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as an Object.

ReadElementContentAsObjectAsync()

Liest das aktuelle Element asynchron und gibt den Inhalt als Object zurück.Asynchronously reads the current element and returns the contents as an Object.

ReadElementContentAsString()

Liest das aktuelle Element und gibt den Inhalt als String-Objekt zurück.Reads the current element and returns the contents as a String object.

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.Checks that the specified local name and namespace URI matches that of the current element, then reads the current element and returns the contents as a String object.

ReadElementContentAsStringAsync()

Liest das aktuelle Element asynchron und gibt den Inhalt als String-Objekt zurück.Asynchronously reads the current element and returns the contents as a String object.

ReadElementString()

Liest ein Nur-Text-Element.Reads a text-only element. Sie sollten stattdessen allerdings die ReadElementContentAsString()-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bietet.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

ReadElementString(String)

Überprüft vor dem Lesen eines Nur-Text-Elements, ob die Name-Eigenschaft des gefundenen Elements mit der angegebenen Zeichenfolge übereinstimmt.Checks that the Name property of the element found matches the given string before reading a text-only element. Sie sollten stattdessen allerdings die ReadElementContentAsString()-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bietet.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

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.Checks that the LocalName and NamespaceURI properties of the element found matches the given strings before reading a text-only element. Sie sollten stattdessen allerdings die ReadElementContentAsString(String, String)-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bietet.However, we recommend that you use the ReadElementContentAsString(String, String) method instead, because it provides a more straightforward way to handle this operation.

ReadEndElement()

Überprüft, ob der aktuelle Inhaltsknoten ein Endtag ist, und verschiebt den Reader auf den nächsten Knoten.Checks that the current content node is an end tag and advances the reader to the next node.

ReadInnerXml()

Liest beim Überschreiben in einer abgeleiteten Klasse den gesamten Inhalt, einschließlich Markup, als Zeichenfolge.When overridden in a derived class, reads all the content, including markup, as a string.

ReadInnerXmlAsync()

Liest asynchron den gesamten Inhalt, einschließlich Markup als Zeichenfolge.Asynchronously reads all the content, including markup, as a string.

ReadOuterXml()

Ruft beim Überschreiben in einer abgeleiteten Klasse den Inhalt (einschließlich Markup) ab, der diesen Knoten und alle untergeordneten Elemente darstellt.When overridden in a derived class, reads the content, including markup, representing this node and all its children.

ReadOuterXmlAsync()

Liest den Inhalt, einschließlich Markup, das diesen Knoten und alle untergeordneten Elemente darstellt, asynchron.Asynchronously reads the content, including markup, representing this node and all its children.

ReadStartElement()

Überprüft, ob der aktuelle Knoten ein Element ist, und rückt den Reader zum nächsten Knoten vor.Checks that the current node is an element and advances the reader to the next node.

ReadStartElement(String)

Überprüft, ob der aktuelle Inhaltsknoten ein Element mit dem angegebenen Name ist, und verschiebt den Reader auf den nächsten Knoten.Checks that the current content node is an element with the given Name and advances the reader to the next node.

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.Checks that the current content node is an element with the given LocalName and NamespaceURI and advances the reader to the next node.

ReadString()

Liest beim Überschreiben in einer abgeleiteten Klasse den Inhalt eines Element- oder Textknotens als Zeichenfolge.When overridden in a derived class, reads the contents of an element or text node as a string. Sie sollten stattdessen allerdings die ReadElementContentAsString-Methode verwenden, da sie eine einfachere Möglichkeit zum Verarbeiten dieses Vorgangs bietet.However, we recommend that you use the ReadElementContentAsString method instead, because it provides a more straightforward way to handle this operation.

ReadSubtree()

Gibt eine neue XmlReader-Instanz zurück, die zum Lesen des aktuellen Knotens und aller Nachfolgerknoten verwendet werden kann.Returns a new XmlReader instance that can be used to read the current node, and all its descendants.

ReadToDescendant(String)

Verschiebt den XmlReader auf das nächste Nachfolgerelement mit dem angegebenen qualifizierten Namen.Advances the XmlReader to the next descendant element with the specified qualified name.

ReadToDescendant(String, String)

Verschiebt den XmlReader auf das nächste Nachfolgerelement mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI.Advances the XmlReader to the next descendant element with the specified local name and namespace URI.

ReadToFollowing(String)

Liest, bis ein Element mit dem angegebenen qualifizierten Namen gefunden wird.Reads until an element with the specified qualified name is found.

ReadToFollowing(String, String)

Liest, bis ein Element mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI gefunden wird.Reads until an element with the specified local name and namespace URI is found.

ReadToNextSibling(String)

Verschiebt den XmlReader auf das nächste nebengeordnete Element mit dem angegebenen qualifizierten Namen.Advances the XmlReader to the next sibling element with the specified qualified name.

ReadToNextSibling(String, String)

Verschiebt den XmlReader auf das nächste nebengeordnete Element mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI.Advances the XmlReader to the next sibling element with the specified local name and namespace URI.

ReadValueChunk(Char[], Int32, Int32)

Liest umfangreiche Streams von Text, der in ein XML-Dokument eingebettet ist.Reads large streams of text embedded in an XML document.

ReadValueChunkAsync(Char[], Int32, Int32)

Liest asynchron umfangreiche Streams von Text, der in ein XML-Dokument eingebettet ist.Asynchronously reads large streams of text embedded in an XML document.

ResolveEntity()

Löst beim Überschreiben in einer abgeleiteten Klasse den Entitätsverweis für EntityReference-Knoten auf.When overridden in a derived class, resolves the entity reference for EntityReference nodes.

Skip()

Überspringt die untergeordneten Elemente des aktuellen Knotens.Skips the children of the current node.

SkipAsync()

Überspringt die untergeordneten Elemente des aktuellen Knotens asynchron.Asynchronously skips the children of the current node.

ToString()

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

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

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

Gilt für:

Siehe auch