XmlWriter Klasse

Definition

Stellt einen Writer für die schnelle, vorwärts gerichtete Generierung von Streams oder Dateien mit XML-Daten ohne Zwischenspeicherung dar.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 abstract class XmlWriter : IDisposable
type XmlWriter = class
    interface IDisposable
Public MustInherit Class XmlWriter
Implements IDisposable
Vererbung
XmlWriter
Abgeleitet
Implementiert

Beispiele

Der folgende Beispielcode zeigt, wie die asynchrone API zum Generieren von XML verwendet wird.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();  
    }  
}  

Hinweise

Die XmlWriter -Klasse schreibt XML-Daten in einen Stream, eine Datei, einen Text Reader oder eine Zeichenfolge.The XmlWriter class writes XML data to a stream, file, text reader, or string. Sie unterstützt die Empfehlungen W3C Extensible Markup Language (XML) 1,0 (Fourth Edition) und Namespaces in XML 1,0 (dritte Edition) .It supports the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and Namespaces in XML 1.0 (third edition) recommendations.

Die Member der XmlWriter -Klasse ermöglichen Folgendes:The members of the XmlWriter class enable you to:

  • Überprüfen, ob die Zeichen zulässige XML-Zeichen sind, und ob Element- und Attributnamen gültige XML-Namen sind.Verify that the characters are legal XML characters and that element and attribute names are valid XML names.

  • Überprüfen, ob das XML-Dokument wohlgeformt ist.Verify that the XML document is well-formed.

  • Codiert binäre Bytes als Base64 oder BinHex und schreibt den resultierenden Text.Encode binary bytes as Base64 or BinHex, and write out the resulting text.

  • Übergeben Sie Werte mithilfe von Common Language Runtime Typen anstelle von Zeichen folgen, um die manuelle Durchführung von Wert Konvertierungen zu vermeiden.Pass values by using common language runtime types instead of strings, to avoid having to manually perform value conversions.

  • Mehrere Dokumente in einen Ausgabestream schreiben.Write multiple documents to one output stream.

  • Gültige Namen, qualifizierte Namen und Namenstoken schreiben.Write valid names, qualified names, and name tokens.

In diesem AbschnittIn this section:

Erstellen eines XML-Writers Creating an XML writer
Angeben des Ausgabeformats Specifying the output format
Daten Konformität Data conformance
Schreiben von Elementen Writing elements
Schreiben von Attributen Writing attributes
Verarbeiten von Namespaces Handling namespaces
Schreiben von typisierten Daten Writing typed data
Schließen des XML-Writers Closing the XML writer
Asynchrone Programmierung Asynchronous programming
Überlegungen zur SicherheitSecurity considerations

Erstellen eines XML-WritersCreating an XML writer

Verwenden Sie die XmlWriter XmlWriter.Create -Methode, um eine Instanz von zu erstellen.To create an XmlWriter instance, use the XmlWriter.Create method. Um den Satz von Features anzugeben, den Sie für den XML-Writer aktivieren möchten, XmlWriterSettings übergeben Sie Create ein an die-Methode.To specify the set of features you want to enable on the XML writer, pass an XmlWriterSettings to the Create method. Andernfalls werden die Standardeinstellungen verwendet.Otherwise, default settings are used. Weitere Informationen Create finden Sie auf den Referenzseiten.See the Create reference pages for details.

Angeben des AusgabeformatsSpecifying the output format

Die XmlWriterSettings -Klasse umfasst mehrere Eigenschaften, die XmlWriter die Formatierung der Ausgabe steuern:The XmlWriterSettings class includes several properties that control how XmlWriter output is formatted:

EigenschaftProperty BeschreibungDescription
Encoding Gibt die zu verwendende Textcodierung an.Specifies the text encoding to use. Die Standardeinstellung ist Encoding.UTF8.The default is Encoding.UTF8.
Indent Gibt an, ob Elemente eingerückt werden.Indicates whether to indent elements. Der Standardwert false ist (kein Einzug).The default is false (no indentation).
IndentChars Gibt die für das Einrücken zu verwendende Zeichenfolge an.Specifies the character string to use when indenting. Der Standard beträgt zwei Leerzeichen.The default is two spaces.
NewLineChars Gibt die für Zeilenumbrüche zu verwendende Zeichenfolge an.Specifies the character string to use for line breaks. Der Standard ist \r\n (Wagenrücklauf, Zeilenvorschub).The default is \r\n (carriage return, line feed).
NewLineHandling Gibt an, wie Zeilen Zeilenzeichen behandelt werden.Specifies how to handle newline characters.
NewLineOnAttributes Gibt an, ob Attribute in einer neuen Zeile geschrieben werden sollen.Indicates whether to write attributes on a new line. Indent muss auf true festgelegt sein, wenn diese Eigenschaft verwendet wird.Indent should be set to true when using this property. Die Standardeinstellung ist false.The default is false.
OmitXmlDeclaration Gibt an, ob eine XML-Deklaration geschrieben werden soll.Indicates whether to write an XML declaration. Die Standardeinstellung ist false.The default is false.

Die Indent-Eigenschaft und die IndentChars-Eigenschaft steuern die Formatierung von nicht signifikantem Leerraum.The Indent and IndentChars properties control how insignificant white space is formatted. So können Sie z. b. Elementknoten einziehen: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)

NewLineOnAttributes Verwenden Sie, um jedes Attribut in einer neuen Zeile mit einer zusätzlichen Einzugs Ebene zu schreiben: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)

Daten KonformitätData conformance

Ein XML-Writer verwendet zwei Eigenschaften der XmlWriterSettings -Klasse, um die Daten Konformität zu überprüfen:An XML writer uses two properties from the XmlWriterSettings class to check for data conformance:

  • Die CheckCharacters -Eigenschaft weist den XML-Writer an, Zeichen zu über XmlException prüfen und eine Ausnahme auszulösen, wenn Zeichen außerhalb des zulässigen Bereichs liegen, wie vom W3C definiert.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.

  • Die ConformanceLevel -Eigenschaft konfiguriert den XML-Writer, um zu überprüfen, ob der geschriebene Stream den Regeln für ein wohl geformtes XML 1,0-Dokument oder-Dokument Fragment entspricht, wie vom W3C definiert.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. Die drei Konformitätsstufen werden in der folgenden Tabelle beschrieben.The three conformance levels are described in the following table. Die Standardeinstellung ist Document.The default is Document. Weitere Informationen finden Sie unter XmlWriterSettings.ConformanceLevel der-Eigenschaft System.Xml.ConformanceLevel und der-Enumeration.For details, see the XmlWriterSettings.ConformanceLevel property and the System.Xml.ConformanceLevel enumeration.

    EbeneLevel BeschreibungDescription
    Document Die XML-Ausgabe entspricht den Regeln für ein wohl geformtes XML 1,0-Dokument und kann von jedem konformen Prozessor verarbeitet werden.The XML output conforms to the rules for a well-formed XML 1.0 document and can be processed by any conforming processor.
    Fragment Die XML-Ausgabe entspricht den Regeln für ein wohl geformtes XML 1,0-Dokument Fragment.The XML output conforms to the rules for a well-formed XML 1.0 document fragment.
    Auto Der XML-Writer bestimmt basierend auf den eingehenden Daten, welche Ebene der Überprüfung der Überprüfung (Dokument oder Fragment) angewendet werden soll.The XML writer determines which level of conformation checking to apply (document or fragment) based on the incoming data.

Schreiben von ElementenWriting elements

Sie können die folgenden XmlWriter Methoden verwenden, um Elementknoten zu schreiben.You can use the following XmlWriter methods to write element nodes. Beispiele finden Sie in den aufgeführten Methoden.For examples, see the methods listed.

VerwendungUse BeschreibungTo
WriteElementString Schreiben eines gesamten Element Knotens, einschließlich eines Zeichen folgen Werts.Write an entire element node, including a string value.
WriteStartElement Zum Schreiben eines Element Werts mithilfe mehrerer Methodenaufrufe.To write an element value by using multiple method calls. Beispielsweise können Sie WriteValue aufrufen, um einen typisierten Wert zu schreiben, WriteCharEntity, um eine Zeichenentität zu schreiben, WriteAttributeString, um ein Attribut zu schreiben, oder Sie können ein untergeordnetes Element schreiben.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. Dies ist eine anspruchsvollere Version der WriteElementString -Methode.This is a more sophisticated version of the WriteElementString method.

Um das Element zu schließen, wird die WriteEndElement - WriteFullEndElement Methode oder die-Methode aufgerufen.To close the element, you call the WriteEndElement or WriteFullEndElement method.
WriteNode , Um einen Elementknoten zu kopieren, der an der aktuellen XmlReader Position XPathNavigator eines-oder-Objekts gefunden wurde.To copy an element node found at the current position of an XmlReader or XPathNavigator object. Beim einem Aufruf werden alle Daten aus dem Quellobjekt in die XmlWriter-Instanz kopiert.When called, it copies everything from the source object to the XmlWriter instance.

Schreiben von AttributenWriting attributes

Sie können die folgenden XmlWriter Methoden verwenden, um Attribute auf Elementknoten zu schreiben.You can use the following XmlWriter methods to write attributes on element nodes. Diese Methoden können auch verwendet werden, um Namespace Deklarationen für ein Element zu erstellen, wie im nächsten Abschnitt erläutert.These methods can also be used to create namespace declarations on an element, as discussed in the next section.

VerwendungUse BeschreibungTo
WriteAttributeString Zum Schreiben eines vollständigen Attribut Knotens einschließlich eines Zeichen folgen Werts.To write an entire attribute node, including a string value.
WriteStartAttribute Zum Schreiben des Attribut Werts mithilfe mehrerer Methodenaufrufe.To write the attribute value using multiple method calls. Beispielsweise können Sie aufzurufen WriteValue , um einen typisierten Wert zu schreiben.For example, you can call WriteValue to write a typed value. Dies ist eine anspruchsvollere Version der WriteElementString -Methode.This is a more sophisticated version of the WriteElementString method.

Um das-Element zu schließen, wird WriteEndAttribute die-Methode aufgerufen.To close the element, you call the WriteEndAttribute method.
WriteAttributes , Um alle Attribute zu kopieren, die an der aktuellen Position XmlReader eines Objekts gefunden wurden.To copy all the attributes found at the current position of an XmlReader object. Welche Attribute geschrieben werden, hängt vom Typ des Knotens ab, auf dem der Reader derzeit positioniert ist:The attributes that are written depend on the type of node the reader is currently positioned on:

-Bei einem Attribut Knoten werden das aktuelle Attribut und anschließend die restlichen Attribute bis zum schließenden Tag des Elements geschrieben.- For an attribute node, it writes the current attribute, and then the rest of the attributes until the element closing tag.
-Für einen Elementknoten werden alle Attribute geschrieben, die im-Element enthalten sind.- For an element node, it writes all attributes contained by the element.
-Bei einem XML-Deklarations Knoten werden alle Attribute in der Deklaration geschrieben.- For an XML declaration node, it writes all the attributes in the declaration.
-Für alle anderen Knoten Typen löst die Methode eine Ausnahme aus.- For all other node types, the method throws an exception.

Verarbeiten von NamespacesHandling namespaces

Mit Namespaces werden Element- und Attributnamen in XML-Dokumenten qualifiziert.Namespaces are used to qualify element and attribute names in an XML document. Namespace Präfixe ordnen Elemente und Attribute Namespaces zu, die wiederum mit URI-verweisen verknüpft sind.Namespace prefixes associate elements and attributes with namespaces, which are in turn associated with URI references. Namespaces gewährleisten eindeutige Element- und Attributnamen in einem XML-Dokument.Namespaces create element and attribute name uniqueness in an XML document.

Verwaltet XmlWriter einen Namespace Stapel, der allen im aktuellen Namespace Bereich definierten Namespaces entspricht.The XmlWriter maintains a namespace stack that corresponds to all the namespaces defined in the current namespace scope. Beim Schreiben von Elementen und Attributen können Sie Namespaces für folgende Aufgaben verwenden:When writing elements and attributes you can utilize namespaces in the following ways:

  • Deklarieren Sie Namespaces manuell, WriteAttributeString indem Sie die-Methode verwenden.Declare namespaces manually by using the WriteAttributeString method. Dies kann hilfreich sein, wenn Sie wissen, wie die Anzahl der Namespacedeklarationen optimiert werden kann.This can be useful when you know how to best optimize the number of namespace declarations. Ein Beispiel finden Sie unter der WriteAttributeString(String, String, String, String) -Methode.For an example, see the WriteAttributeString(String, String, String, String) method.

  • Überschreiben der aktuellen Namespacedeklaration mit einem neuen Namespace.Override the current namespace declaration with a new namespace. Im folgenden WriteAttributeString Code ändert die-Methode den Namespace-URI für das "x" Präfix von "abc" "123" in.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()
    

    Der Code generiert die folgende XML-Zeichenfolge:The code generates the following XML string:

    <x:root xmlns:x="123">  
      <item xmlns:x="abc" />  
    </x:root>  
    
  • Angeben eines Namespacepräfixes beim Schreiben von Attributen oder Elementen.Specify a namespace prefix when writing attributes or elements. Viele der Methoden, mit denen Elemente und Attribute geschrieben werden, ermöglichen es Ihnen, dies zu tun.Many of the methods used to write element and attributes enable you to do this. Die WriteStartElement(String, String, String) -Methode schreibt z. b. ein Starttag und ordnet es einem angegebenen Namespace und Präfix zu.For example, the WriteStartElement(String, String, String) method writes a start tag and associates it with a specified namespace and prefix.

Schreiben von typisierten DatenWriting typed data

Die WriteValue -Methode akzeptiert ein Common Language Runtime (CLR)-Objekt, konvertiert den Eingabe Wert gemäß den Datentyp-Konvertierungsregeln der XML-Schema Definitions Sprache (XSD) in seine Zeichen folgen Darstellung und WriteString schreibt ihn mithilfe der-Methode.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. Dies ist einfacher als die Verwendung der Methoden in XmlConvert der-Klasse, um die typisierten Daten vor dem Schreiben in einen Zeichen folgen Wert zu konvertieren.This is easier than using the methods in the XmlConvert class to convert the typed data to a string value before writing it out.

Beim Schreiben in Text wird der typisierte Wert mit den XmlConvert Regeln für den Schematyp in Text serialisiert.When writing to text, the typed value is serialized to text by using the XmlConvert rules for that schema type.

Informationen zu XSD-Standard Datentypen, die CLR-Typen WriteValue entsprechen, finden Sie unter der-Methode.For default XSD data types that correspond to CLR types, see the WriteValue method.

XmlWriter Kann auch verwendet werden, um in einen XML-Datenspeicher zu schreiben.The XmlWriter can also be used to write to an XML data store. Die XPathNavigator-Klasse kann z. B. ein XmlWriter-Objekt erstellen, das Knoten für ein XmlDocument-Objekt erstellt.For example, the XPathNavigator class can create an XmlWriter object to create nodes for an XmlDocument object. Wenn dem Datenspeicher Schema Informationen zur Verfügung stehen, löst die WriteValue Methode eine Ausnahme aus, wenn Sie versuchen, eine Konvertierung in einen nicht zulässigen Typ auszuführen. Wenn dem Datenspeicher keine Schema Informationen zur Verfügung stehen, behandelt die WriteValue Methode alle Werte xsd:anySimpleType als Typ.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.If the data store does not have schema information available to it, the WriteValue method treats all values as an xsd:anySimpleType type.

Schließen des XML-WritersClosing the XML writer

Wenn Sie- XmlWriter Methoden verwenden, um XML auszugeben, werden die Elemente und Attribute erst geschrieben, wenn Close Sie die-Methode aufgerufen haben.When you use XmlWriter methods to output XML, the elements and attributes are not written until you call the Close method. Wenn Sie z. b. verwenden XmlWriter , um ein XmlDocument Objekt zu füllen, können Sie die geschriebenen Elemente und Attribute im Zieldokument erst sehen, wenn Sie die XmlWriter Instanz schließen.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.

Asynchrone ProgrammierungAsynchronous programming

Die meisten Methoden verfügen über asynchrone Entsprechungen, deren Methodennamen "Async" aufweisen. XmlWriterMost of the XmlWriter methods have asynchronous counterparts that have "Async" at the end of their method names. Beispielsweise ist WriteAttributeStringAsyncdie asynchrone Entsprechung WriteAttributeString von.For example, the asynchronous equivalent of WriteAttributeString is WriteAttributeStringAsync.

Konvertieren Sie WriteValue für die-Methode, die kein asynchrones Gegenstück hat, den Rückgabewert in eine Zeichen WriteStringAsync Folge, und verwenden Sie stattdessen die-Methode.For the WriteValue method, which doesn't have an asynchronous counterpart, convert the return value to a string and use the WriteStringAsync method instead.

SicherheitsüberlegungenSecurity considerations

Beachten Sie beim Arbeiten mit der XmlWriter -Klasse Folgendes:Consider the following when working with the XmlWriter class:

  • Von ausgelöste Ausnahmen XmlWriter können Pfadinformationen offenlegen, die nicht zur app hinzugefügt werden sollen.Exceptions thrown by the XmlWriter can disclose path information that you do not want bubbled up to the app. Ihre APP muss Ausnahmen abfangen und entsprechend verarbeiten.Your app must catch exceptions and process them appropriately.

  • XmlWriterüberprüft keine Daten, die an die-Methode oder WriteDocType WriteRaw die-Methode übermittelt werden.XmlWriter does not validate any data that is passed to the WriteDocType or WriteRaw method. Sie sollten keine beliebigen Daten an diese Methoden übergeben.You should not pass arbitrary data to these methods.

Konstruktoren

XmlWriter()

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

Eigenschaften

Settings

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

WriteState

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

XmlLang

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

XmlSpace

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

Methoden

Close()

Schließt beim Überschreiben in einer abgeleiteten Klasse diesen Stream und den zugrunde liegenden Stream.When overridden in a derived class, closes this stream and the underlying stream.

Create(Stream)

Erstellt eine neue XmlWriter-Instanz mit dem angegebenen Stream.Creates a new XmlWriter instance using the specified stream.

Create(Stream, XmlWriterSettings)

Erstellt eine neue XmlWriter-Instanz mit dem Stream und dem XmlWriterSettings-Objekt.Creates a new XmlWriter instance using the stream and XmlWriterSettings object.

Create(String)

Erstellt eine neue XmlWriter-Instanz mit dem angegebenen Dateinamen.Creates a new XmlWriter instance using the specified filename.

Create(String, XmlWriterSettings)

Erstellt eine neue XmlWriter-Instanz mit dem Dateinamen und dem XmlWriterSettings-Objekt.Creates a new XmlWriter instance using the filename and XmlWriterSettings object.

Create(StringBuilder)

Erstellt mit dem angegebenen XmlWriter eine neue StringBuilder-Instanz.Creates a new XmlWriter instance using the specified StringBuilder.

Create(StringBuilder, XmlWriterSettings)

Erstellt mit dem XmlWriter-Objekt und dem StringBuilder-Objekt eine neue XmlWriterSettings-Instanz.Creates a new XmlWriter instance using the StringBuilder and XmlWriterSettings objects.

Create(TextWriter)

Erstellt mit dem angegebenen XmlWriter eine neue TextWriter-Instanz.Creates a new XmlWriter instance using the specified TextWriter.

Create(TextWriter, XmlWriterSettings)

Erstellt mit dem XmlWriter-Objekt und dem TextWriter-Objekt eine neue XmlWriterSettings-Instanz.Creates a new XmlWriter instance using the TextWriter and XmlWriterSettings objects.

Create(XmlWriter)

Erstellt eine neue XmlWriter-Instanz mit dem angegebenen XmlWriter-Objekt.Creates a new XmlWriter instance using the specified XmlWriter object.

Create(XmlWriter, XmlWriterSettings)

Erstellt mit dem angegebenen XmlWriter-Objekt und dem angegebenen XmlWriter-Objekt eine neue XmlWriterSettings-Instanz.Creates a new XmlWriter instance using the specified XmlWriter and XmlWriterSettings objects.

Dispose()

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

Dispose(Boolean)

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

Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
Flush()

Entleert beim Überschreiben in einer abgeleiteten Klasse den Inhalt des Puffers in die zugrunde liegenden Streams und leert den zugrunde liegenden Stream ebenfalls.When overridden in a derived class, flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

FlushAsync()

Entleert den Pufferinhalt asynchron in die zugrunde liegenden Streams und entleert den zugrunde liegenden Stream ebenfalls.Asynchronously flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetType()

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

(Geerbt von Object)
LookupPrefix(String)

Gibt beim Überschreiben in einer abgeleiteten Klasse das nächstliegende Präfix zurück, das im aktuellen Namespacebereich für den Namespace-URI definiert ist.When overridden in a derived class, returns the closest prefix defined in the current namespace scope for the namespace URI.

MemberwiseClone()

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

(Geerbt von Object)
ToString()

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

(Geerbt von Object)
WriteAttributes(XmlReader, Boolean)

Schreibt beim Überschreiben in einer abgeleiteten Klasse sämtliche an der aktuellen Position gefundenen Attribute in den XmlReader.When overridden in a derived class, writes out all the attributes found at the current position in the XmlReader.

WriteAttributesAsync(XmlReader, Boolean)

Schreibt asynchron alle Attribute aus, die in der aktuellen Position in XmlReader gefunden werden.Asynchronously writes out all the attributes found at the current position in the XmlReader.

WriteAttributeString(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das Attribut mit dem angegebenen lokalen Namen und Wert.When overridden in a derived class, writes out the attribute with the specified local name and value.

WriteAttributeString(String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse ein Attribut mit dem angegebenen lokalen Namen, Namespace-URI und Wert.When overridden in a derived class, writes an attribute with the specified local name, namespace URI, and value.

WriteAttributeString(String, String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das Attribut mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.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)

Schreibt ein Attribut asynchron mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.Asynchronously writes out the attribute with the specified prefix, local name, namespace URI, and value.

WriteBase64(Byte[], Int32, Int32)

Codiert beim Überschreiben in einer abgeleiteten Klasse die angegebenen binären Bytes als Base64 und schreibt den resultierenden Text.When overridden in a derived class, encodes the specified binary bytes as Base64 and writes out the resulting text.

WriteBase64Async(Byte[], Int32, Int32)

Codiert die angegebenen binären Bytes asynchron als Base64 und schreibt den resultierenden Text.Asynchronously encodes the specified binary bytes as Base64 and writes out the resulting text.

WriteBinHex(Byte[], Int32, Int32)

Codiert beim Überschreiben in einer abgeleiteten Klasse die angegebenen binären Bytes als BinHex und schreibt den resultierenden Text.When overridden in a derived class, encodes the specified binary bytes as BinHex and writes out the resulting text.

WriteBinHexAsync(Byte[], Int32, Int32)

Codiert die angegebenen binären Bytes asynchron als BinHex und schreibt den resultierenden Text.Asynchronously encodes the specified binary bytes as BinHex and writes out the resulting text.

WriteCData(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse einen <![CDATA[...]]>-Block mit dem angegebenen Text.When overridden in a derived class, writes out a <![CDATA[...]]> block containing the specified text.

WriteCDataAsync(String)

Schreibt asynchron einen <![CDATA[...]]>-Block mit dem angegebenen Text.Asynchronously writes out a <![CDATA[...]]> block containing the specified text.

WriteCharEntity(Char)

Erzwingt beim Überschreiben in einer abgeleiteten Klasse die Generierung einer Zeichenentität für den angegebenen Wert eines Unicode-Zeichens.When overridden in a derived class, forces the generation of a character entity for the specified Unicode character value.

WriteCharEntityAsync(Char)

Erzwingt das Generieren einer Zeichenentität asynchron für den angegebenen Unicode-Zeichenwert.Asynchronously forces the generation of a character entity for the specified Unicode character value.

WriteChars(Char[], Int32, Int32)

Schreibt beim Überschreiben in einer abgeleiteten Klasse Text in jeweils einen Puffer.When overridden in a derived class, writes text one buffer at a time.

WriteCharsAsync(Char[], Int32, Int32)

Schreibt Text asynchron in jeweils einen Puffer.Asynchronously writes text one buffer at a time.

WriteComment(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den Kommentar <!--...--> mit dem angegebenen Text.When overridden in a derived class, writes out a comment <!--...--> containing the specified text.

WriteCommentAsync(String)

Schreibt asynchron einen Kommentar <!--...-->, der den angegebenen Text enthält.Asynchronously writes out a comment <!--...--> containing the specified text.

WriteDocType(String, String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse die DOCTYPE-Deklaration mit dem angegebenen Namen und optionalen Attributen.When overridden in a derived class, writes the DOCTYPE declaration with the specified name and optional attributes.

WriteDocTypeAsync(String, String, String, String)

Schreibt die DOCTYPE-Deklaration asynchron mit dem angegebenen Namen und optionalen Attributen.Asynchronously writes the DOCTYPE declaration with the specified name and optional attributes.

WriteElementString(String, String)

Schreibt ein Element mit dem angegebenen lokalen Namen und Wert.Writes an element with the specified local name and value.

WriteElementString(String, String, String)

Schreibt ein Element mit dem angegebenen lokalen Namen, Namespace-URI und Wert.Writes an element with the specified local name, namespace URI, and value.

WriteElementString(String, String, String, String)

Schreibt ein Element mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.Writes an element with the specified prefix, local name, namespace URI, and value.

WriteElementStringAsync(String, String, String, String)

Schreibt ein Element asynchron mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.Asynchronously writes an element with the specified prefix, local name, namespace URI, and value.

WriteEndAttribute()

Schließt beim Überschreiben in einer abgeleiteten Klasse den vorherigen WriteStartAttribute(String, String)-Aufruf.When overridden in a derived class, closes the previous WriteStartAttribute(String, String) call.

WriteEndAttributeAsync()

Schließt den asynchronen vorherigen WriteStartAttribute(String, String)-Aufruf.Asynchronously closes the previous WriteStartAttribute(String, String) call.

WriteEndDocument()

Schließt beim Überschreiben in einer abgeleiteten Klasse alle geöffneten Elemente oder Attribute und setzt den Writer in den Anfangszustand zurück.When overridden in a derived class, closes any open elements or attributes and puts the writer back in the Start state.

WriteEndDocumentAsync()

Schließt alle geöffneten Elemente oder Attribute asynchron und setzt den Writer in den Startzustand zurück.Asynchronously closes any open elements or attributes and puts the writer back in the Start state.

WriteEndElement()

Schließt beim Überschreiben in einer abgeleiteten Klasse ein Element und löst den entsprechenden Namespacebereich auf.When overridden in a derived class, closes one element and pops the corresponding namespace scope.

WriteEndElementAsync()

Schließt ein Element asynchron und löst den entsprechenden Namespacebereich auf.Asynchronously closes one element and pops the corresponding namespace scope.

WriteEntityRef(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse einen Entitätsverweis als &name;.When overridden in a derived class, writes out an entity reference as &name;.

WriteEntityRefAsync(String)

Schreibt einen Entitätsverweis asynchron als &name; aus.Asynchronously writes out an entity reference as &name;.

WriteFullEndElement()

Schließt beim Überschreiben in einer abgeleiteten Klasse ein Element und löst den entsprechenden Namespacebereich auf.When overridden in a derived class, closes one element and pops the corresponding namespace scope.

WriteFullEndElementAsync()

Schließt ein Element asynchron und löst den entsprechenden Namespacebereich auf.Asynchronously closes one element and pops the corresponding namespace scope.

WriteName(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den angegebenen Namen und stellt sicher, dass dieser gemäß der W3C-Empfehlung zu XML, Version 1.0 (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name), ein gültiger Name ist.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)

Schreibt den angegebenen Namen asynchron aus und prüft dessen Gültigkeit entsprechend der W3C-Empfehlung für XML, Version 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)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den angegebenen Namen und stellt sicher, dass dieser gemäß der W3C-Empfehlung zu XML, Version 1.0 (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name), ein gültiges NmToken ist.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)

Schreibt den angegebenen Namen asynchron aus und stellt sicher, dass dieser gemäß der W3C-Empfehlung für XML, Version 1.0 (https://www.w3.org/TR/1998/REC-xml-19980210#NT-Name), ein gültiges NmToken ist.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)

Kopiert beim Überschreiben in einer abgeleiteten Klasse den gesamten Inhalt des Readers in den Writer und verschiebt den Reader zum Anfang des nächsten nebengeordneten Elements.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)

Kopiert den gesamten Inhalt des XPathNavigator-Objekts in den Writer.Copies everything from the XPathNavigator object to the writer. Die Position des XPathNavigator bleibt unverändert.The position of the XPathNavigator remains unchanged.

WriteNodeAsync(XmlReader, Boolean)

Kopiert beim Überschreiben in einer abgeleiteten Klasse den gesamten Inhalt des Readers asynchron in den Writer und verschiebt den Reader zum Anfang des nächsten nebengeordneten Elements.Asynchronously copies everything from the reader to the writer and moves the reader to the start of the next sibling.

WriteNodeAsync(XPathNavigator, Boolean)

Kopiert asynchron den gesamten Inhalt des XPathNavigator-Objekt in den Writer.Asynchronously copies everything from the XPathNavigator object to the writer. Die Position des XPathNavigator bleibt unverändert.The position of the XPathNavigator remains unchanged.

WriteProcessingInstruction(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Verarbeitungsanweisung mit einem Leerzeichen zwischen dem Namen und dem Text wie folgt: <?name text?>.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)

Schreibt eine Verarbeitungsanweisung asynchron mit einem Leerzeichen zwischen dem Namen und dem Text wie folgt: <?name text?>.Asynchronously writes out a processing instruction with a space between the name and text as follows: <?name text?>.

WriteQualifiedName(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den durch den Namespace angegebenen Namen.When overridden in a derived class, writes out the namespace-qualified name. Diese Methode sucht das Präfix im Gültigkeitsbereich des Namespaces.This method looks up the prefix that is in scope for the given namespace.

WriteQualifiedNameAsync(String, String)

Schreibt den durch Namespace gekennzeichneten Namen asynchron.Asynchronously writes out the namespace-qualified name. Diese Methode sucht das Präfix im Gültigkeitsbereich des Namespaces.This method looks up the prefix that is in scope for the given namespace.

WriteRaw(Char[], Int32, Int32)

Schreibt beim Überschreiben in einer abgeleiteten Klasse Rohdatenmarkup manuell aus einem Zeichenpuffer.When overridden in a derived class, writes raw markup manually from a character buffer.

WriteRaw(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse Rohdatenmarkup manuell aus einer Zeichenfolge.When overridden in a derived class, writes raw markup manually from a string.

WriteRawAsync(Char[], Int32, Int32)

Schreibt asynchron unformatiertes Markup manuell aus einem Zeichenpuffer.Asynchronously writes raw markup manually from a character buffer.

WriteRawAsync(String)

Schreibt asynchron unformatiertes Markup manuell aus einer Zeichenfolge.Asynchronously writes raw markup manually from a string.

WriteStartAttribute(String)

Schreibt den Anfang eines Attributs mit dem angegebenen lokalen Namen.Writes the start of an attribute with the specified local name.

WriteStartAttribute(String, String)

Schreibt den Anfang eines Attributs mit dem angegebenen lokalen Namen und dem angegebenen Namespace-URI.Writes the start of an attribute with the specified local name and namespace URI.

WriteStartAttribute(String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den Anfang eines Attributs mit dem angegebenen Präfix, dem angegebenen lokalen Namen und dem angegebenen Namespace-URI.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)

Schreibt den Anfang eines Attributs asynchron mit dem angegebenen Präfix, lokalen Namen und Namespace-URI.Asynchronously writes the start of an attribute with the specified prefix, local name, and namespace URI.

WriteStartDocument()

Schreibt beim Überschreiben in einer abgeleiteten Klasse die XML-Deklaration mit der Version "1.0".When overridden in a derived class, writes the XML declaration with the version "1.0".

WriteStartDocument(Boolean)

Schreibt beim Überschreiben in einer abgeleiteten Klasse die XML-Deklaration mit der Version "1.0" und dem eigenständigen Attribut.When overridden in a derived class, writes the XML declaration with the version "1.0" and the standalone attribute.

WriteStartDocumentAsync()

Schreibt die XML-Deklaration asynchron mit der Version "1.0".Asynchronously writes the XML declaration with the version "1.0".

WriteStartDocumentAsync(Boolean)

Schreibt die XML-Deklaration asynchron mit der Version "1.0" und dem eigenständigen Attribut.Asynchronously writes the XML declaration with the version "1.0" and the standalone attribute.

WriteStartElement(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse ein Starttag mit dem angegebenen lokalen Namen.When overridden in a derived class, writes out a start tag with the specified local name.

WriteStartElement(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das angegebene Starttag und ordnet dieses dem angegebenen Namespace zu.When overridden in a derived class, writes the specified start tag and associates it with the given namespace.

WriteStartElement(String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das angegebene Starttag und ordnet dieses dem angegebenen Namespace und Präfix zu.When overridden in a derived class, writes the specified start tag and associates it with the given namespace and prefix.

WriteStartElementAsync(String, String, String)

Schreibt das angegebene Starttag asynchron und ordnet dieses dem angegebenen Namespace und Präfix zu.Asynchronously writes the specified start tag and associates it with the given namespace and prefix.

WriteString(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den angegebenen Textinhalt.When overridden in a derived class, writes the given text content.

WriteStringAsync(String)

Schreibt den angegebenen Textinhalt asynchron.Asynchronously writes the given text content.

WriteSurrogateCharEntity(Char, Char)

Generiert und schreibt beim Überschreiben in einer abgeleiteten Klasse die Ersatzzeichenentität für das Ersatzzeichenpaar.When overridden in a derived class, generates and writes the surrogate character entity for the surrogate character pair.

WriteSurrogateCharEntityAsync(Char, Char)

Generiert und schreibt die Ersatzzeichenentität asynchron für das Ersatzzeichenpaar.Asynchronously generates and writes the surrogate character entity for the surrogate character pair.

WriteValue(Boolean)

Schreibt einen Boolean-Wert.Writes a Boolean value.

WriteValue(DateTime)

Schreibt einen DateTime-Wert.Writes a DateTime value.

WriteValue(DateTimeOffset)

Schreibt einen DateTimeOffset-Wert.Writes a DateTimeOffset value.

WriteValue(Decimal)

Schreibt einen Decimal-Wert.Writes a Decimal value.

WriteValue(Double)

Schreibt einen Double-Wert.Writes a Double value.

WriteValue(Int32)

Schreibt einen Int32-Wert.Writes a Int32 value.

WriteValue(Int64)

Schreibt einen Int64-Wert.Writes a Int64 value.

WriteValue(Object)

Schreibt den Objektwert.Writes the object value.

WriteValue(Single)

Schreibt eine Gleitkommazahl mit einfacher Genauigkeit.Writes a single-precision floating-point number.

WriteValue(String)

Schreibt einen String-Wert.Writes a String value.

WriteWhitespace(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den angegebenen Leerraum.When overridden in a derived class, writes out the given white space.

WriteWhitespaceAsync(String)

Schreibt den angegebenen Leerraum asynchron.Asynchronously writes out the given white space.

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

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

Gilt für:

Siehe auch