XmlReader Třída

Definice

Představuje čtecí modul, který poskytuje rychlý, mezipaměti a přístup pouze k datům XML.Represents a reader that provides fast, noncached, forward-only access to XML data.

public ref class XmlReader abstract : IDisposable
public ref class XmlReader abstract
public abstract class XmlReader : IDisposable
public abstract class XmlReader
type XmlReader = class
    interface IDisposable
type XmlReader = class
Public MustInherit Class XmlReader
Implements IDisposable
Public MustInherit Class XmlReader
Dědičnost
XmlReader
Odvozené
Implementuje

Příklady

Následující příklad kódu ukazuje, jak použít asynchronní rozhraní API k analýze XML.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

Poznámky

XmlReader poskytuje přístup jen pro čtení k datům XML v dokumentu nebo v datovém proudu.XmlReader provides forward-only, read-only access to XML data in a document or stream. Tato třída odpovídá standardu W3C jazyk XML (Extensible Markup Language) (XML) 1,0 (čtvrté vydání) a obory názvů v doporučeních XML 1,0 (třetí edice) .This class conforms to the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and the Namespaces in XML 1.0 (third edition) recommendations.

XmlReader metody umožňují přesouvat data XML a číst obsah uzlu.XmlReader methods let you move through XML data and read the contents of a node. Vlastnosti třídy odpovídají hodnotě aktuálního uzlu, ve kterém je umístěno čtecí zařízení.The properties of the class reflect the value of the current node, which is where the reader is positioned. ReadStateHodnota vlastnosti označuje aktuální stav čtecího modulu XML.The ReadState property value indicates the current state of the XML reader. Například vlastnost je nastavena na hodnotu ReadState.Initial XmlReader.Read metodou a ReadState.Closed XmlReader.Close metodou.For example, the property is set to ReadState.Initial by the XmlReader.Read method and ReadState.Closed by the XmlReader.Close method. XmlReader také poskytuje kontroly shody dat a ověřování na základě DTD nebo schématu.XmlReader also provides data conformance checks and validation against a DTD or schema.

XmlReader k načtení dat používá model Pull.XmlReader uses a pull model to retrieve data. Tento model:This model:

  • Zjednodušuje správu stavu v rámci přirozeného a horního procedurálního vylepšení.Simplifies state management by a natural, top-down procedural refinement.

  • Podporuje více vstupních streamů a vrstvení.Supports multiple input streams and layering.

  • Umožňuje klientovi poskytnout analyzátoru vyrovnávací paměť, do které se řetězec napíše přímo, a proto zabrání nutnosti nadbytečné kopie řetězce.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.

  • Podporuje selektivní zpracování.Supports selective processing. Klient může přeskočit položky a zpracovat ty, které mají zájem o aplikaci.The client can skip items and process those that are of interest to the application. Můžete také nastavit vlastnosti předem a spravovat způsob zpracování datového proudu XML (například normalizace).You can also set properties in advance to manage how the XML stream is processed (for example, normalization).

V této části:In this section:

Vytvoření čtecího modulu XML Creating an XML reader
Ověřování dat XML Validating XML data
Shoda dat Data conformance
Navigace v uzlech Navigating through nodes
Čtení elementů XML Reading XML elements
Čtení atributů XML Reading XML attributes
Čtení obsahu XML Reading XML content
Převod na typy CLR Converting to CLR types
Asynchronní programování Asynchronous programming
Důležité informace o zabezpečeníSecurity considerations

Vytvoření čtecího modulu XMLCreating an XML reader

CreateK vytvoření instance použijte metodu XmlReader .Use the Create method to create an XmlReader instance.

I když .NET Framework poskytuje konkrétní implementace XmlReader třídy, jako je XmlTextReader , XmlNodeReader , a XmlValidatingReader třídy, doporučujeme používat specializované třídy pouze v těchto scénářích: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:

  • Pokud chcete načíst podstrom XML modelu XML z XmlNode objektu, použijte XmlNodeReader třídu.When you want to read an XML DOM subtree from an XmlNode object, use the XmlNodeReader class. (Tato třída však nepodporuje ověřování DTD ani schématu.)(However, this class doesn't support DTD or schema validation.)

  • Pokud musíte rozbalit entity na vyžádání, nechcete, aby byl váš textový obsah normalizován, nebo nechcete vracet výchozí atributy, použijte XmlTextReader třídu.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.

Chcete-li určit sadu funkcí, které chcete povolit pro čtecí modul XML, předejte System.Xml.XmlReaderSettings objekt Create metodě.To specify the set of features you want to enable on the XML reader, pass an System.Xml.XmlReaderSettings object to the Create method. Jeden objekt můžete použít System.Xml.XmlReaderSettings k vytvoření více čtenářů se stejnou funkcí nebo System.Xml.XmlReaderSettings k úpravě objektu pro vytvoření nového čtecího zařízení s jinou sadou funkcí.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. Do existujícího čtecího zařízení můžete také snadno přidat funkce.You can also easily add features to an existing reader.

Pokud objekt nepoužíváte System.Xml.XmlReaderSettings , použijí se výchozí nastavení.If you don't use a System.Xml.XmlReaderSettings object, default settings are used. Podrobnosti najdete na Create referenční stránce.See the Create reference page for details.

XmlReader vyvolá chybu XmlException analýzy XML.XmlReader throws an XmlException on XML parse errors. Po vyvolání výjimky se stav čtecího zařízení nepředvídatelné.After an exception is thrown, the state of the reader is not predictable. Například typ hlášeného uzlu může být jiný než skutečný typ uzlu aktuálního uzlu.For example, the reported node type may be different from the actual node type of the current node. Pomocí ReadState Vlastnosti ověřte, zda je čtecí modul v chybovém stavu.Use the ReadState property to check whether the reader is in error state.

Ověřování dat XMLValidating XML data

Chcete-li definovat strukturu dokumentu XML a jeho vztahů elementů, datových typů a omezení obsahu, použijte definici typu dokumentu (DTD) nebo schéma schématu definice jazyka XML (XSD).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. Dokument XML je považován za správný formát, pokud splňuje všechny syntaktické požadavky definované doporučením W3C XML 1,0.An XML document is considered to be well formed if it meets all the syntactical requirements defined by the W3C XML 1.0 Recommendation. Je považována za platný, pokud je ve správném formátu, a také vyhovuje omezením definovaným pomocí DTD nebo schématu.It's considered valid if it's well formed and also conforms to the constraints defined by its DTD or schema. (Viz část 1 W3C XML schématu: struktury a část 2 W3C XML schématu: typy dat doporučení.) Proto i když jsou všechny platné dokumenty XML ve správném formátu, nejsou všechny správně formátované dokumenty XML platné.(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.

Můžete ověřit data proti DTD, vloženému schématu XSD nebo schématu XSD uloženému v XmlSchemaSet objektu (mezipaměť); tyto scénáře jsou popsány na Create referenční stránce.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 nepodporuje ověřování schématu XML-Data Redukovan (XDR).XmlReader doesn't support XML-Data Reduced (XDR) schema validation.

Pomocí následujících nastavení XmlReaderSettings třídy můžete určit, jaký typ ověřování má XmlReader instance podporovat.You use the following settings on the XmlReaderSettings class to specify what type of validation, if any, the XmlReader instance supports.

Použít tohoto XmlReaderSettings členaUse this XmlReaderSettings member ZadáníTo specify
DtdProcessing majetekDtdProcessing property Určuje, zda má být povoleno zpracování DTD.Whether to allow DTD processing. Výchozím nastavením je zakázat zpracování DTD.The default is to disallow DTD processing.
ValidationType majetekValidationType property Zda má čtecí modul ověřovat data a jaký typ ověřování má být proveden (DTD nebo schéma).Whether the reader should validate data, and what type of validation to perform (DTD or schema). Výchozí hodnota není ověření dat.The default is no data validation.
ValidationEventHandler událostíValidationEventHandler event Obslužná rutina události pro příjem informací o událostech ověření.An event handler for receiving information about validation events. Pokud není k dispozici obslužná rutina události, XmlException je vyvolána při první chybě ověření.If an event handler is not provided, an XmlException is thrown on the first validation error.
ValidationFlags majetekValidationFlags property Další možnosti ověřování prostřednictvím XmlSchemaValidationFlags členů výčtu:Additional validation options through the XmlSchemaValidationFlags enumeration members:

- AllowXmlAttributes--Povolí atributy XML ( xml:* ) v dokumentech instancí i v případě, že nejsou definované ve schématu.- AllowXmlAttributes-- Allow XML attributes (xml:*) in instance documents even when they're not defined in the schema. Atributy jsou ověřeny na základě jejich datového typu.The attributes are validated based on their data type. Informace o XmlSchemaValidationFlags nastavení, které se má použít v konkrétních scénářích, najdete na referenční stránce.See the XmlSchemaValidationFlags reference page for the setting to use in specific scenarios. (Zakázané ve výchozím nastavení.)(Disabled by default.)
- ProcessIdentityConstraints --Při ověřování se zjistila omezení identity procesu ( xs:ID , xs:IDREF ,, xs:key xs:keyref , xs:unique ).- ProcessIdentityConstraints --Process identity constraints (xs:ID, xs:IDREF, xs:key, xs:keyref, xs:unique) encountered during validation. (Povoleno ve výchozím nastavení.)(Enabled by default.)
- ProcessSchemaLocation --Schémata procesů určené xsi:schemaLocation xsi:noNamespaceSchemaLocation atributem nebo.- ProcessSchemaLocation --Process schemas specified by the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attribute. (Povoleno ve výchozím nastavení.)(Enabled by default.)
- ProcessInlineSchema--Zpracovat vložená schémata XML během ověřování.- ProcessInlineSchema-- Process inline XML Schemas during validation. (Zakázané ve výchozím nastavení.)(Disabled by default.)
- ReportValidationWarnings--Ohlásí události, pokud dojde k upozornění ověření.- ReportValidationWarnings--Report events if a validation warning occurs. Upozornění je obvykle vystaveno, pokud neexistuje žádné schéma DTD nebo XML pro ověření konkrétního prvku nebo atributu proti.A warning is typically issued when there is no DTD or XML Schema to validate a particular element or attribute against. ValidationEventHandlerSlouží k oznámení.The ValidationEventHandler is used for notification. (Zakázané ve výchozím nastavení.)(Disabled by default.)
Schemas , XmlSchemaSet Který se má použít k ověření.The XmlSchemaSet to use for validation.
XmlResolver majetekXmlResolver property XmlResolverPro řešení a přístup k externím prostředkům.The XmlResolver for resolving and accessing external resources. To může zahrnovat externí entity, jako je například DTD a schémata, a všechny xs:include xs:import prvky, které jsou obsaženy ve schématu XML.This can include external entities such as DTD and schemas, and any xs:include or xs:import elements contained in the XML Schema. Pokud nezadáte XmlResolver , XmlReader použije se výchozí nastavení XmlUrlResolver bez přihlašovacích údajů uživatele.If you don't specify an XmlResolver, the XmlReader uses a default XmlUrlResolver with no user credentials.

Shoda datData conformance

Čtečky XML, které jsou vytvořeny Create metodou, splňují ve výchozím nastavení následující požadavky na dodržování předpisů:XML readers that are created by the Create method meet the following compliance requirements by default:

  • Nové řádky a hodnoty atributů jsou normalizovány podle doporučení W3C XML 1,0.New lines and attribute value are normalized according to the W3C XML 1.0 Recommendation.

  • Všechny entity jsou automaticky rozbaleny.All entities are automatically expanded.

  • Výchozí atributy deklarované v definici typu dokumentu jsou vždy přidány i v případě, že se čtecí zařízení neověřuje.Default attributes declared in the document type definition are always added even when the reader doesn't validate.

  • Deklarace předpony XML mapované na správný identifikátor URI oboru názvů XML je povolena.Declaration of XML prefix mapped to the correct XML namespace URI is allowed.

  • Názvy zápisů v NotationType deklaraci jediného atributu a NmTokens v Enumeration deklaraci jediného atributu jsou odlišné.The notation names in a single NotationType attribute declaration and NmTokens in a single Enumeration attribute declaration are distinct.

Pomocí těchto XmlReaderSettings vlastností můžete určit typ kontrol shody, které chcete povolit:Use these XmlReaderSettings properties to specify the type of conformance checks you want to enable:

Tato vlastnost se používá XmlReaderSettingsUse this XmlReaderSettings property ZáměrTo VýchozíDefault
CheckCharacters majetekCheckCharacters property Povolit nebo zakázat kontroly pro následující:Enable or disable checks for the following:

-Znaky jsou v rozsahu přípustných znaků XML, jak jsou definovány částí 2,2 znaků v tématu doporučení W3C XML 1,0.- Characters are within the range of legal XML characters, as defined by the 2.2 Characters section of the W3C XML 1.0 Recommendation.
-Všechny názvy XML jsou platné, jak jsou definovány v oddílu 2,3 Common syntaktických konstrukcí v doporučení W3C XML 1,0.- All XML names are valid, as defined by the 2.3 Common Syntactic Constructs section of the W3C XML 1.0 Recommendation.

Je-li tato vlastnost nastavena na hodnotu true (výchozí), XmlException je vyvolána výjimka, pokud soubor XML obsahuje neplatné znaky nebo neplatné názvy XML (například název elementu začíná číslem).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).
Kontrola znaků a názvů je povolena.Character and name checking is enabled.

Nastavení CheckCharacters pro false vypnutí kontroly znaku pro odkazy na znakové entity.Setting CheckCharacters to false turns off character checking for character entity references. Pokud čtenář zpracovává textová data, vždy kontroluje platnost názvů XML bez ohledu na toto nastavení.If the reader is processing text data, it always checks that XML names are valid, regardless of this setting. Poznámka: Pokud je k dispozici deklarace DTD, doporučení XML 1,0 vyžaduje shodu na úrovni dokumentu.Note: The XML 1.0 recommendation requires document-level conformance when a DTD is present. Proto pokud je čtecí modul nakonfigurován pro podporu ConformanceLevel.Fragment , ale data XML obsahují definici typu dokumentu (DTD), XmlException je vyvolána.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 majetekConformanceLevel property Vyberte úroveň dodržování shody:Choose the level of conformance to enforce:

- Document.- Document. Odpovídá pravidlům pro dokument XML 1,0 ve správnémformátu.Conforms to the rules for a well-formed XML 1.0 document.
- Fragment.- Fragment. Odpovídá pravidlům pro fragment dokumentu ve správném formátu, který lze spotřebovat jako externí analyzovanou entitu.Conforms to the rules for a well-formed document fragment that can be consumed as an external parsed entity.
- Auto.- Auto. Odpovídá úrovni, kterou Čtenář vyrozhodl.Conforms to the level decided by the reader.

Pokud data nejsou v souladu, XmlException je vyvolána výjimka.If the data isn't in conformance, an XmlException exception is thrown.
Document

Aktuální uzel je uzel XML, na kterém je aktuálně umístěno čtecí modul XML.The current node is the XML node on which the XML reader is currently positioned. Všechny XmlReader metody provádějí operace ve vztahu k tomuto uzlu a všechny XmlReader vlastnosti odpovídají hodnotě aktuálního uzlu.All XmlReader methods perform operations in relation to this node, and all XmlReader properties reflect the value of the current node.

Následující metody usnadňují procházení uzlů a analýzu dat.The following methods make it easy to navigate through nodes and parse data.

Použít tuto XmlReaderSettings metoduUse this XmlReaderSettings method ZáměrTo
Read Přečtěte si první uzel a pokračujte v jednom uzlu v jednom okamžiku.Read the first node, and advance through the stream one node at a time. Taková volání se obvykle provádějí uvnitř while smyčky.Such calls are typically performed inside a while loop.

Vlastnost použijte NodeType k získání typu (například atribut, komentář, prvek a tak dále) aktuálního uzlu.Use the NodeType property to get the type (for example, attribute, comment, element, and so on) of the current node.
Skip Přeskočit podřízené položky aktuálního uzlu a přesunout se na další uzel.Skip the children of the current node and move to the next node.
MoveToContent a MoveToContentAsyncMoveToContent and MoveToContentAsync Přeskočí uzly bez obsahu a přesun na další uzel obsahu nebo na konec souboru.Skip non-content nodes and move to the next content node or to the end of the file.

Uzly bez obsahu zahrnují ProcessingInstruction ,,, a DocumentType Comment Whitespace SignificantWhitespace .Non-content nodes include ProcessingInstruction, DocumentType, Comment, Whitespace, and SignificantWhitespace.

Uzly obsahu obsahují text, který není prázdný, CDATA EntityReference a EndEntity .Content nodes include non-white space text, CDATA, EntityReference , and EndEntity.
ReadSubtree Přečtěte si element a všechny jeho podřízené objekty a vraťte novou XmlReader instanci nastavenou na ReadState.Initial .Read an element and all its children, and return a new XmlReader instance set to ReadState.Initial.

Tato metoda je užitečná pro vytváření hranic kolem XML elementů; Například pokud chcete předat data do jiné součásti pro zpracování a chcete omezit, kolik dat může komponenta přistupovat.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.

Podívejte se na XmlReader.Read referenční stránku, kde najdete příklad navigace přes textový Stream v jednom uzlu v čase a zobrazení typu každého uzlu.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.

Následující části popisují, jak můžete číst konkrétní typy dat, jako jsou například prvky, atributy a typová data.The following sections describe how you can read specific types of data, such as elements, attributes, and typed data.

Čtení elementů XMLReading XML elements

V následující tabulce jsou uvedeny metody a vlastnosti, které XmlReader Třída poskytuje pro zpracování elementů.The following table lists the methods and properties that the XmlReader class provides for processing elements. Po XmlReader umístění v prvku, vlastnosti uzlu, například Name , odrážejí hodnoty elementu.After the XmlReader is positioned on an element, the node properties, such as Name, reflect the element values. Kromě členů popsaných níže XmlReader lze ke zpracování prvků použít také kteroukoli z obecných metod a vlastností třídy.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. Například můžete použít ReadInnerXml metodu pro čtení obsahu elementu.For example, you can use the ReadInnerXml method to read the contents of an element.

Poznámka

V části 3,1 doporučení W3C XML 1,0 najdete definice počátečních značek, koncových značek a prázdných značek elementu.See section 3.1 of the W3C XML 1.0 Recommendation for definitions of start tags, end tags, and empty element tags.

Použít tohoto XmlReader členaUse this XmlReader member ZáměrTo
Metoda IsStartElementIsStartElement method Zkontroluje, zda je aktuální uzel počáteční nebo prázdná značka elementu.Check if the current node is a start tag or an empty element tag.
Metoda ReadStartElementReadStartElement method Ověřte, zda je aktuální uzel prvkem a zda je čtenář posunut na další uzel (volání IsStartElement následované Read ).Check that the current node is an element and advance the reader to the next node (calls IsStartElement followed by Read).
Metoda ReadEndElementReadEndElement method Ověřte, zda je aktuální uzel koncovou značkou a přečtěte si čtecí modul na další uzel.Check that the current node is an end tag and advance the reader to the next node.
Metoda ReadElementStringReadElementString method Čtení elementu pouze pro text.Read a text-only element.
Metoda ReadToDescendantReadToDescendant method Přejděte do čtecího modulu XML k dalšímu objektu následníka (podřízeného), který má zadaný název.Advance the XML reader to the next descendant (child) element that has the specified name.
Metoda ReadToNextSiblingReadToNextSibling method Přejděte do čtecího modulu XML k dalšímu elementu na stejné úrovni, který má zadaný název.Advance the XML reader to the next sibling element that has the specified name.
IsEmptyElement majetekIsEmptyElement property Zkontroluje, zda aktuální prvek obsahuje značku koncového elementu.Check if the current element has an end element tag. Například:For example:

- <item num="123"/> ( IsEmptyElement je true .)- <item num="123"/> (IsEmptyElement is true.)
- <item num="123"> </item> ( IsEmptyElement je false , i když je obsah elementu prázdný.)- <item num="123"> </item> (IsEmptyElement is false, although the element's content is empty.)

Příklad čtení textového obsahu prvků naleznete v ReadString metodě.For an example of reading the text content of elements, see the ReadString method. Následující příklad zpracovává prvky pomocí while smyčky.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

Čtení atributů XMLReading XML attributes

Atributy XML jsou nejčastěji nalezeny u elementů, ale jsou povoleny také v deklaraci XML a v uzlech typu dokumentu.XML attributes are most commonly found on elements, but they're also allowed on XML declaration and document type nodes.

Při umístění na uzel elementu MoveToAttribute vám Metoda umožní projít seznam atributů elementu.When positioned on an element node, the MoveToAttribute method lets you go through the attribute list of the element. Všimněte si, že po MoveToAttribute volání, vlastnosti uzlu, například Name , NamespaceURI , a Prefix odráží vlastnosti daného atributu, nikoli vlastnosti prvku, ke kterému patří atribut.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.

XmlReaderTřída poskytuje tyto metody a vlastnosti pro čtení a zpracování atributů u elementů.The XmlReader class provides these methods and properties to read and process attributes on elements.

Použít tohoto XmlReader členaUse this XmlReader member ZáměrTo
HasAttributes majetekHasAttributes property Ověřte, zda má aktuální uzel žádné atributy.Check whether the current node has any attributes.
AttributeCount majetekAttributeCount property Získá počet atributů u aktuálního prvku.Get the number of attributes on the current element.
Metoda MoveToFirstAttributeMoveToFirstAttribute method Přesune se na první atribut v elementu.Move to the first attribute in an element.
Metoda MoveToNextAttributeMoveToNextAttribute method Přesune se k dalšímu atributu v elementu.Move to the next attribute in an element.
Metoda MoveToAttributeMoveToAttribute method Přesunout na zadaný atribut.Move to a specified attribute.
GetAttribute Metoda nebo Item[] vlastnostGetAttribute method or Item[] property Získá hodnotu zadaného atributu.Get the value of a specified attribute.
IsDefault majetekIsDefault property Ověřte, zda je aktuální uzel atributem, který byl vygenerován z výchozí hodnoty definované v souboru DTD nebo schématu.Check whether the current node is an attribute that was generated from the default value defined in the DTD or schema.
Metoda MoveToElementMoveToElement method Přejděte k prvku, který vlastní aktuální atribut.Move to the element that owns the current attribute. Tuto metodu použijte, chcete-li se vrátit na prvek po přechodu skrze jeho atributy.Use this method to return to an element after navigating through its attributes.
Metoda ReadAttributeValueReadAttributeValue method Analyzujte hodnotu atributu na jeden nebo více Text EntityReference uzlů, nebo EndEntity .Parse the attribute value into one or more Text, EntityReference, or EndEntity nodes.

XmlReaderK zpracování atributů lze použít také kteroukoli z obecných metod a vlastností.Any of the general XmlReader methods and properties can also be used to process attributes. Například po XmlReader umístění v atributu atribut Name a Value vlastnosti odráží hodnoty atributu.For example, after the XmlReader is positioned on an attribute, the Name and Value properties reflect the values of the attribute. Můžete také použít kteroukoli z Read metod obsahu k získání hodnoty atributu.You can also use any of the content Read methods to get the value of the attribute.

V tomto příkladu se používá AttributeCount vlastnost k procházení všech atributů elementu.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

V tomto příkladu se MoveToNextAttribute while k procházení atributů používá metoda ve smyčce.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

Čtení atributů v uzlech deklarace XMLReading attributes on XML declaration nodes

Pokud je čtecí modul XML umístěn v uzlu deklarace XML, Value vrátí vlastnost informace o verzi, samostatném a kódování jako jeden řetězec.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 objekty vytvořené Create metodou, XmlTextReader třídou a XmlValidatingReader třídou zveřejňují položky verze, samostatné a kódování jako atributy.XmlReader objects created by the Create method, the XmlTextReader class, and the XmlValidatingReader class expose the version, standalone, and encoding items as attributes.

Čtení atributů v uzlech typu dokumentuReading attributes on document type nodes

Když je čtecí modul XML umístěn v uzlu typu dokumentu, GetAttribute Metoda a Item[] vlastnost lze použít k vrácení hodnot pro systém a veřejné literály.When the XML reader is positioned on a document type node, the GetAttribute method and Item[] property can be used to return the values for the SYSTEM and PUBLIC literals. Například volání reader.GetAttribute("PUBLIC") vrátí veřejnou hodnotu.For example, calling reader.GetAttribute("PUBLIC") returns the PUBLIC value.

Čtení atributů v uzlech instrukcí pro zpracováníReading attributes on processing instruction nodes

Když XmlReader je umístěn v uzlu instrukce pro zpracování, Value vrátí vlastnost celý textový obsah.When the XmlReader is positioned on a processing instruction node, the Value property returns the entire text content. Položky v uzlu instrukce pro zpracování nejsou považovány za atributy.Items in the processing instruction node aren't treated as attributes. Nelze je číst pomocí GetAttribute MoveToAttribute metody nebo.They can't be read with the GetAttribute or MoveToAttribute method.

Čtení obsahu XMLReading XML content

Třída XMLReader obsahuje následující členy, které čtou obsah ze souboru XML a vracejí obsah jako řetězcové hodnoty.The XMLReader class includes the following members that read content from an XML file and return the content as string values. (Chcete-li vrátit typy CLR, přečtěte si Další část.)(To return CLR types, see the next section.)

Použít tohoto XmlReader členaUse this XmlReader member ZáměrTo
Value majetekValue property Získá textový obsah aktuálního uzlu.Get the text content of the current node. Vrácená hodnota závisí na typu uzlu; Podrobnosti najdete na Value referenční stránce.The value returned depends on the node type; see the Value reference page for details.
Metoda ReadStringReadString method Získání obsahu elementu nebo textového uzlu jako řetězce.Get the content of an element or text node as a string. Tato metoda zastaví zpracování instrukcí a komentářů.This method stops on processing instructions and comments.

Podrobnosti o tom, jak tato metoda zpracovává konkrétní typy uzlů, naleznete na ReadString referenční stránce.For details on how this method handles specific node types, see the ReadString reference page.
ReadInnerXml a ReadInnerXmlAsync metodyReadInnerXml and ReadInnerXmlAsync methods Získá veškerý obsah aktuálního uzlu, včetně značky, ale s výjimkou počátečních a koncových značek.Get all the content of the current node, including the markup, but excluding start and end tags. Například pro:For example, for:

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

ReadInnerXml VrátíReadInnerXml returns:

this<child id="123"/>
ReadOuterXml a ReadOuterXmlAsync metodyReadOuterXml and ReadOuterXmlAsync methods Získá veškerý obsah aktuálního uzlu a jeho podřízených prvků, včetně značek a počátečních a koncových značek.Get all the content of the current node and its children, including markup and start/end tags. Například pro:For example, for:

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

ReadOuterXml VrátíReadOuterXml returns:

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

Převod na typy CLRConverting to CLR types

Můžete použít členy XmlReader třídy (uvedené v následující tabulce) pro čtení dat XML a návratové hodnoty jako typy modulu CLR (Common Language Runtime) namísto řetězců.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. Tito členové vám umožňují získat hodnoty v reprezentaci, která je nejvhodnější pro vaši úlohu kódování, aniž by bylo nutné ručně analyzovat nebo převádět řetězcové hodnoty.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.

  • Metody metody ReadElementContentAs lze volat pouze u typů uzlů elementu.The ReadElementContentAs methods can only be called on element node types. Tyto metody nelze použít u elementů, které obsahují podřízené prvky nebo smíšený obsah.These methods cannot be used on elements that contain child elements or mixed content. Při volání XmlReader objekt přečte počáteční značku, přečte obsah elementu a potom přesune za značku koncového prvku.When called, the XmlReader object reads the start tag, reads the element content, and then moves past the end element tag. Pokyny a komentáře ke zpracování se ignorují a rozbalí se entity.Processing instructions and comments are ignored and entities are expanded.

  • Metody ReadContentAs přečtou textový obsah na aktuální pozici čtečky a pokud data XML nemají k sobě přidružené žádné informace schématu nebo datového typu, převeďte textový obsah na požadovaný návratový typ.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, prázdné znaky, významné prázdné znaky a CDATA oddíly jsou zřetězeny.Text, white space, significant white space and CDATA sections are concatenated. Komentáře a pokyny pro zpracování jsou přeskočeny a odkazy na entity jsou automaticky vyřešeny.Comments and processing instructions are skipped, and entity references are automatically resolved.

XmlReaderTřída používá pravidla definovaná v části 2 W3C XML schématu: typy dat doporučení.The XmlReader class uses the rules defined by the W3C XML Schema Part 2: Datatypes recommendation.

Použít tuto XmlReader metoduUse this XmlReader method Chcete-li vrátit tento typ CLRTo return this CLR type
ReadContentAsBoolean a ReadElementContentAsBooleanReadContentAsBoolean and ReadElementContentAsBoolean Boolean
ReadContentAsDateTime a ReadElementContentAsDateTimeReadContentAsDateTime and ReadElementContentAsDateTime DateTime
ReadContentAsDouble a ReadElementContentAsDoubleReadContentAsDouble and ReadElementContentAsDouble Double
ReadContentAsLong a ReadElementContentAsLongReadContentAsLong and ReadElementContentAsLong Int64
ReadContentAsInt a ReadElementContentAsIntReadContentAsInt and ReadElementContentAsInt Int32
ReadContentAsString a ReadElementContentAsStringReadContentAsString and ReadElementContentAsString String
ReadContentAs a ReadElementContentAsReadContentAs and ReadElementContentAs Typ, který zadáte s returnType parametremThe type you specify with the returnType parameter
ReadContentAsObject a ReadElementContentAsObjectReadContentAsObject and ReadElementContentAsObject Nejvhodnější typ, jak je určen XmlReader.ValueType vlastností.The most appropriate type, as specified by the XmlReader.ValueType property. Informace o mapování najdete v tématu Podpora typů v třídách System.Xml .See Type Support in the System.Xml Classes for mapping information.

Pokud element nelze snadno převést na typ CLR z důvodu jeho formátu, můžete použít mapování schématu pro zajištění úspěšného převodu.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. Následující příklad používá soubor. xsd k převedení hire-date elementu na xs:date typ a poté používá ReadElementContentAsDateTime metodu pro vrácení prvku jako DateTime objektu.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.

Vstup (hireDate.xml):Input (hireDate.xml):

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

Schéma (ZaměstnánOd. 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>

ZnakovouCode:

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

VýkonemOutput:

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

Asynchronní programováníAsynchronous programming

Většina XmlReader metod má asynchronní protějšky, které mají "Async" na konci jejich názvů metod.Most of the XmlReader methods have asynchronous counterparts that have "Async" at the end of their method names. Například asynchronní ekvivalent ReadContentAsObject je ReadContentAsObjectAsync .For example, the asynchronous equivalent of ReadContentAsObject is ReadContentAsObjectAsync.

Pomocí asynchronních volání metod lze použít následující metody:The following methods can be used with asynchronous method calls:

Následující části popisují asynchronní použití pro metody, které nemají asynchronní protějšky.The following sections describe asynchronous usage for methods that don't have asynchronous counterparts.

Metoda ReadStartElementReadStartElement 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

Metoda ReadEndElementReadEndElement 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

Metoda ReadToNextSiblingReadToNextSibling 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

Metoda ReadToFollowingReadToFollowing 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

Metoda ReadToDescendantReadToDescendant 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

Důležité informace o zabezpečeníSecurity considerations

Při práci s třídou Vezměte v úvahu následující XmlReader :Consider the following when working with the XmlReader class:

  • Výjimky vyvolané z jsou XmlReader schopné zveřejňovat informace o cestě, které nebudete chtít poznamenat do aplikace.Exceptions thrown from the XmlReader can disclose path information that you might not want bubbled up to your app. Vaše aplikace musí zachytit výjimky a vhodně je zpracovat.Your app must catch exceptions and process them appropriately.

  • Nepovolujte zpracování DTD, pokud se zajímáte o problémech s odepřením služeb nebo pokud pracujete s nedůvěryhodnými zdroji.Do not enable DTD processing if you're concerned about denial of service issues or if you're dealing with untrusted sources. Zpracování DTD je ve výchozím nastavení zakázáno pro XmlReader objekty vytvořené Create metodou.DTD processing is disabled by default for XmlReader objects created by the Create method.

    Pokud máte povolené zpracování DTD, můžete použít XmlSecureResolver k omezení prostředků, ke kterým má XmlReader přístup přístup.If you have DTD processing enabled, you can use the XmlSecureResolver to restrict the resources that the XmlReader can access. Můžete také navrhnout aplikaci tak, aby zpracování XML bylo omezené na paměť a čas.You can also design your app so that the XML processing is memory and time constrained. V aplikaci ASP.NET můžete například nakonfigurovat limity časového limitu.For example, you can configure time-out limits in your ASP.NET app.

  • Data XML mohou zahrnovat odkazy na externí prostředky, jako je například soubor schématu.XML data can include references to external resources such as a schema file. Ve výchozím nastavení se externí prostředky řeší pomocí XmlUrlResolver objektu bez přihlašovacích údajů uživatele.By default, external resources are resolved by using an XmlUrlResolver object with no user credentials. Tento postup lze zabezpečit pomocí jedné z následujících akcí:You can secure this further by doing one of the following:

  • ProcessInlineSchema ProcessSchemaLocation Příznaky ověřování a XmlReaderSettings objektu nejsou ve výchozím nastavení nastaveny.The ProcessInlineSchema and ProcessSchemaLocation validation flags of an XmlReaderSettings object aren't set by default. To pomáhá chránit XmlReader před útoky založenými na schématu při zpracování dat XML z nedůvěryhodného zdroje.This helps to protect the XmlReader against schema-based attacks when it is processing XML data from an untrusted source. Při nastavení těchto příznaků je XmlResolver XmlReaderSettings objekt použit k překladu umístění schématu zjištěného v dokumentu instance v XmlReader .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. Pokud XmlResolver je vlastnost nastavena na null , umístění schématu nebudou přeložena ani v případě, že ProcessInlineSchema ProcessSchemaLocation jsou nastaveny příznaky ověřování a.If the XmlResolver property is set to null, schema locations aren't resolved even if the ProcessInlineSchema and ProcessSchemaLocation validation flags are set.

    Schémata přidaná během ověřování přidávají nové typy a můžou měnit výsledky ověřování u ověřovaného dokumentu.Schemas added during validation add new types and can change the validation outcome of the document being validated. Výsledkem je, že externí schémata by se měla vyřešit jenom z důvěryhodných zdrojů.As a result, external schemas should only be resolved from trusted sources.

    Doporučujeme zakázat ProcessIdentityConstraints příznak při ověřování nedůvěryhodných a velkých dokumentů XML ve scénářích s vysokou dostupností na základě schématu, které má omezení identity v rozsáhlých součástech dokumentu.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. Tento příznak je ve výchozím nastavení povolen.This flag is enabled by default.

  • Data XML mohou obsahovat velký počet atributů, deklarace oboru názvů, vnořené prvky a tak dále, které vyžadují značné množství času ke zpracování.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. Chcete-li omezit velikost vstupu, který je odeslán do XmlReader , můžete:To limit the size of the input that is sent to the XmlReader, you can:

  • ReadValueChunkMetodu lze použít pro zpracování velkých proudů dat.The ReadValueChunk method can be used to handle large streams of data. Tato metoda čte malý počet znaků v čase namísto přidělení jediného řetězce pro celou hodnotu.This method reads a small number of characters at a time instead of allocating a single string for the whole value.

  • Při čtení dokumentu XML, který má velký počet jedinečných místních názvů, oborů názvů nebo předpon, může dojít k problému.When reading an XML document with a large number of unique local names, namespaces, or prefixes, a problem can occur. Pokud používáte třídu, která je odvozena z XmlReader a zavoláte LocalName Prefix vlastnost, nebo NamespaceURI pro každou položku, vrácený řetězec je přidán do NameTable .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. Kolekce držená NameTable nikdy nesnižuje velikost, což vytváří nevrácenou virtuální paměť obslužných rutin řetězce.The collection held by the NameTable never decreases in size, creating a virtual memory leak of the string handles. Jedno zmírnění pro tuto skutečnost je odvozeno od NameTable třídy a vynutilo maximální velikost kvóty.One mitigation for this is to derive from the NameTable class and enforce a maximum size quota. (Neexistuje žádný způsob, jak zabránit použití NameTable , nebo pro přepnutí, NameTable když je plný).(There is no way to prevent the use of a NameTable, or to switch the NameTable when it is full). Další zmírnění je zabránit používání zmíněných vlastností a místo toho použít MoveToAttribute metodu s IsStartElement metodou, pokud je to možné; tyto metody nevrací řetězce a zabraňují tak problému přeplňování NameTable kolekce.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 objekty můžou obsahovat citlivé informace, například přihlašovací údaje uživatele.XmlReaderSettings objects can contain sensitive information such as user credentials. Nedůvěryhodná komponenta by mohla použít XmlReaderSettings objekt a jeho přihlašovací údaje uživatele k vytvoření XmlReader objektů pro čtení dat.An untrusted component could use the XmlReaderSettings object and its user credentials to create XmlReader objects to read data. Buďte opatrní při ukládání XmlReaderSettings objektů do mezipaměti nebo při předávání XmlReaderSettings objektu z jedné součásti do jiné.Be careful when caching XmlReaderSettings objects, or when passing the XmlReaderSettings object from one component to another.

  • Nepřijímejte podpůrné komponenty, jako jsou NameTable , XmlNamespaceManager a XmlResolver objekty, z nedůvěryhodného zdroje.Do not accept supporting components, such as NameTable, XmlNamespaceManager, and XmlResolver objects, from an untrusted source.

Konstruktory

XmlReader()

Inicializuje novou instanci XmlReader třídy.Initializes a new instance of the XmlReader class.

Vlastnosti

AttributeCount

Při přepsání v odvozené třídě získá počet atributů v aktuálním uzlu.When overridden in a derived class, gets the number of attributes on the current node.

BaseURI

Při přepsání v odvozené třídě získá základní identifikátor URI aktuálního uzlu.When overridden in a derived class, gets the base URI of the current node.

CanReadBinaryContent

Získá hodnotu, která označuje, zda XmlReader implementuje metody čtení binárního obsahu.Gets a value indicating whether the XmlReader implements the binary content read methods.

CanReadValueChunk

Získá hodnotu, která označuje, zda XmlReader implementuje ReadValueChunk(Char[], Int32, Int32) metodu.Gets a value indicating whether the XmlReader implements the ReadValueChunk(Char[], Int32, Int32) method.

CanResolveEntity

Načte hodnotu, která označuje, jestli může tento čtenář analyzovat a vyřešit entity.Gets a value indicating whether this reader can parse and resolve entities.

Depth

Při přepsání v odvozené třídě získá hloubku aktuálního uzlu v dokumentu XML.When overridden in a derived class, gets the depth of the current node in the XML document.

EOF

Při přepsání v odvozené třídě získá hodnotu, která označuje, zda je čtecí modul umístěn na konci proudu.When overridden in a derived class, gets a value indicating whether the reader is positioned at the end of the stream.

HasAttributes

Načte hodnotu, která označuje, jestli má aktuální uzel nějaké atributy.Gets a value indicating whether the current node has any attributes.

HasValue

Při přepsání v odvozené třídě získá hodnotu, která označuje, zda aktuální uzel může mít Value .When overridden in a derived class, gets a value indicating whether the current node can have a Value.

IsDefault

Při přepsání v odvozené třídě získá hodnotu, která označuje, zda je aktuální uzel atribut, který byl vygenerován z výchozí hodnoty definované v souboru DTD nebo schématu.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

Při přepsání v odvozené třídě získá hodnotu, která označuje, zda je aktuální uzel prázdným prvkem (například < MyElement/ > ).When overridden in a derived class, gets a value indicating whether the current node is an empty element (for example, <MyElement/>).

Item[Int32]

Při přepsání v odvozené třídě získá hodnotu atributu se zadaným indexem.When overridden in a derived class, gets the value of the attribute with the specified index.

Item[String, String]

Při přepsání v odvozené třídě získá hodnotu atributu se zadaným LocalName a NamespaceURI .When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

Item[String]

Při přepsání v odvozené třídě získá hodnotu atributu se zadaným Name .When overridden in a derived class, gets the value of the attribute with the specified Name.

LocalName

Při přepsání v odvozené třídě získá místní název aktuálního uzlu.When overridden in a derived class, gets the local name of the current node.

Name

Při přepsání v odvozené třídě získá úplný název aktuálního uzlu.When overridden in a derived class, gets the qualified name of the current node.

NamespaceURI

Při přepsání v odvozené třídě získá identifikátor URI oboru názvů (jak je definováno ve specifikaci oboru názvů W3C) uzlu, na kterém je umístěno čtecí modul.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

Při přepsání v odvozené třídě získá XmlNameTable přidružený k této implementaci.When overridden in a derived class, gets the XmlNameTable associated with this implementation.

NodeType

Při přepsání v odvozené třídě získá typ aktuálního uzlu.When overridden in a derived class, gets the type of the current node.

Prefix

Při přepsání v odvozené třídě získá předponu oboru názvů přidruženou k aktuálnímu uzlu.When overridden in a derived class, gets the namespace prefix associated with the current node.

QuoteChar

Při přepsání v odvozené třídě získá znak uvozovky, který se používá k uzavření hodnoty uzlu atributu.When overridden in a derived class, gets the quotation mark character used to enclose the value of an attribute node.

ReadState

Při přepsání v odvozené třídě získá stav čtecího modulu.When overridden in a derived class, gets the state of the reader.

SchemaInfo

Načte informace o schématu, které byly přiřazeny k aktuálnímu uzlu v důsledku ověření schématu.Gets the schema information that has been assigned to the current node as a result of schema validation.

Settings

Získá XmlReaderSettings objekt použitý k vytvoření této XmlReader instance.Gets the XmlReaderSettings object used to create this XmlReader instance.

Value

Při přepsání v odvozené třídě získá textovou hodnotu aktuálního uzlu.When overridden in a derived class, gets the text value of the current node.

ValueType

Získá typ modulu CLR (Common Language Runtime) pro aktuální uzel.Gets The Common Language Runtime (CLR) type for the current node.

XmlLang

Při přepsání v odvozené třídě získá aktuální xml:lang obor.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace

Při přepsání v odvozené třídě získá aktuální xml:space obor.When overridden in a derived class, gets the current xml:space scope.

Metody

Close()

Při přepsání v odvozené třídě změní na ReadState Closed .When overridden in a derived class, changes the ReadState to Closed.

Create(Stream)

Vytvoří novou XmlReader instanci pomocí zadaného datového proudu s výchozími nastaveními.Creates a new XmlReader instance using the specified stream with default settings.

Create(Stream, XmlReaderSettings)

Vytvoří novou XmlReader instanci se zadaným datovým proudem a nastavením.Creates a new XmlReader instance with the specified stream and settings.

Create(Stream, XmlReaderSettings, String)

Vytvoří novou XmlReader instanci pomocí zadaného datového proudu, základního identifikátoru URI a nastavení.Creates a new XmlReader instance using the specified stream, base URI, and settings.

Create(Stream, XmlReaderSettings, XmlParserContext)

Vytvoří novou XmlReader instanci pomocí zadaného datového proudu, nastavení a kontextové informace pro analýzu.Creates a new XmlReader instance using the specified stream, settings, and context information for parsing.

Create(String)

Vytvoří novou XmlReader instanci se zadaným identifikátorem URI.Creates a new XmlReader instance with specified URI.

Create(String, XmlReaderSettings)

Vytvoří novou XmlReader instanci pomocí zadaného identifikátoru URI a nastavení.Creates a new XmlReader instance by using the specified URI and settings.

Create(String, XmlReaderSettings, XmlParserContext)

Vytvoří novou XmlReader instanci pomocí zadaného identifikátoru URI, nastavení a kontextové informace pro analýzu.Creates a new XmlReader instance by using the specified URI, settings, and context information for parsing.

Create(TextReader)

Vytvoří novou XmlReader instanci pomocí zadaného čtecího modulu textu.Creates a new XmlReader instance by using the specified text reader.

Create(TextReader, XmlReaderSettings)

Vytvoří novou XmlReader instanci pomocí zadaného čtecího modulu textu a nastavení.Creates a new XmlReader instance by using the specified text reader and settings.

Create(TextReader, XmlReaderSettings, String)

Vytvoří novou XmlReader instanci pomocí zadaného čtecího modulu textu, nastavení a základního identifikátoru URI.Creates a new XmlReader instance by using the specified text reader, settings, and base URI.

Create(TextReader, XmlReaderSettings, XmlParserContext)

Vytvoří novou XmlReader instanci pomocí zadaného čtecího textu, nastavení a kontextové informace pro analýzu.Creates a new XmlReader instance by using the specified text reader, settings, and context information for parsing.

Create(XmlReader, XmlReaderSettings)

Vytvoří novou XmlReader instanci pomocí zadaného čtecího modulu XML a nastavení.Creates a new XmlReader instance by using the specified XML reader and settings.

Dispose()

Uvolní všechny prostředky používané aktuální instancí XmlReader třídy.Releases all resources used by the current instance of the XmlReader class.

Dispose(Boolean)

Uvolní nespravované prostředky používané XmlReader a volitelně uvolňuje spravované prostředky.Releases the unmanaged resources used by the XmlReader and optionally releases the managed resources.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetAttribute(Int32)

Při přepsání v odvozené třídě získá hodnotu atributu se zadaným indexem.When overridden in a derived class, gets the value of the attribute with the specified index.

GetAttribute(String)

Při přepsání v odvozené třídě získá hodnotu atributu se zadaným Name .When overridden in a derived class, gets the value of the attribute with the specified Name.

GetAttribute(String, String)

Při přepsání v odvozené třídě získá hodnotu atributu se zadaným LocalName a NamespaceURI .When overridden in a derived class, gets the value of the attribute with the specified LocalName and NamespaceURI.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
GetValueAsync()

Asynchronně získá hodnotu aktuálního uzlu.Asynchronously gets the value of the current node.

IsName(String)

Vrátí hodnotu, která označuje, zda je řetězcový argument platným názvem XML.Returns a value indicating whether the string argument is a valid XML name.

IsNameToken(String)

Vrátí hodnotu, která označuje, zda je řetězcový argument platným tokenem názvu XML.Returns a value indicating whether or not the string argument is a valid XML name token.

IsStartElement()

Volání MoveToContent() a testy, pokud je aktuální uzel obsahu počáteční značka nebo prázdná značka elementu.Calls MoveToContent() and tests if the current content node is a start tag or empty element tag.

IsStartElement(String)

Volání MoveToContent() a testy, pokud je aktuální uzel obsahu počáteční značka nebo prázdná značka elementu a zda Name vlastnost elementu nalezena odpovídá danému argumentu.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)

Volání MoveToContent() a testy, pokud je aktuální uzel obsahu počáteční značka nebo prázdná značka elementu, a pokud LocalName vlastnosti a NamespaceURI elementu nalezené v daném řetězci odpovídají daným řetězcům.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)

Při přepsání v odvozené třídě je přeložena předpona oboru názvů v oboru aktuálního prvku.When overridden in a derived class, resolves a namespace prefix in the current element's scope.

MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
MoveToAttribute(Int32)

Při přepsání v odvozené třídě se přesune k atributu se zadaným indexem.When overridden in a derived class, moves to the attribute with the specified index.

MoveToAttribute(String)

Při přepsání v odvozené třídě se přesune na atribut se zadaným parametrem Name .When overridden in a derived class, moves to the attribute with the specified Name.

MoveToAttribute(String, String)

Při přepsání v odvozené třídě se přesune na atribut se zadaným LocalName a NamespaceURI .When overridden in a derived class, moves to the attribute with the specified LocalName and NamespaceURI.

MoveToContent()

Zkontroluje, zda je aktuální uzel obsahem (neprázdný text,,,, CDATA Element EndElement EntityReference nebo EndEntity ) uzlu.Checks whether the current node is a content (non-white space text, CDATA, Element, EndElement, EntityReference, or EndEntity) node. Pokud uzel není uzel obsahu, čtecí modul přeskočí na další uzel obsahu nebo konec souboru.If the node is not a content node, the reader skips ahead to the next content node or end of file. Přeskočí uzly následujícího typu: ProcessingInstruction , DocumentType , Comment , Whitespace nebo SignificantWhitespace .It skips over nodes of the following type: ProcessingInstruction, DocumentType, Comment, Whitespace, or SignificantWhitespace.

MoveToContentAsync()

Asynchronně kontroluje, zda je aktuální uzel uzel obsahu.Asynchronously checks whether the current node is a content node. Pokud uzel není uzel obsahu, čtecí modul přeskočí na další uzel obsahu nebo konec souboru.If the node is not a content node, the reader skips ahead to the next content node or end of file.

MoveToElement()

Při přepsání v odvozené třídě se přesune k prvku, který obsahuje aktuální uzel atributu.When overridden in a derived class, moves to the element that contains the current attribute node.

MoveToFirstAttribute()

Při přepsání v odvozené třídě se přesune k prvnímu atributu.When overridden in a derived class, moves to the first attribute.

MoveToNextAttribute()

Při přepsání v odvozené třídě se přesune k dalšímu atributu.When overridden in a derived class, moves to the next attribute.

Read()

Při přepsání v odvozené třídě přečte další uzel z datového proudu.When overridden in a derived class, reads the next node from the stream.

ReadAsync()

Asynchronně načte další uzel z datového proudu.Asynchronously reads the next node from the stream.

ReadAttributeValue()

Při přepsání v odvozené třídě analyzuje hodnotu atributu na jeden nebo více Text EntityReference uzlů, nebo EndEntity .When overridden in a derived class, parses the attribute value into one or more Text, EntityReference, or EndEntity nodes.

ReadContentAs(Type, IXmlNamespaceResolver)

Přečte obsah jako objekt zadaného typu.Reads the content as an object of the type specified.

ReadContentAsAsync(Type, IXmlNamespaceResolver)

Asynchronně přečte obsah jako objekt zadaného typu.Asynchronously reads the content as an object of the type specified.

ReadContentAsBase64(Byte[], Int32, Int32)

Přečte obsah a vrátí binární bajty dekódovaného kódu base64.Reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBase64Async(Byte[], Int32, Int32)

Asynchronně přečte obsah a vrátí binární bajty dekódovaného kódu base64.Asynchronously reads the content and returns the Base64 decoded binary bytes.

ReadContentAsBinHex(Byte[], Int32, Int32)

Přečte obsah a vrátí BinHex Dekódovatelné binární bajty.Reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBinHexAsync(Byte[], Int32, Int32)

Asynchronně přečte obsah a vrátí BinHex Dekódovatelné binární bajty.Asynchronously reads the content and returns the BinHex decoded binary bytes.

ReadContentAsBoolean()

Přečte textový obsah na aktuální pozici jako Boolean .Reads the text content at the current position as a Boolean.

ReadContentAsDateTime()

Přečte textový obsah na aktuální pozici jako DateTime objekt.Reads the text content at the current position as a DateTime object.

ReadContentAsDateTimeOffset()

Přečte textový obsah na aktuální pozici jako DateTimeOffset objekt.Reads the text content at the current position as a DateTimeOffset object.

ReadContentAsDecimal()

Přečte textový obsah na aktuální pozici jako Decimal objekt.Reads the text content at the current position as a Decimal object.

ReadContentAsDouble()

Přečte textový obsah na aktuální pozici jako číslo s plovoucí desetinnou čárkou s dvojitou přesností.Reads the text content at the current position as a double-precision floating-point number.

ReadContentAsFloat()

Přečte textový obsah na aktuální pozici jako číslo s plovoucí desetinnou čárkou s jednoduchou přesností.Reads the text content at the current position as a single-precision floating point number.

ReadContentAsInt()

Přečte textový obsah na aktuální pozici jako 32é celé číslo se znaménkem.Reads the text content at the current position as a 32-bit signed integer.

ReadContentAsLong()

Přečte textový obsah na aktuální pozici jako 64é celé číslo se znaménkem.Reads the text content at the current position as a 64-bit signed integer.

ReadContentAsObject()

Přečte textový obsah na aktuální pozici jako Object .Reads the text content at the current position as an Object.

ReadContentAsObjectAsync()

Asynchronně přečte textový obsah na aktuální pozici jako Object .Asynchronously reads the text content at the current position as an Object.

ReadContentAsString()

Přečte textový obsah na aktuální pozici jako String objekt.Reads the text content at the current position as a String object.

ReadContentAsStringAsync()

Asynchronně přečte textový obsah na aktuální pozici jako String objekt.Asynchronously reads the text content at the current position as a String object.

ReadElementContentAs(Type, IXmlNamespaceResolver)

Přečte obsah elementu podle požadovaného typu.Reads the element content as the requested type.

ReadElementContentAs(Type, IXmlNamespaceResolver, String, String)

Kontroluje, zda zadaný místní název a identifikátor URI oboru názvů odpovídají aktuálnímu prvku, a pak přečte obsah elementu jako požadovaný 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)

Asynchronně přečte obsah elementu podle požadovaného typu.Asynchronously reads the element content as the requested type.

ReadElementContentAsBase64(Byte[], Int32, Int32)

Přečte prvek a dekóduje Base64 obsah.Reads the element and decodes the Base64 content.

ReadElementContentAsBase64Async(Byte[], Int32, Int32)

Asynchronně přečte prvek a dekóduje Base64 obsah.Asynchronously reads the element and decodes the Base64 content.

ReadElementContentAsBinHex(Byte[], Int32, Int32)

Přečte prvek a dekóduje BinHex obsah.Reads the element and decodes the BinHex content.

ReadElementContentAsBinHexAsync(Byte[], Int32, Int32)

Asynchronně přečte prvek a dekóduje BinHex obsah.Asynchronously reads the element and decodes the BinHex content.

ReadElementContentAsBoolean()

Přečte aktuální prvek a vrátí obsah jako Boolean objekt.Reads the current element and returns the contents as a Boolean object.

ReadElementContentAsBoolean(String, String)

Kontroluje, zda zadaný název místního názvu a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako Boolean objekt.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()

Přečte aktuální prvek a vrátí obsah jako DateTime objekt.Reads the current element and returns the contents as a DateTime object.

ReadElementContentAsDateTime(String, String)

Kontroluje, zda zadaný název místního názvu a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako DateTime objekt.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()

Přečte aktuální prvek a vrátí obsah jako Decimal objekt.Reads the current element and returns the contents as a Decimal object.

ReadElementContentAsDecimal(String, String)

Kontroluje, zda zadaný název místního názvu a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako Decimal objekt.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()

Přečte aktuální prvek a vrátí obsah jako číslo s plovoucí desetinnou čárkou s dvojitou přesností.Reads the current element and returns the contents as a double-precision floating-point number.

ReadElementContentAsDouble(String, String)

Kontroluje, zda zadaný název místního názvu a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako číslo s plovoucí desetinnou čárkou s dvojitou přesností.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()

Přečte aktuální prvek a vrátí obsah jako číslo s plovoucí desetinnou čárkou s jednoduchou přesností.Reads the current element and returns the contents as single-precision floating-point number.

ReadElementContentAsFloat(String, String)

Kontroluje, zda zadaný název místního názvu a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako číslo s plovoucí desetinnou čárkou s jednoduchou přesností.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()

Přečte aktuální prvek a vrátí obsah jako 32 celé číslo se znaménkem.Reads the current element and returns the contents as a 32-bit signed integer.

ReadElementContentAsInt(String, String)

Kontroluje, zda zadaný místní název a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako 32 celé číslo se znaménkem.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()

Přečte aktuální prvek a vrátí obsah jako 64 celé číslo se znaménkem.Reads the current element and returns the contents as a 64-bit signed integer.

ReadElementContentAsLong(String, String)

Kontroluje, zda zadaný místní název a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako 64 celé číslo se znaménkem.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()

Přečte aktuální prvek a vrátí obsah jako Object .Reads the current element and returns the contents as an Object.

ReadElementContentAsObject(String, String)

Kontroluje, zda zadaný místní název a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako Object .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()

Asynchronně přečte aktuální prvek a vrátí obsah jako Object .Asynchronously reads the current element and returns the contents as an Object.

ReadElementContentAsString()

Přečte aktuální prvek a vrátí obsah jako String objekt.Reads the current element and returns the contents as a String object.

ReadElementContentAsString(String, String)

Kontroluje, zda zadaný název místního názvu a identifikátor URI oboru názvů odpovídá aktuálnímu prvku a následně přečte aktuální prvek a vrátí obsah jako String objekt.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()

Asynchronně přečte aktuální prvek a vrátí obsah jako String objekt.Asynchronously reads the current element and returns the contents as a String object.

ReadElementString()

Přečte textový element.Reads a text-only element. Doporučujeme však použít ReadElementContentAsString() místo toho metodu, protože poskytuje jednodušší způsob, jak tuto operaci zpracovat.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

ReadElementString(String)

Kontroluje, zda Name vlastnost nalezeného prvku odpovídá danému řetězci před čtením elementu pouze pro text.Checks that the Name property of the element found matches the given string before reading a text-only element. Doporučujeme však použít ReadElementContentAsString() místo toho metodu, protože poskytuje jednodušší způsob, jak tuto operaci zpracovat.However, we recommend that you use the ReadElementContentAsString() method instead, because it provides a more straightforward way to handle this operation.

ReadElementString(String, String)

Kontroluje, zda LocalName NamespaceURI vlastnosti a nalezené elementu odpovídají daným řetězcům před čtením elementu pouze pro text.Checks that the LocalName and NamespaceURI properties of the element found matches the given strings before reading a text-only element. Doporučujeme však použít ReadElementContentAsString(String, String) místo toho metodu, protože poskytuje jednodušší způsob, jak tuto operaci zpracovat.However, we recommend that you use the ReadElementContentAsString(String, String) method instead, because it provides a more straightforward way to handle this operation.

ReadEndElement()

Kontroluje, zda je aktuální uzel obsahu koncovou značkou a přechází čtenáře na další uzel.Checks that the current content node is an end tag and advances the reader to the next node.

ReadInnerXml()

Při přepsání v odvozené třídě přečte veškerý obsah včetně značek jako řetězce.When overridden in a derived class, reads all the content, including markup, as a string.

ReadInnerXmlAsync()

Asynchronně načte veškerý obsah včetně značek jako řetězce.Asynchronously reads all the content, including markup, as a string.

ReadOuterXml()

Při přepsání v odvozené třídě přečte obsah, včetně značek, představujících tento uzel a všechny jeho podřízené objekty.When overridden in a derived class, reads the content, including markup, representing this node and all its children.

ReadOuterXmlAsync()

Asynchronně přečte obsah včetně značek, který představuje tento uzel a všechny jeho podřízené objekty.Asynchronously reads the content, including markup, representing this node and all its children.

ReadStartElement()

Kontroluje, zda je aktuální uzel prvkem, a přesune čtenáře do dalšího uzlu.Checks that the current node is an element and advances the reader to the next node.

ReadStartElement(String)

Kontroluje, zda je aktuální uzel obsahu prvkem s daným objektem Name a přechází čtenáře na další uzel.Checks that the current content node is an element with the given Name and advances the reader to the next node.

ReadStartElement(String, String)

Kontroluje, zda je aktuální uzel obsahu prvkem s daným LocalName a a přechází NamespaceURI čtenáře na další uzel.Checks that the current content node is an element with the given LocalName and NamespaceURI and advances the reader to the next node.

ReadString()

Při přepsání v odvozené třídě přečte obsah elementu nebo textového uzlu jako řetězec.When overridden in a derived class, reads the contents of an element or text node as a string. Doporučujeme však použít ReadElementContentAsString místo toho metodu, protože poskytuje jednodušší způsob, jak tuto operaci zpracovat.However, we recommend that you use the ReadElementContentAsString method instead, because it provides a more straightforward way to handle this operation.

ReadSubtree()

Vrátí novou XmlReader instanci, kterou lze použít ke čtení aktuálního uzlu a všech jeho potomků.Returns a new XmlReader instance that can be used to read the current node, and all its descendants.

ReadToDescendant(String)

Přejde na XmlReader Další následníkný prvek se zadaným kvalifikovaným názvem.Advances the XmlReader to the next descendant element with the specified qualified name.

ReadToDescendant(String, String)

Přejde na XmlReader Další následný element se zadaným místním názvem a identifikátorem URI oboru názvů.Advances the XmlReader to the next descendant element with the specified local name and namespace URI.

ReadToFollowing(String)

Přečte se, dokud se nenajde element se zadaným úplným názvem.Reads until an element with the specified qualified name is found.

ReadToFollowing(String, String)

Přečte se, dokud se nenajde element se zadaným místním názvem a identifikátorem URI oboru názvů.Reads until an element with the specified local name and namespace URI is found.

ReadToNextSibling(String)

Přejde XmlReader k dalšímu elementu na stejné úrovni se zadaným úplným názvem.Advances the XmlReader to the next sibling element with the specified qualified name.

ReadToNextSibling(String, String)

Přejde XmlReader k dalšímu elementu na stejné úrovni se zadaným místním názvem a identifikátorem URI oboru názvů.Advances the XmlReader to the next sibling element with the specified local name and namespace URI.

ReadValueChunk(Char[], Int32, Int32)

Přečte velké streamy textu vložené v dokumentu XML.Reads large streams of text embedded in an XML document.

ReadValueChunkAsync(Char[], Int32, Int32)

Asynchronně čte velké proudy textu vložené v dokumentu XML.Asynchronously reads large streams of text embedded in an XML document.

ResolveEntity()

Při přepsání v odvozené třídě se vyřeší odkaz na entitu pro EntityReference uzly.When overridden in a derived class, resolves the entity reference for EntityReference nodes.

Skip()

Přeskočí podřízené položky aktuálního uzlu.Skips the children of the current node.

SkipAsync()

Asynchronně přeskočí podřízené objekty aktuálního uzlu.Asynchronously skips the children of the current node.

ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

IDisposable.Dispose()

Popis tohoto člena naleznete v tématu Dispose() .For a description of this member, see Dispose().

Platí pro