XmlWriter Klasse

Definition

Stellt einen Writer für die schnelle, vorwärts gerichtete Generierung von Streams oder Dateien mit XML-Daten ohne Zwischenspeicherung dar.

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
Vererbung
XmlWriter
Abgeleitet
Implementiert

Beispiele

Der folgende Beispielcode zeigt, wie die asynchrone API zum Generieren von XML verwendet wird.

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 Datenstrom, eine Datei, einen Textleser oder eine Zeichenfolge. Es unterstützt die Empfehlungen für W3C Extensible Markup Language (XML) 1.0 (vierte Edition) und Namespaces in XML 1.0 (Dritte Edition).

Die Mitglieder der XmlWriter Klasse ermöglichen Folgendes:

  • Überprüfen, ob die Zeichen zulässige XML-Zeichen sind, und ob Element- und Attributnamen gültige XML-Namen sind.

  • Überprüfen, ob das XML-Dokument wohlgeformt ist.

  • Codieren Sie binäre Bytes als Base64 oder BinHex, und schreiben Sie den resultierenden Text aus.

  • Übergeben Sie Werte, indem Sie gängige Sprachlaufzeittypen anstelle von Zeichenfolgen verwenden, um zu vermeiden, dass Sie Wertkonvertierungen manuell ausführen müssen.

  • Mehrere Dokumente in einen Ausgabestream schreiben.

  • Gültige Namen, qualifizierte Namen und Namenstoken schreiben.

In diesem Abschnitt

Erstellen eines XML-Writers
Angeben des Ausgabeformats
Datenkonformität
Schreiben von Elementen
Schreiben von Attributen
Behandeln von Namespaces
Schreiben von typierten Daten
Schließen des XML-Writers
Asynchrone Programmierung
Überlegungen zur Sicherheit

Erstellen eines XML-Writers

Verwenden Sie die XmlWriter.Create Methode, um eine XmlWriter Instanz zu erstellen. Um den Satz von Features anzugeben, die Sie für den XML-Writer aktivieren möchten, übergeben Sie eine XmlWriterSettings an die Create Methode. Andernfalls werden Standardeinstellungen verwendet. Ausführliche Informationen finden Sie auf den Create Referenzseiten.

Angeben des Ausgabeformats

Die XmlWriterSettings Klasse enthält mehrere Eigenschaften, die steuern, wie XmlWriter die Ausgabe formatiert wird:

Eigenschaft Beschreibung
Encoding Gibt die zu verwendende Textcodierung an. Der Standardwert ist Encoding.UTF8.
Indent Gibt an, ob Elemente eingerückt werden. Der Standardwert ist false (kein Einzug).
IndentChars Gibt die für das Einrücken zu verwendende Zeichenfolge an. Der Standard beträgt zwei Leerzeichen.
NewLineChars Gibt die für Zeilenumbrüche zu verwendende Zeichenfolge an. Der Standard ist \r\n (Wagenrücklauf, Zeilenvorschub).
NewLineHandling Gibt an, wie Neuelinezeichen behandelt werden.
NewLineOnAttributes Gibt an, ob Attribute in einer neuen Zeile geschrieben werden sollen. Indent sollte festgelegt werden, true wenn diese Eigenschaft verwendet wird. Der Standardwert ist false.
OmitXmlDeclaration Gibt an, ob eine XML-Deklaration geschrieben werden soll. Der Standardwert ist false.

Die Indent-Eigenschaft und die IndentChars-Eigenschaft steuern die Formatierung von nicht signifikantem Leerraum. So können Sie beispielsweise Elementknoten einziehen:

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)

Verwenden Sie das NewLineOnAttributes Attribut, um jedes Attribut in einer neuen Zeile mit einer zusätzlichen Einzugsebene zu schreiben:

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)

Datenkonformität

Ein XML-Writer verwendet zwei Eigenschaften der XmlWriterSettings Klasse, um die Datenkonformität zu überprüfen:

  • Die CheckCharacters Eigenschaft weist den XML-Writer an, Zeichen zu überprüfen und eine XmlException Ausnahme zu auslösen, wenn alle Zeichen außerhalb des gesetzlichen Bereichs liegen, wie vom W3C definiert.

  • Die ConformanceLevel Eigenschaft konfiguriert den XML-Writer, um zu überprüfen, ob der geschriebene Datenstrom den Regeln für ein gut gebildetes XML 1.0-Dokument oder Dokumentfragment entspricht, wie vom W3C definiert. Die drei Konformitätsstufen werden in der folgenden Tabelle beschrieben. Der Standardwert ist Document. Ausführliche Informationen finden Sie in der XmlWriterSettings.ConformanceLevel Eigenschaft und der System.Xml.ConformanceLevel Enumeration.

    Ebene Beschreibung
    Document Die XML-Ausgabe entspricht den Regeln für ein gut gebildetes XML 1.0-Dokument und kann von jedem konformen Prozessor verarbeitet werden.
    Fragment Die XML-Ausgabe entspricht den Regeln für ein gut gebildetes XML 1.0-Dokumentfragment.
    Auto Der XML-Writer bestimmt, welche Konformitätsüberprüfungsebene (Dokument oder Fragment) basierend auf den eingehenden Daten angewendet werden soll.

Schreiben von Elementen

Sie können die folgenden XmlWriter Methoden verwenden, um Elementknoten zu schreiben. Beispiele finden Sie in den aufgeführten Methoden.

Verwendung Beschreibung
WriteElementString Schreiben Sie einen gesamten Elementknoten, einschließlich eines Zeichenfolgenwerts.
WriteStartElement So schreiben Sie einen Elementwert mithilfe mehrerer Methodenaufrufe. 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. Dies ist eine komplexere Version der WriteElementString Methode.

Um das Element zu schließen, rufen Sie die WriteEndElement Methode WriteFullEndElement auf.
WriteNode So kopieren Sie einen Elementknoten, der an der aktuellen Position eines Objekts XmlReader XPathNavigator gefunden wurde. Beim einem Aufruf werden alle Daten aus dem Quellobjekt in die XmlWriter-Instanz kopiert.

Schreiben von Attributen

Sie können die folgenden XmlWriter Methoden verwenden, um Attribute auf Elementknoten zu schreiben. Diese Methoden können auch verwendet werden, um Namespacedeklarationen für ein Element zu erstellen, wie im nächsten Abschnitt erläutert.

Verwendung Beschreibung
WriteAttributeString Zum Schreiben eines gesamten Attributknotens, einschließlich eines Zeichenfolgenwerts.
WriteStartAttribute So schreiben Sie den Attributwert mithilfe mehrerer Methodenaufrufe. Sie können beispielsweise aufrufen WriteValue , um einen typierten Wert zu schreiben. Dies ist eine komplexere Version der WriteElementString Methode.

Um das Element zu schließen, rufen Sie die WriteEndAttribute Methode auf.
WriteAttributes So kopieren Sie alle Attribute, die an der aktuellen Position eines XmlReader Objekts gefunden wurden. Die Attribute, die geschrieben werden, hängen vom Typ des Knotens ab, auf dem der Leser derzeit positioniert ist:

– Für einen Attributknoten schreibt er das aktuelle Attribut, und dann die restlichen Attribute, bis das Element schließende Tag.
– Für einen Elementknoten schreibt er alle Attribute, die vom Element enthalten sind.
- Für einen XML-Deklarationsknoten schreibt er alle Attribute in der Deklaration.
- Bei allen anderen Knotentypen löst die Methode eine Ausnahme aus.

Behandeln von Namespaces

Mit Namespaces werden Element- und Attributnamen in XML-Dokumenten qualifiziert. Namespacepräfixe ordnen Elemente und Attribute mit Namespaces zu, die wiederum URI-Verweise zugeordnet sind. Namespaces gewährleisten eindeutige Element- und Attributnamen in einem XML-Dokument.

Der XmlWriter Namespacestapel wird verwaltet, der allen namespaces entspricht, die im aktuellen Namespacebereich definiert sind. Beim Schreiben von Elementen und Attributen können Sie Namespaces für folgende Aufgaben verwenden:

  • Deklarieren Sie Namespaces manuell mithilfe der WriteAttributeString Methode. Dies kann hilfreich sein, wenn Sie wissen, wie die Anzahl der Namespacedeklarationen optimiert werden kann. Ein Beispiel finden Sie in der WriteAttributeString(String, String, String, String) Methode.

  • Überschreiben der aktuellen Namespacedeklaration mit einem neuen Namespace. Im folgenden Code ändert die WriteAttributeString Methode den Namespace-URI für das "x" Präfix von "123" in "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:

    <x:root xmlns:x="123">  
      <item xmlns:x="abc" />  
    </x:root>  
    
  • Angeben eines Namespacepräfixes beim Schreiben von Attributen oder Elementen. Viele der Methoden, die zum Schreiben von Elementen und Attributen verwendet werden, ermöglichen Ihnen dies. Die Methode schreibt z. B WriteStartElement(String, String, String) . ein Starttag und ordnet es einem angegebenen Namespace und Präfix zu.

Schreiben von typierten Daten

Die WriteValue Methode akzeptiert ein Common Language Runtime (CLR)-Objekt, konvertiert den Eingabewert in seine Zeichenfolgendarstellung entsprechend den XML-Schemadefinitionssprache (XSD)-Datentypkonvertierungsregeln und schreibt ihn mithilfe der WriteString Methode heraus. Dies ist einfacher als die Verwendung der Methoden in der XmlConvert Klasse, um die eingegebenen Daten in einen Zeichenfolgenwert zu konvertieren, bevor sie ausschreiben.

Beim Schreiben in Text wird der typisierte Wert mithilfe der XmlConvert Regeln für diesen Schematyp in Text serialisiert.

Standardmäßige XSD-Datentypen, die CLR-Typen entsprechen, finden Sie in der WriteValue Methode.

Dies XmlWriter kann auch verwendet werden, um in einen XML-Datenspeicher zu schreiben. Die XPathNavigator-Klasse kann z. B. ein XmlWriter-Objekt erstellen, das Knoten für ein XmlDocument-Objekt erstellt. Wenn der Datenspeicher über Schemainformationen verfügt, löst die WriteValue Methode eine Ausnahme aus, wenn Sie versuchen, in einen nicht zulässigen Typ zu konvertieren. Wenn der Datenspeicher keine Schemainformationen enthält, behandelt die WriteValue Methode alle Werte als xsd:anySimpleType Typ.

Schließen des XML-Writers

Wenn Sie Methoden zum Ausgeben von XML verwenden XmlWriter , werden die Elemente und Attribute erst geschrieben, wenn Sie die Close Methode aufrufen. Wenn Sie XmlWriter beispielsweise ein XmlDocument Objekt auffüllen, können Sie die geschriebenen Elemente und Attribute im Zieldokument erst sehen, wenn Sie die XmlWriter Instanz schließen.

Asynchrone Programmierung

XmlWriter Die meisten Methoden verfügen über asynchrone Gegenstücke, die am Ende ihrer Methodennamen "Async" haben. Beispielsweise ist WriteAttributeStringAsyncdie asynchrone Entsprechung von WriteAttributeString .

Für die WriteValue Methode, die kein asynchrones Gegenstück hat, konvertieren Sie den Rückgabewert in eine Zeichenfolge, und verwenden Sie stattdessen die WriteStringAsync Methode.

Sicherheitshinweise

Berücksichtigen Sie folgendes, wenn Sie mit der XmlWriter Klasse arbeiten:

  • Ausnahmen, die von der XmlWriter App ausgelöst werden, können Pfadinformationen offenlegen, die Sie nicht für die App verwenden möchten. Ihre App muss Ausnahmen erfassen und entsprechend verarbeiten.

  • XmlWriter überprüft keine Daten, die an die WriteDocType Methode WriteRaw übergeben werden. Sie sollten keine beliebigen Daten an diese Methoden übergeben.

Konstruktoren

XmlWriter()

Initialisiert eine neue Instanz der XmlWriter-Klasse.

Eigenschaften

Settings

Ruft das zum Erstellen dieser XmlWriterSettings-Instanz verwendete XmlWriter-Objekt ab.

WriteState

Ruft beim Überschreiben in einer abgeleiteten Klasse den Zustand des Writers ab.

XmlLang

Ruft beim Überschreiben in einer abgeleiteten Klasse den aktuellen xml:lang-Bereich ab.

XmlSpace

Ruft beim Überschreiben in einer abgeleiteten Klasse einen XmlSpace ab, der den aktuellen xml:space-Bereich darstellt.

Methoden

Close()

Schließt beim Überschreiben in einer abgeleiteten Klasse diesen Stream und den zugrunde liegenden Stream.

Create(Stream)

Erstellt eine neue XmlWriter-Instanz mit dem angegebenen Stream.

Create(Stream, XmlWriterSettings)

Erstellt eine neue XmlWriter-Instanz mit dem Stream und dem XmlWriterSettings-Objekt.

Create(String)

Erstellt eine neue XmlWriter-Instanz mit dem angegebenen Dateinamen.

Create(String, XmlWriterSettings)

Erstellt eine neue XmlWriter-Instanz mit dem Dateinamen und dem XmlWriterSettings-Objekt.

Create(StringBuilder)

Erstellt mit dem angegebenen XmlWriter eine neue StringBuilder-Instanz.

Create(StringBuilder, XmlWriterSettings)

Erstellt mit dem XmlWriter-Objekt und dem StringBuilder-Objekt eine neue XmlWriterSettings-Instanz.

Create(TextWriter)

Erstellt mit dem angegebenen XmlWriter eine neue TextWriter-Instanz.

Create(TextWriter, XmlWriterSettings)

Erstellt mit dem XmlWriter-Objekt und dem TextWriter-Objekt eine neue XmlWriterSettings-Instanz.

Create(XmlWriter)

Erstellt eine neue XmlWriter-Instanz mit dem angegebenen XmlWriter-Objekt.

Create(XmlWriter, XmlWriterSettings)

Erstellt mit dem angegebenen XmlWriter-Objekt und dem angegebenen XmlWriter-Objekt eine neue XmlWriterSettings-Instanz.

Dispose()

Gibt alle von der aktuellen Instanz der XmlWriter-Klasse verwendeten Ressourcen frei.

Dispose(Boolean)

Gibt die von XmlWriter verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

DisposeAsync()

Führt anwendungsspezifische Aufgaben aus, die mit dem asynchronen Freigeben, Zurückgeben oder Zurücksetzen von nicht verwalteten Ressourcen zusammenhängen.

DisposeAsyncCore()

Führt anwendungsspezifische Aufgaben aus, die mit dem asynchronen Freigeben, Zurückgeben oder Zurücksetzen von verwalteten Ressourcen zusammenhängen.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(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.

FlushAsync()

Entleert den Pufferinhalt asynchron in die zugrunde liegenden Streams und entleert den zugrunde liegenden Stream ebenfalls.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(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.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
WriteAttributes(XmlReader, Boolean)

Schreibt beim Überschreiben in einer abgeleiteten Klasse sämtliche an der aktuellen Position gefundenen Attribute in den XmlReader.

WriteAttributesAsync(XmlReader, Boolean)

Schreibt asynchron alle Attribute aus, die in der aktuellen Position in XmlReader gefunden werden.

WriteAttributeString(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das Attribut mit dem angegebenen lokalen Namen und Wert.

WriteAttributeString(String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse ein Attribut mit dem angegebenen lokalen Namen, Namespace-URI und Wert.

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.

WriteAttributeStringAsync(String, String, String, String)

Schreibt ein Attribut asynchron mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.

WriteBase64(Byte[], Int32, Int32)

Codiert beim Überschreiben in einer abgeleiteten Klasse die angegebenen binären Bytes als Base64 und schreibt den resultierenden Text.

WriteBase64Async(Byte[], Int32, Int32)

Codiert die angegebenen binären Bytes asynchron als Base64 und schreibt den resultierenden Text.

WriteBinHex(Byte[], Int32, Int32)

Codiert beim Überschreiben in einer abgeleiteten Klasse die angegebenen binären Bytes als BinHex und schreibt den resultierenden Text.

WriteBinHexAsync(Byte[], Int32, Int32)

Codiert die angegebenen binären Bytes asynchron als BinHex und schreibt den resultierenden Text.

WriteCData(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse einen <![CDATA[...]]>-Block mit dem angegebenen Text.

WriteCDataAsync(String)

Schreibt asynchron einen <![CDATA[...]]>-Block mit dem angegebenen Text.

WriteCharEntity(Char)

Erzwingt beim Überschreiben in einer abgeleiteten Klasse die Generierung einer Zeichenentität für den angegebenen Wert eines Unicode-Zeichens.

WriteCharEntityAsync(Char)

Erzwingt das Generieren einer Zeichenentität asynchron für den angegebenen Unicode-Zeichenwert.

WriteChars(Char[], Int32, Int32)

Schreibt beim Überschreiben in einer abgeleiteten Klasse Text in jeweils einen Puffer.

WriteCharsAsync(Char[], Int32, Int32)

Schreibt Text asynchron in jeweils einen Puffer.

WriteComment(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den Kommentar <!--...--> mit dem angegebenen Text.

WriteCommentAsync(String)

Schreibt asynchron einen Kommentar <!--...-->, der den angegebenen Text enthält.

WriteDocType(String, String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse die DOCTYPE-Deklaration mit dem angegebenen Namen und optionalen Attributen.

WriteDocTypeAsync(String, String, String, String)

Schreibt die DOCTYPE-Deklaration asynchron mit dem angegebenen Namen und optionalen Attributen.

WriteElementString(String, String)

Schreibt ein Element mit dem angegebenen lokalen Namen und Wert.

WriteElementString(String, String, String)

Schreibt ein Element mit dem angegebenen lokalen Namen, Namespace-URI und Wert.

WriteElementString(String, String, String, String)

Schreibt ein Element mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.

WriteElementStringAsync(String, String, String, String)

Schreibt ein Element asynchron mit dem angegebenen Präfix, lokalen Namen, Namespace-URI und Wert.

WriteEndAttribute()

Schließt beim Überschreiben in einer abgeleiteten Klasse den vorherigen WriteStartAttribute(String, String)-Aufruf.

WriteEndAttributeAsync()

Schließt den asynchronen vorherigen WriteStartAttribute(String, String)-Aufruf.

WriteEndDocument()

Schließt beim Überschreiben in einer abgeleiteten Klasse alle geöffneten Elemente oder Attribute und setzt den Writer in den Anfangszustand zurück.

WriteEndDocumentAsync()

Schließt alle geöffneten Elemente oder Attribute asynchron und setzt den Writer in den Startzustand zurück.

WriteEndElement()

Schließt beim Überschreiben in einer abgeleiteten Klasse ein Element und löst den entsprechenden Namespacebereich auf.

WriteEndElementAsync()

Schließt ein Element asynchron und löst den entsprechenden Namespacebereich auf.

WriteEntityRef(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse einen Entitätsverweis als &name;.

WriteEntityRefAsync(String)

Schreibt einen Entitätsverweis asynchron als &name; aus.

WriteFullEndElement()

Schließt beim Überschreiben in einer abgeleiteten Klasse ein Element und löst den entsprechenden Namespacebereich auf.

WriteFullEndElementAsync()

Schließt ein Element asynchron und löst den entsprechenden Namespacebereich auf.

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.

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).

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.

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.

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.

WriteNode(XPathNavigator, Boolean)

Kopiert den gesamten Inhalt des XPathNavigator-Objekts in den Writer. Die Position des XPathNavigator bleibt unverändert.

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.

WriteNodeAsync(XPathNavigator, Boolean)

Kopiert asynchron den gesamten Inhalt des XPathNavigator-Objekt in den Writer. Die Position des XPathNavigator bleibt unverändert.

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?>.

WriteProcessingInstructionAsync(String, String)

Schreibt eine Verarbeitungsanweisung asynchron mit einem Leerzeichen zwischen dem Namen und dem Text wie folgt: <?name text?>.

WriteQualifiedName(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den durch den Namespace angegebenen Namen. Diese Methode sucht das Präfix im Gültigkeitsbereich des Namespaces.

WriteQualifiedNameAsync(String, String)

Schreibt den durch Namespace gekennzeichneten Namen asynchron. Diese Methode sucht das Präfix im Gültigkeitsbereich des Namespaces.

WriteRaw(Char[], Int32, Int32)

Schreibt beim Überschreiben in einer abgeleiteten Klasse Rohdatenmarkup manuell aus einem Zeichenpuffer.

WriteRaw(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse Rohdatenmarkup manuell aus einer Zeichenfolge.

WriteRawAsync(Char[], Int32, Int32)

Schreibt asynchron unformatiertes Markup manuell aus einem Zeichenpuffer.

WriteRawAsync(String)

Schreibt asynchron unformatiertes Markup manuell aus einer Zeichenfolge.

WriteStartAttribute(String)

Schreibt den Anfang eines Attributs mit dem angegebenen lokalen Namen.

WriteStartAttribute(String, String)

Schreibt den Anfang eines Attributs mit dem angegebenen lokalen Namen und dem angegebenen 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.

WriteStartAttributeAsync(String, String, String)

Schreibt den Anfang eines Attributs asynchron mit dem angegebenen Präfix, lokalen Namen und Namespace-URI.

WriteStartDocument()

Schreibt beim Überschreiben in einer abgeleiteten Klasse die XML-Deklaration mit der 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.

WriteStartDocumentAsync()

Schreibt die XML-Deklaration asynchron mit der Version "1.0".

WriteStartDocumentAsync(Boolean)

Schreibt die XML-Deklaration asynchron mit der Version "1.0" und dem eigenständigen Attribut.

WriteStartElement(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse ein Starttag mit dem angegebenen lokalen Namen.

WriteStartElement(String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das angegebene Starttag und ordnet dieses dem angegebenen Namespace zu.

WriteStartElement(String, String, String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse das angegebene Starttag und ordnet dieses dem angegebenen Namespace und Präfix zu.

WriteStartElementAsync(String, String, String)

Schreibt das angegebene Starttag asynchron und ordnet dieses dem angegebenen Namespace und Präfix zu.

WriteString(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den angegebenen Textinhalt.

WriteStringAsync(String)

Schreibt den angegebenen Textinhalt asynchron.

WriteSurrogateCharEntity(Char, Char)

Generiert und schreibt beim Überschreiben in einer abgeleiteten Klasse die Ersatzzeichenentität für das Ersatzzeichenpaar.

WriteSurrogateCharEntityAsync(Char, Char)

Generiert und schreibt die Ersatzzeichenentität asynchron für das Ersatzzeichenpaar.

WriteValue(Boolean)

Schreibt einen Boolean-Wert.

WriteValue(DateTime)

Schreibt einen DateTime-Wert.

WriteValue(DateTimeOffset)

Schreibt einen DateTimeOffset-Wert.

WriteValue(Decimal)

Schreibt einen Decimal-Wert.

WriteValue(Double)

Schreibt einen Double-Wert.

WriteValue(Int32)

Schreibt einen Int32-Wert.

WriteValue(Int64)

Schreibt einen Int64-Wert.

WriteValue(Object)

Schreibt den Objektwert.

WriteValue(Single)

Schreibt eine Gleitkommazahl mit einfacher Genauigkeit.

WriteValue(String)

Schreibt einen String-Wert.

WriteWhitespace(String)

Schreibt beim Überschreiben in einer abgeleiteten Klasse den angegebenen Leerraum.

WriteWhitespaceAsync(String)

Schreibt den angegebenen Leerraum asynchron.

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Eine Beschreibung dieses Elements finden Sie unter Dispose().

Erweiterungsmethoden

ConfigureAwait(IAsyncDisposable, Boolean)

Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden.

Gilt für:

Siehe auch