XmlWriter Třída

Definice

Představuje zapisovač, který poskytuje rychlý, neuložený obsah do mezipaměti, pouze pro vytváření datových proudů nebo souborů obsahujících data XML.Represents a writer that provides a fast, non-cached, forward-only way to generate streams or files that contain XML data.

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

Příklady

Následující příklad kódu ukazuje, jak použít asynchronní rozhraní API k vygenerování XML.The following example code shows how to use the asynchronous API to generate XML.

async Task TestWriter(Stream stream)   
{  
    XmlWriterSettings settings = new XmlWriterSettings();  
    settings.Async = true;  

    using (XmlWriter writer = XmlWriter.Create(stream, settings)) {  
        await writer.WriteStartElementAsync("pf", "root", "http://ns");  
        await writer.WriteStartElementAsync(null, "sub", null);  
        await writer.WriteAttributeStringAsync(null, "att", null, "val");  
        await writer.WriteStringAsync("text");  
        await writer.WriteEndElementAsync();  
        await writer.WriteProcessingInstructionAsync("pName", "pValue");  
        await writer.WriteCommentAsync("cValue");  
        await writer.WriteCDataAsync("cdata value");  
        await writer.WriteEndElementAsync();  
        await writer.FlushAsync();  
    }  
}  

Poznámky

XmlWriterTřída zapisuje data XML do datového proudu, souboru, čtečky textu nebo řetězce.The XmlWriter class writes XML data to a stream, file, text reader, or string. Podporuje 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) .It supports the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and Namespaces in XML 1.0 (third edition) recommendations.

Členové XmlWriter třídy vám umožňují:The members of the XmlWriter class enable you to:

  • Ověřte, že tyto znaky jsou platné znaky XML a že názvy elementů a atributů jsou platné názvy XML.Verify that the characters are legal XML characters and that element and attribute names are valid XML names.

  • Ověřte, zda je dokument XML správně vytvořen.Verify that the XML document is well-formed.

  • Kódování binárních bajtů jako Base64 nebo BinHex a vypsání výsledného textu.Encode binary bytes as Base64 or BinHex, and write out the resulting text.

  • Předejte hodnoty pomocí typů modulu CLR (Common Language Runtime) namísto řetězců, abyste se vyhnuli nutnosti provádět převody hodnot ručně.Pass values by using common language runtime types instead of strings, to avoid having to manually perform value conversions.

  • Zápis více dokumentů do jednoho výstupního datového proudu.Write multiple documents to one output stream.

  • Zápis platných názvů, kvalifikovaných názvů a tokenů názvů.Write valid names, qualified names, and name tokens.

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

Vytvoření zapisovače XML Creating an XML writer
Určení formátu výstupu Specifying the output format
Shoda dat Data conformance
Zápis prvků Writing elements
Psaní atributů Writing attributes
Zpracování oborů názvů Handling namespaces
Zápis typových dat Writing typed data
Zavření zapisovače XML Closing the XML writer
Asynchronní programování Asynchronous programming
Důležité informace o zabezpečeníSecurity considerations

Vytvoření zapisovače XMLCreating an XML writer

Chcete-li vytvořit XmlWriter instanci, použijte XmlWriter.Create metodu.To create an XmlWriter instance, use the XmlWriter.Create method. Chcete-li zadat sadu funkcí, které chcete povolit u zapisovače XML, předejte XmlWriterSettings metodu do Create metody.To specify the set of features you want to enable on the XML writer, pass an XmlWriterSettings to the Create method. V opačném případě se použijí výchozí nastavení.Otherwise, default settings are used. Podrobnosti najdete na Create referenčních stránkách.See the Create reference pages for details.

Určení formátu výstupuSpecifying the output format

XmlWriterSettingsTřída obsahuje několik vlastností, které řídí XmlWriter formátování výstupu:The XmlWriterSettings class includes several properties that control how XmlWriter output is formatted:

VlastnostProperty PopisDescription
Encoding Určuje kódování textu, které se má použít.Specifies the text encoding to use. Výchozí formát je Encoding.UTF8.The default is Encoding.UTF8.
Indent Označuje, zda mají být prvky odsazeny.Indicates whether to indent elements. Výchozí hodnota je false (bez odsazení).The default is false (no indentation).
IndentChars Určuje řetězec znaků, který má být použit při odsazení.Specifies the character string to use when indenting. Výchozí hodnota je dvě mezery.The default is two spaces.
NewLineChars Určuje řetězec znaků, který má být použit pro konce řádků.Specifies the character string to use for line breaks. Výchozí hodnota je \r\n (návrat z řádku, kanál čáry).The default is \r\n (carriage return, line feed).
NewLineHandling Určuje, jak se mají zpracovat znaky nového řádku.Specifies how to handle newline characters.
NewLineOnAttributes Určuje, zda zapisovat atributy na nový řádek.Indicates whether to write attributes on a new line. Indent Při použití této vlastnosti by měla být nastavena na hodnotu true .Indent should be set to true when using this property. Výchozí formát je false.The default is false.
OmitXmlDeclaration Označuje, zda se má zapsat deklarace XML.Indicates whether to write an XML declaration. Výchozí formát je false.The default is false.

IndentVlastnosti a IndentChars určují, jak je formátováno nedůležité prázdné znaky.The Indent and IndentChars properties control how insignificant white space is formatted. Například pro odsazování uzlů elementů:For example, to indent element nodes:

XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = "\t";
XmlWriter writer = XmlWriter.Create("books.xml", settings);
Dim settings As New XmlWriterSettings()
settings.Indent = True
settings.IndentChars = vbTab
Dim writer As XmlWriter = XmlWriter.Create("books.xml", settings)

Použijte NewLineOnAttributes pro zápis každého atributu na nový řádek s jednou další úrovní odsazení:Use the NewLineOnAttributes to write each attribute on a new line with one extra level of indentation:

XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.NewLineOnAttributes = true;
XmlWriter writer = XmlWriter.Create("books.xml", settings);
Dim settings As New XmlWriterSettings()
settings.Indent = True
settings.NewLineOnAttributes = True
Dim writer As XmlWriter = XmlWriter.Create("books.xml", settings)

Shoda datData conformance

Zapisovač XML používá XmlWriterSettings ke kontrole shody dat dvě vlastnosti z třídy:An XML writer uses two properties from the XmlWriterSettings class to check for data conformance:

  • CheckCharactersVlastnost instruuje ZAPISOVAČ XML, aby zkontroloval znaky a vyvolal XmlException výjimku, pokud jsou nějaké znaky mimo platný rozsah, jak definuje W3C.The CheckCharacters property instructs the XML writer to check characters and throw an XmlException exception if any characters are outside the legal range, as defined by the W3C.

  • ConformanceLevelVlastnost nakonfiguruje ZAPISOVAČ XML, aby zkontroloval, jestli je datový proud v souladu s pravidly pro dobře vytvořený dokument XML 1,0 nebo fragment dokumentu, jak definuje W3C.The ConformanceLevel property configures the XML writer to check that the stream being written complies with the rules for a well-formed XML 1.0 document or document fragment, as defined by the W3C. Tři úrovně shody jsou popsány v následující tabulce.The three conformance levels are described in the following table. Výchozí formát je Document.The default is Document. Podrobnosti naleznete v tématu XmlWriterSettings.ConformanceLevel vlastnost a System.Xml.ConformanceLevel výčet.For details, see the XmlWriterSettings.ConformanceLevel property and the System.Xml.ConformanceLevel enumeration.

    LevelLevel DescriptionDescription
    Document Výstup XML odpovídá pravidlům pro dobře vytvořený dokument XML 1,0 a může být zpracován jakýmkoli procesorem, který je v souladu.The XML output conforms to the rules for a well-formed XML 1.0 document and can be processed by any conforming processor.
    Fragment Výstup XML odpovídá pravidlům pro fragment dokumentu XML 1,0 ve správném formátu.The XML output conforms to the rules for a well-formed XML 1.0 document fragment.
    Auto Zapisovač XML určuje, která úroveň shody se má použít (dokument nebo fragment) na základě příchozích dat.The XML writer determines which level of conformation checking to apply (document or fragment) based on the incoming data.

Zápis prvkůWriting elements

Následující metody lze použít XmlWriter pro zápis uzlů prvků.You can use the following XmlWriter methods to write element nodes. Příklady najdete v uvedených metodách.For examples, see the methods listed.

PoužitíUse ZáměrTo
WriteElementString Zápis celého uzlu elementu, včetně řetězcové hodnoty.Write an entire element node, including a string value.
WriteStartElement Pro zápis hodnoty elementu pomocí více volání metody.To write an element value by using multiple method calls. Například můžete volat WriteValue pro zápis typové hodnoty, WriteCharEntity pro zápis znakových entit, WriteAttributeString pro zápis atributu nebo můžete napsat podřízený element.For example, you can call WriteValue to write a typed value, WriteCharEntity to write a character entity, WriteAttributeString to write an attribute, or you can write a child element. Toto je propracovanější verze WriteElementString metody.This is a more sophisticated version of the WriteElementString method.

Chcete-li element zavřít, zavolejte WriteEndElement metodu nebo WriteFullEndElement .To close the element, you call the WriteEndElement or WriteFullEndElement method.
WriteNode Ke zkopírování uzlu elementu nalezeného na aktuální pozici XmlReader XPathNavigator objektu nebo.To copy an element node found at the current position of an XmlReader or XPathNavigator object. Při volání zkopíruje vše ze zdrojového objektu do XmlWriter instance.When called, it copies everything from the source object to the XmlWriter instance.

Psaní atributůWriting attributes

Následující metody lze použít XmlWriter pro zápis atributů v uzlech prvků.You can use the following XmlWriter methods to write attributes on element nodes. Tyto metody lze také použít k vytvoření deklarace oboru názvů u prvku, jak je popsáno v následující části.These methods can also be used to create namespace declarations on an element, as discussed in the next section.

PoužitíUse ZáměrTo
WriteAttributeString Pro zápis celého uzlu atributu včetně řetězcové hodnoty.To write an entire attribute node, including a string value.
WriteStartAttribute Pro zápis hodnoty atributu pomocí více volání metody.To write the attribute value using multiple method calls. Například můžete zavolat WriteValue pro zápis typované hodnoty.For example, you can call WriteValue to write a typed value. Toto je propracovanější verze WriteElementString metody.This is a more sophisticated version of the WriteElementString method.

Chcete-li element zavřít, zavolejte WriteEndAttribute metodu.To close the element, you call the WriteEndAttribute method.
WriteAttributes Ke zkopírování všech atributů nalezených na aktuální pozici XmlReader objektu.To copy all the attributes found at the current position of an XmlReader object. Atributy, které jsou zapsány závisí na typu uzlu, na kterém je čtecí modul aktuálně umístěn:The attributes that are written depend on the type of node the reader is currently positioned on:

– Pro uzel atributu zapíše aktuální atribut a potom zbytek atributů do uzavírací značky elementu.- For an attribute node, it writes the current attribute, and then the rest of the attributes until the element closing tag.
– Pro uzel elementu zapisuje všechny atributy, které jsou obsaženy v elementu.- For an element node, it writes all attributes contained by the element.
– Pro uzel deklarace XML zapisuje všechny atributy v deklaraci.- For an XML declaration node, it writes all the attributes in the declaration.
– Pro všechny ostatní typy uzlů vyvolá metoda výjimku.- For all other node types, the method throws an exception.

Zpracování oborů názvůHandling namespaces

Obory názvů slouží k získání názvů prvků a atributů v dokumentu XML.Namespaces are used to qualify element and attribute names in an XML document. Předpony oboru názvů přiřadí prvky a atributy k oborům názvů, které jsou zase přidruženy k odkazům identifikátoru URI.Namespace prefixes associate elements and attributes with namespaces, which are in turn associated with URI references. Obory názvů vytvářejí jedinečnost názvu elementu a atributu v dokumentu XML.Namespaces create element and attribute name uniqueness in an XML document.

XmlWriterUdržuje zásobník oboru názvů, který odpovídá všem oborům názvů definovaným v aktuálním oboru názvů.The XmlWriter maintains a namespace stack that corresponds to all the namespaces defined in the current namespace scope. Při psaní prvků a atributů můžete obory názvů využít následujícími způsoby:When writing elements and attributes you can utilize namespaces in the following ways:

  • Deklarujte obory názvů ručně pomocí WriteAttributeString metody.Declare namespaces manually by using the WriteAttributeString method. To může být užitečné, když víte, jak nejlépe optimalizovat počet deklarací oboru názvů.This can be useful when you know how to best optimize the number of namespace declarations. Příklad naleznete v WriteAttributeString(String, String, String, String) metodě.For an example, see the WriteAttributeString(String, String, String, String) method.

  • Přepsat aktuální deklaraci oboru názvů novým oborem názvů.Override the current namespace declaration with a new namespace. V následujícím kódu WriteAttributeString metoda změní identifikátor URI oboru názvů pro "x" předponu z "123" na "abc" .In the following code, the WriteAttributeString method changes the namespace URI for the "x" prefix from "123" to "abc".

    writer.WriteStartElement("x", "root", "123");
    writer.WriteStartElement("item");
    writer.WriteAttributeString("xmlns", "x", null, "abc");
    writer.WriteEndElement();
    writer.WriteEndElement();
    
    writer.WriteStartElement("x", "root", "123")
    writer.WriteStartElement("item")
    writer.WriteAttributeString("xmlns", "x", Nothing, "abc")
    writer.WriteEndElement()
    writer.WriteEndElement()
    

    Kód generuje následující řetězec XML:The code generates the following XML string:

    <x:root xmlns:x="123">  
      <item xmlns:x="abc" />  
    </x:root>  
    
  • Při psaní atributů nebo elementů zadejte předponu oboru názvů.Specify a namespace prefix when writing attributes or elements. Mnohé z metod, které slouží k psaní element a atributů, vám to umožňují.Many of the methods used to write element and attributes enable you to do this. Například WriteStartElement(String, String, String) Metoda zapíše počáteční značku a přidruží ji ke specifikovanému oboru názvů a předponu.For example, the WriteStartElement(String, String, String) method writes a start tag and associates it with a specified namespace and prefix.

Zápis typových datWriting typed data

WriteValueMetoda přijímá objekt modulu CLR (Common Language Runtime), převede vstupní hodnotu na jeho řetězcovou reprezentaci podle pravidel pro převod datového typu schématu XML (XSD) a zapíše je pomocí WriteString metody.The WriteValue method accepts a common language runtime (CLR) object, converts the input value to its string representation according to XML schema definition language (XSD) data type conversion rules, and writes it out by using the WriteString method. To je snazší než použití metod ve XmlConvert třídě pro převod zadaných dat na hodnotu řetězce před jejich zápisem do výstupní hodnoty.This is easier than using the methods in the XmlConvert class to convert the typed data to a string value before writing it out.

Při zápisu do textu je zadaná hodnota serializovaná na text pomocí XmlConvert pravidel pro daný typ schématu.When writing to text, the typed value is serialized to text by using the XmlConvert rules for that schema type.

Pro výchozí datové typy XSD, které odpovídají typům CLR, se podívejte na WriteValue metodu.For default XSD data types that correspond to CLR types, see the WriteValue method.

XmlWriterLze také použít k zápisu do úložiště dat XML.The XmlWriter can also be used to write to an XML data store. XPathNavigatorTřída může například vytvořit XmlWriter objekt pro vytváření uzlů pro XmlDocument objekt.For example, the XPathNavigator class can create an XmlWriter object to create nodes for an XmlDocument object. Pokud je v úložišti dat k dispozici informace o schématu, WriteValue vyvolá metoda výjimku, pokud se pokusíte převést na typ, který není povolen.If the data store has schema information available to it, the WriteValue method throws an exception if you try to convert to a type that is not allowed. Pokud úložiště dat nemá k dispozici informace o schématu, WriteValue metoda zpracuje všechny hodnoty jako xsd:anySimpleType typ.If the data store does not have schema information available to it, the WriteValue method treats all values as an xsd:anySimpleType type.

Zavření zapisovače XMLClosing the XML writer

Použijete XmlWriter -li metody pro výstup XML, prvky a atributy nejsou zapsány, dokud nebudete volat Close metodu.When you use XmlWriter methods to output XML, the elements and attributes are not written until you call the Close method. Například pokud používáte XmlWriter k naplnění XmlDocument objektu, nebudete moci v cílovém dokumentu zobrazit zapsané prvky a atributy, dokud instanci nezavřete XmlWriter .For example, if you are using XmlWriter to populate an XmlDocument object, you won't be able to see the written elements and attributes in the target document until you close the XmlWriter instance.

Asynchronní programováníAsynchronous programming

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

Pro WriteValue metodu, která nemá asynchronní protějšek, převeďte návratovou hodnotu na řetězec a WriteStringAsync místo toho použijte metodu.For the WriteValue method, which doesn't have an asynchronous counterpart, convert the return value to a string and use the WriteStringAsync method instead.

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

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

  • Výjimky vyvolané pomocí XmlWriter můžou zveřejnit informace o cestě, které nechcete nastavovat do aplikace.Exceptions thrown by the XmlWriter can disclose path information that you do not want bubbled up to the app. Vaše aplikace musí zachytit výjimky a vhodně je zpracovat.Your app must catch exceptions and process them appropriately.

  • XmlWriter neověřuje žádná data, která jsou předána WriteDocType metodě nebo WriteRaw .XmlWriter does not validate any data that is passed to the WriteDocType or WriteRaw method. Do těchto metod byste neměli předávat libovolná data.You should not pass arbitrary data to these methods.

Konstruktory

XmlWriter()

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

Vlastnosti

Settings

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

WriteState

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

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á hodnotu XmlSpace představující aktuální xml:space obor.When overridden in a derived class, gets an XmlSpace representing the current xml:space scope.

Metody

Close()

Při přepsání v odvozené třídě zavře tento datový proud a podkladový datový proud.When overridden in a derived class, closes this stream and the underlying stream.

Create(Stream)

Vytvoří novou XmlWriter instanci pomocí zadaného datového proudu.Creates a new XmlWriter instance using the specified stream.

Create(Stream, XmlWriterSettings)

Vytvoří novou XmlWriter instanci pomocí datového proudu a XmlWriterSettings objektu.Creates a new XmlWriter instance using the stream and XmlWriterSettings object.

Create(String)

Vytvoří novou XmlWriter instanci pomocí zadaného názvu souboru.Creates a new XmlWriter instance using the specified filename.

Create(String, XmlWriterSettings)

Vytvoří novou XmlWriter instanci pomocí názvu souboru a XmlWriterSettings objektu.Creates a new XmlWriter instance using the filename and XmlWriterSettings object.

Create(StringBuilder)

Vytvoří novou XmlWriter instanci pomocí zadaného StringBuilder .Creates a new XmlWriter instance using the specified StringBuilder.

Create(StringBuilder, XmlWriterSettings)

Vytvoří novou XmlWriter instanci pomocí StringBuilder XmlWriterSettings objektů a.Creates a new XmlWriter instance using the StringBuilder and XmlWriterSettings objects.

Create(TextWriter)

Vytvoří novou XmlWriter instanci pomocí zadaného TextWriter .Creates a new XmlWriter instance using the specified TextWriter.

Create(TextWriter, XmlWriterSettings)

Vytvoří novou XmlWriter instanci pomocí TextWriter XmlWriterSettings objektů a.Creates a new XmlWriter instance using the TextWriter and XmlWriterSettings objects.

Create(XmlWriter)

Vytvoří novou XmlWriter instanci pomocí zadaného XmlWriter objektu.Creates a new XmlWriter instance using the specified XmlWriter object.

Create(XmlWriter, XmlWriterSettings)

Vytvoří novou XmlWriter instanci pomocí zadaných XmlWriter XmlWriterSettings objektů a.Creates a new XmlWriter instance using the specified XmlWriter and XmlWriterSettings objects.

Dispose()

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

Dispose(Boolean)

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

DisposeAsync()

Provádí úkoly definované aplikací, které jsou spojeny s uvolněním, uvolněním nebo obnovením nespravovaných prostředků asynchronně.Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources asynchronously.

DisposeAsyncCore()

Provádí úkoly definované aplikací, které jsou spojeny s uvolněním, uvolněním nebo resetováním spravovaných prostředků asynchronně.Performs application-defined tasks associated with freeing, releasing, or resetting managed resources asynchronously.

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)
Flush()

Pokud je přepsána v odvozené třídě, vyprázdní vše, co je ve vyrovnávací paměti, na podkladové datové proudy a také vyprázdní podkladový datový proud.When overridden in a derived class, flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

FlushAsync()

Asynchronně vyprázdní vše, co je ve vyrovnávací paměti, na podkladové datové proudy a také vyprázdní podkladový datový proud.Asynchronously flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

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)
LookupPrefix(String)

Při přepsání v odvozené třídě vrátí nejbližší předponu, která je definována v aktuálním oboru názvů pro identifikátor URI oboru názvů.When overridden in a derived class, returns the closest prefix defined in the current namespace scope for the namespace URI.

MemberwiseClone()

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

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

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

(Zděděno od Object)
WriteAttributes(XmlReader, Boolean)

Při přepsání v odvozené třídě zapíše všechny atributy nalezené na aktuální pozici v XmlReader .When overridden in a derived class, writes out all the attributes found at the current position in the XmlReader.

WriteAttributesAsync(XmlReader, Boolean)

Asynchronně zapisuje všechny atributy nalezené na aktuální pozici v XmlReader .Asynchronously writes out all the attributes found at the current position in the XmlReader.

WriteAttributeString(String, String)

Při přepsání v odvozené třídě zapíše atribut se zadaným místním názvem a hodnotou.When overridden in a derived class, writes out the attribute with the specified local name and value.

WriteAttributeString(String, String, String)

Při přepsání v odvozené třídě zapíše atribut se zadaným místním názvem, identifikátorem URI oboru názvů a hodnotou.When overridden in a derived class, writes an attribute with the specified local name, namespace URI, and value.

WriteAttributeString(String, String, String, String)

Při přepsání v odvozené třídě zapíše atribut se zadanou předponou, místním názvem, identifikátorem URI oboru názvů a hodnotou.When overridden in a derived class, writes out the attribute with the specified prefix, local name, namespace URI, and value.

WriteAttributeStringAsync(String, String, String, String)

Asynchronně zapisuje atribut se zadanou předponou, místním názvem, identifikátorem URI oboru názvů a hodnotou.Asynchronously writes out the attribute with the specified prefix, local name, namespace URI, and value.

WriteBase64(Byte[], Int32, Int32)

Při přepsání v odvozené třídě kódování zadaných binárních bajtů jako base64 a zapisuje výsledný text.When overridden in a derived class, encodes the specified binary bytes as Base64 and writes out the resulting text.

WriteBase64Async(Byte[], Int32, Int32)

Asynchronně zakóduje zadané binární bajty jako base64 a zapisuje výsledný text.Asynchronously encodes the specified binary bytes as Base64 and writes out the resulting text.

WriteBinHex(Byte[], Int32, Int32)

Při přepsání v odvozené třídě zakóduje zadané binární bajty jako BinHex a zapisuje výsledný text.When overridden in a derived class, encodes the specified binary bytes as BinHex and writes out the resulting text.

WriteBinHexAsync(Byte[], Int32, Int32)

Asynchronně zakóduje zadané binární bajty jako BinHex a zapisuje výsledný text.Asynchronously encodes the specified binary bytes as BinHex and writes out the resulting text.

WriteCData(String)

Při přepsání v odvozené třídě zapíše a < ! [ CDATA [...]] > blok obsahující zadaný textWhen overridden in a derived class, writes out a <![CDATA[...]]> block containing the specified text.

WriteCDataAsync(String)

Asynchronně zapisuje do < ! [ CDATA [...]] > blok obsahující zadaný textAsynchronously writes out a <![CDATA[...]]> block containing the specified text.

WriteCharEntity(Char)

Při přepsání v odvozené třídě vynutí generování znakové entity pro zadanou hodnotu znaku Unicode.When overridden in a derived class, forces the generation of a character entity for the specified Unicode character value.

WriteCharEntityAsync(Char)

Asynchronně vynutí generování znakové entity pro zadanou hodnotu znaku Unicode.Asynchronously forces the generation of a character entity for the specified Unicode character value.

WriteChars(Char[], Int32, Int32)

Při přepsání v odvozené třídě zapisuje text v jednu vyrovnávací paměť.When overridden in a derived class, writes text one buffer at a time.

WriteCharsAsync(Char[], Int32, Int32)

Asynchronně zapisuje současně textovou vyrovnávací paměť.Asynchronously writes text one buffer at a time.

WriteComment(String)

Při přepsání v odvozené třídě zapíše komentář < !--...-- > obsahující zadaný text.When overridden in a derived class, writes out a comment <!--...--> containing the specified text.

WriteCommentAsync(String)

Asynchronně zapisuje komentář < !--...-- > obsahující zadaný text.Asynchronously writes out a comment <!--...--> containing the specified text.

WriteDocType(String, String, String, String)

Při přepsání v odvozené třídě zapíše deklaraci DOCTYPE se zadaným názvem a nepovinnými atributy.When overridden in a derived class, writes the DOCTYPE declaration with the specified name and optional attributes.

WriteDocTypeAsync(String, String, String, String)

Asynchronně zapisuje deklaraci DOCTYPE se zadaným názvem a volitelnými atributy.Asynchronously writes the DOCTYPE declaration with the specified name and optional attributes.

WriteElementString(String, String)

Zapíše element se zadaným místním názvem a hodnotou.Writes an element with the specified local name and value.

WriteElementString(String, String, String)

Zapíše element se zadaným místním názvem, identifikátorem URI oboru názvů a hodnotou.Writes an element with the specified local name, namespace URI, and value.

WriteElementString(String, String, String, String)

Zapíše element se zadanou předponou, místním názvem, identifikátorem URI oboru názvů a hodnotou.Writes an element with the specified prefix, local name, namespace URI, and value.

WriteElementStringAsync(String, String, String, String)

Asynchronně zapisuje element se zadanou předponou, místním názvem, identifikátorem URI oboru názvů a hodnotou.Asynchronously writes an element with the specified prefix, local name, namespace URI, and value.

WriteEndAttribute()

Při přepsání v odvozené třídě zavře předchozí WriteStartAttribute(String, String) volání.When overridden in a derived class, closes the previous WriteStartAttribute(String, String) call.

WriteEndAttributeAsync()

Asynchronně zavře předchozí WriteStartAttribute(String, String) volání.Asynchronously closes the previous WriteStartAttribute(String, String) call.

WriteEndDocument()

Při přepsání v odvozené třídě zavře všechny otevřené prvky nebo atributy a vloží zapisovač zpátky do počátečního stavu.When overridden in a derived class, closes any open elements or attributes and puts the writer back in the Start state.

WriteEndDocumentAsync()

Asynchronně uzavře všechny otevřené prvky nebo atributy a vloží zapisovač zpátky do počátečního stavu.Asynchronously closes any open elements or attributes and puts the writer back in the Start state.

WriteEndElement()

Při přepsání v odvozené třídě zavře jeden element a napředá odpovídající obor názvů.When overridden in a derived class, closes one element and pops the corresponding namespace scope.

WriteEndElementAsync()

Asynchronně uzavře jeden element a zapop odpovídající obor názvů.Asynchronously closes one element and pops the corresponding namespace scope.

WriteEntityRef(String)

Při přepsání v odvozené třídě zapíše odkaz na entitu jako &name; .When overridden in a derived class, writes out an entity reference as &name;.

WriteEntityRefAsync(String)

Asynchronně zapisuje odkaz na entitu jako &name; .Asynchronously writes out an entity reference as &name;.

WriteFullEndElement()

Při přepsání v odvozené třídě zavře jeden element a napředá odpovídající obor názvů.When overridden in a derived class, closes one element and pops the corresponding namespace scope.

WriteFullEndElementAsync()

Asynchronně uzavře jeden element a zapop odpovídající obor názvů.Asynchronously closes one element and pops the corresponding namespace scope.

WriteName(String)

Při přepsání v odvozené třídě zapisuje zadaný název, který zajišťuje, že se jedná o platný název podle doporučení W3C XML 1,0 ( https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name) .When overridden in a derived class, writes out the specified name, ensuring it is a valid name according to the W3C XML 1.0 recommendation (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name).

WriteNameAsync(String)

Asynchronně zapisuje zadaný název, který zajišťuje, že se jedná o platný název podle doporučení W3C XML 1,0 ( https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name) .Asynchronously writes out the specified name, ensuring it is a valid name according to the W3C XML 1.0 recommendation (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name).

WriteNmToken(String)

Při přepsání v odvozené třídě zapisuje zadaný název, který zajišťuje, že se jedná o platný NmToken podle doporučení W3C XML 1,0 ( https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name) .When overridden in a derived class, writes out the specified name, ensuring it is a valid NmToken according to the W3C XML 1.0 recommendation (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name).

WriteNmTokenAsync(String)

Asynchronně zapisuje zadaný název, který zajišťuje, že se jedná o platný NmToken podle doporučení W3C XML 1,0 ( https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name) .Asynchronously writes out the specified name, ensuring it is a valid NmToken according to the W3C XML 1.0 recommendation (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name).

WriteNode(XmlReader, Boolean)

Při přepsání v odvozené třídě zkopíruje vše z čtecího zařízení do zapisovače a přesune čtecí modul na začátek další položky na stejné úrovni.When overridden in a derived class, copies everything from the reader to the writer and moves the reader to the start of the next sibling.

WriteNode(XPathNavigator, Boolean)

Zkopíruje vše z XPathNavigator objektu do zapisovače.Copies everything from the XPathNavigator object to the writer. Pozice XPathNavigator zůstane beze změny.The position of the XPathNavigator remains unchanged.

WriteNodeAsync(XmlReader, Boolean)

Asynchronně zkopíruje vše z čtecího zařízení do zapisovače a přesune čtenáře na začátek další stejné úrovně na stejné úrovni.Asynchronously copies everything from the reader to the writer and moves the reader to the start of the next sibling.

WriteNodeAsync(XPathNavigator, Boolean)

Asynchronně zkopíruje vše z XPathNavigator objektu do zapisovače.Asynchronously copies everything from the XPathNavigator object to the writer. Pozice XPathNavigator zůstane beze změny.The position of the XPathNavigator remains unchanged.

WriteProcessingInstruction(String, String)

Při přepsání v odvozené třídě zapíše instrukce pro zpracování s mezerou mezi názvem a textem následujícím způsobem: < ? text názvu? > .When overridden in a derived class, writes out a processing instruction with a space between the name and text as follows: <?name text?>.

WriteProcessingInstructionAsync(String, String)

Asynchronně zapisuje instrukci zpracování s mezerou mezi názvem a textem následujícím způsobem: < ? text názvu? > .Asynchronously writes out a processing instruction with a space between the name and text as follows: <?name text?>.

WriteQualifiedName(String, String)

Při přepsání v odvozené třídě vypíše název kvalifikovaný obor názvů.When overridden in a derived class, writes out the namespace-qualified name. Tato metoda vyhledá předponu, která je v oboru pro daný obor názvů.This method looks up the prefix that is in scope for the given namespace.

WriteQualifiedNameAsync(String, String)

Asynchronně zapisuje název kvalifikovaný obor názvů.Asynchronously writes out the namespace-qualified name. Tato metoda vyhledá předponu, která je v oboru pro daný obor názvů.This method looks up the prefix that is in scope for the given namespace.

WriteRaw(Char[], Int32, Int32)

Při přepsání v odvozené třídě zapisuje nezpracované označení ručně z vyrovnávací paměti znaků.When overridden in a derived class, writes raw markup manually from a character buffer.

WriteRaw(String)

Při přepsání v odvozené třídě zapisuje nezpracované označení ručně z řetězce.When overridden in a derived class, writes raw markup manually from a string.

WriteRawAsync(Char[], Int32, Int32)

Asynchronně zapisuje nezpracované označení ručně z vyrovnávací paměti znaků.Asynchronously writes raw markup manually from a character buffer.

WriteRawAsync(String)

Asynchronně zapisuje nezpracované označení ručně z řetězce.Asynchronously writes raw markup manually from a string.

WriteStartAttribute(String)

Zapíše začátek atributu se zadaným místním názvem.Writes the start of an attribute with the specified local name.

WriteStartAttribute(String, String)

Zapíše začátek atributu se zadaným místním názvem a identifikátorem URI oboru názvů.Writes the start of an attribute with the specified local name and namespace URI.

WriteStartAttribute(String, String, String)

Při přepsání v odvozené třídě zapíše začátek atributu se zadanou předponou, místním názvem a identifikátorem URI oboru názvů.When overridden in a derived class, writes the start of an attribute with the specified prefix, local name, and namespace URI.

WriteStartAttributeAsync(String, String, String)

Asynchronně zapisuje začátek atributu se zadanou předponou, místním názvem a identifikátorem URI oboru názvů.Asynchronously writes the start of an attribute with the specified prefix, local name, and namespace URI.

WriteStartDocument()

Při přepsání v odvozené třídě zapíše deklaraci XML s verzí "1,0".When overridden in a derived class, writes the XML declaration with the version "1.0".

WriteStartDocument(Boolean)

Při přepsání v odvozené třídě zapíše deklaraci XML s verzí "1,0" a samostatný atribut.When overridden in a derived class, writes the XML declaration with the version "1.0" and the standalone attribute.

WriteStartDocumentAsync()

Asynchronně zapisuje deklaraci XML s verzí "1,0".Asynchronously writes the XML declaration with the version "1.0".

WriteStartDocumentAsync(Boolean)

Asynchronně zapisuje deklaraci XML do verze "1,0" a samostatného atributu.Asynchronously writes the XML declaration with the version "1.0" and the standalone attribute.

WriteStartElement(String)

Při přepsání v odvozené třídě zapíše počáteční značku se zadaným místním názvem.When overridden in a derived class, writes out a start tag with the specified local name.

WriteStartElement(String, String)

Při přepsání v odvozené třídě zapíše zadanou počáteční značku a přidruží ji k danému oboru názvů.When overridden in a derived class, writes the specified start tag and associates it with the given namespace.

WriteStartElement(String, String, String)

Při přepsání v odvozené třídě zapíše zadanou počáteční značku a přidruží ji k danému oboru názvů a předponu.When overridden in a derived class, writes the specified start tag and associates it with the given namespace and prefix.

WriteStartElementAsync(String, String, String)

Asynchronně zapíše zadanou počáteční značku a přidruží ji k danému oboru názvů a předponu.Asynchronously writes the specified start tag and associates it with the given namespace and prefix.

WriteString(String)

Při přepsání v odvozené třídě zapíše daný textový obsah.When overridden in a derived class, writes the given text content.

WriteStringAsync(String)

Asynchronně zapisuje daný textový obsah.Asynchronously writes the given text content.

WriteSurrogateCharEntity(Char, Char)

Při přepsání v odvozené třídě vygeneruje a zapíše entitu náhradních znaků pro dvojici náhradních znaků.When overridden in a derived class, generates and writes the surrogate character entity for the surrogate character pair.

WriteSurrogateCharEntityAsync(Char, Char)

Asynchronně generuje a zapisuje entitu náhradního znaku pro dvojici náhradních znaků.Asynchronously generates and writes the surrogate character entity for the surrogate character pair.

WriteValue(Boolean)

Zapíše Boolean hodnotu.Writes a Boolean value.

WriteValue(DateTime)

Zapíše DateTime hodnotu.Writes a DateTime value.

WriteValue(DateTimeOffset)

Zapíše DateTimeOffset hodnotu.Writes a DateTimeOffset value.

WriteValue(Decimal)

Zapíše Decimal hodnotu.Writes a Decimal value.

WriteValue(Double)

Zapíše Double hodnotu.Writes a Double value.

WriteValue(Int32)

Zapíše Int32 hodnotu.Writes a Int32 value.

WriteValue(Int64)

Zapíše Int64 hodnotu.Writes a Int64 value.

WriteValue(Object)

Zapíše hodnotu objektu.Writes the object value.

WriteValue(Single)

Zapisuje číslo s plovoucí desetinnou čárkou s jednoduchou přesností.Writes a single-precision floating-point number.

WriteValue(String)

Zapíše String hodnotu.Writes a String value.

WriteWhitespace(String)

Při přepsání v odvozené třídě zapisuje dané prázdné znaky.When overridden in a derived class, writes out the given white space.

WriteWhitespaceAsync(String)

Asynchronně zapisuje dané prázdné znaky.Asynchronously writes out the given white space.

Explicitní implementace rozhraní

IDisposable.Dispose()

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

Metody rozšíření

ConfigureAwait(IAsyncDisposable, Boolean)

Konfiguruje, jak se provádí funkce await u úloh vrácených z asynchronního použití.Configures how awaits on the tasks returned from an async disposable are performed.

Platí pro