XmlWriter Classe

Définition

Représente un writer qui fournit un moyen rapide, sans mise en cache et en avant de générer des flux de données ou des fichiers contenant des données 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 abstract class XmlWriter : IDisposable
type XmlWriter = class
    interface IDisposable
Public MustInherit Class XmlWriter
Implements IDisposable
Héritage
XmlWriter
Dérivé
Implémente

Exemples

L’exemple de code suivant montre comment utiliser l’API asynchrone pour générer du code 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();  
    }  
}  

Remarques

La classe XmlWriter écrit des données XML dans un flux, un fichier, un lecteur de texte ou une chaîne.The XmlWriter class writes XML data to a stream, file, text reader, or string. Il prend en charge les recommandations du W3C Extensible Markup Language (XML) 1,0 (quatrième édition) et des espaces de noms dans XML 1,0 (troisième édition) .It supports the W3C Extensible Markup Language (XML) 1.0 (fourth edition) and Namespaces in XML 1.0 (third edition) recommendations.

Les membres de la classe XmlWriter vous permettent d’effectuer les opérations suivantes :The members of the XmlWriter class enable you to:

  • vérifier que les caractères sont des caractères XML reconnus et que les noms d'éléments et d'attributs sont des noms XML valides ;Verify that the characters are legal XML characters and that element and attribute names are valid XML names.

  • vérifier que le document XML est correctement construit ;Verify that the XML document is well-formed.

  • Encode les octets binaires en base64 ou BinHex et écrit le texte résultant.Encode binary bytes as Base64 or BinHex, and write out the resulting text.

  • Passer des valeurs à l’aide de common language runtime types au lieu de chaînes, afin d’éviter d’avoir à effectuer manuellement des conversions de valeurs.Pass values by using common language runtime types instead of strings, to avoid having to manually perform value conversions.

  • écrire plusieurs documents dans un même flux de sortie ;Write multiple documents to one output stream.

  • écrire des noms, des noms qualifiés et des jetons de nom valides.Write valid names, qualified names, and name tokens.

Dans cette section :In this section:

Création d’un d’écriture XMLCreating an XML writer
Spécification du format de sortie Specifying the output format
de la conformité des donnéesData conformance
Écriture d’éléments Writing elements
Écriture d’attributs Writing attributes
Gestion des espaces de noms Handling namespaces
Écriture de données typées Writing typed data
Fermeture de l’enregistreur XML Closing the XML writer
de programmation asynchroneAsynchronous programming
Considérations relatives à la sécuritéSecurity considerations

Création d’un enregistreur XMLCreating an XML writer

Pour créer une instance XmlWriter, utilisez la méthode XmlWriter.Create.To create an XmlWriter instance, use the XmlWriter.Create method. Pour spécifier l’ensemble de fonctionnalités que vous souhaitez activer sur l’enregistreur XML, transmettez une XmlWriterSettings à la méthode Create.To specify the set of features you want to enable on the XML writer, pass an XmlWriterSettings to the Create method. Dans le cas contraire, les paramètres par défaut sont utilisés.Otherwise, default settings are used. Pour plus d’informations, consultez les pages de référence Create.See the Create reference pages for details.

Spécification du format de sortieSpecifying the output format

La classe XmlWriterSettings comprend plusieurs propriétés qui contrôlent la façon dont XmlWriter sortie est mise en forme :The XmlWriterSettings class includes several properties that control how XmlWriter output is formatted:

PropertyProperty DescriptionDescription
Encoding Spécifie l'encodage de texte à utiliser.Specifies the text encoding to use. La valeur par défaut est Encoding.UTF8,The default is Encoding.UTF8.
Indent Indique si des éléments doivent être mis en retrait.Indicates whether to indent elements. La valeur par défaut est false (aucune mise en retrait).The default is false (no indentation).
IndentChars Spécifie la chaîne de caractères à utiliser pour la mise en retrait.Specifies the character string to use when indenting. Par défaut, il s'agit de deux espaces.The default is two spaces.
NewLineChars Spécifie la chaîne de caractères à utiliser pour les sauts de ligne.Specifies the character string to use for line breaks. La valeur par défaut est \r\n (retour chariot, saut de ligne).The default is \r\n (carriage return, line feed).
NewLineHandling Spécifie comment gérer les caractères de saut de ligne.Specifies how to handle newline characters.
NewLineOnAttributes Indique si des attributs doivent être écrits sur une nouvelle ligne.Indicates whether to write attributes on a new line. Indent doit être défini sur true lors de l’utilisation de cette propriété.Indent should be set to true when using this property. La valeur par défaut est false,The default is false.
OmitXmlDeclaration Indique si une déclaration XML doit être écrite.Indicates whether to write an XML declaration. La valeur par défaut est false,The default is false.

Les propriétés Indent et IndentChars contrôlent la taille minime de l'espace blanc formaté.The Indent and IndentChars properties control how insignificant white space is formatted. Par exemple, pour mettre en retrait les nœuds d’élément :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)

Utilisez la NewLineOnAttributes pour écrire chaque attribut sur une nouvelle ligne avec un niveau supplémentaire de mise en retrait :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)

Conformité aux donnéesData conformance

Un Writer XML utilise deux propriétés de la classe XmlWriterSettings pour vérifier la conformité des données :An XML writer uses two properties from the XmlWriterSettings class to check for data conformance:

  • La propriété CheckCharacters indique au Writer XML de vérifier les caractères et de lever une exception XmlException si des caractères se trouvent en dehors de la plage légale, comme défini par le 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.

  • La propriété ConformanceLevel configure l’enregistreur XML pour vérifier que le flux en cours d’écriture est conforme aux règles d’un document ou d’un fragment de document XML 1,0 correctement formé, tel que défini par le 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. Les trois niveaux de conformité sont décrits dans le tableau suivant.The three conformance levels are described in the following table. La valeur par défaut est Document,The default is Document. Pour plus d’informations, consultez la propriété XmlWriterSettings.ConformanceLevel et l’énumération System.Xml.ConformanceLevel.For details, see the XmlWriterSettings.ConformanceLevel property and the System.Xml.ConformanceLevel enumeration.

    LevelLevel DescriptionDescription
    Document La sortie XML est conforme aux règles d’un document XML 1,0 correctement construit et peut être traitée par n’importe quel processeur conforme.The XML output conforms to the rules for a well-formed XML 1.0 document and can be processed by any conforming processor.
    Fragment La sortie XML est conforme aux règles d’un fragment de document XML 1,0 correctement construit.The XML output conforms to the rules for a well-formed XML 1.0 document fragment.
    Auto L’enregistreur XML détermine le niveau de vérification de la conformité à appliquer (document ou fragment) en fonction des données entrantes.The XML writer determines which level of conformation checking to apply (document or fragment) based on the incoming data.

Écrire des élémentsWriting elements

Vous pouvez utiliser les méthodes de XmlWriter suivantes pour écrire des nœuds d’élément.You can use the following XmlWriter methods to write element nodes. Pour obtenir des exemples, consultez les méthodes listées.For examples, see the methods listed.

UtilisezUse PourTo
WriteElementString Écrire un nœud d’élément entier, y compris une valeur de chaîne.Write an entire element node, including a string value.
WriteStartElement Pour écrire une valeur d’élément à l’aide de plusieurs appels de méthode.To write an element value by using multiple method calls. Par exemple, vous pouvez appeler WriteValue pour écrire une valeur typée, WriteCharEntity pour écrire une entité de caractères, WriteAttributeString pour écrire un attribut ou vous pouvez écrire un élément enfant.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. Il s’agit d’une version plus sophistiquée de la méthode WriteElementString.This is a more sophisticated version of the WriteElementString method.

Pour fermer l’élément, vous appelez la méthode WriteEndElement ou WriteFullEndElement.To close the element, you call the WriteEndElement or WriteFullEndElement method.
WriteNode Pour copier un nœud d’élément trouvé à la position actuelle d’un objet XmlReader ou XPathNavigator.To copy an element node found at the current position of an XmlReader or XPathNavigator object. Lorsqu'elle est appelée, elle copie tout l'objet source vers l'instance de l'objet XmlWriter.When called, it copies everything from the source object to the XmlWriter instance.

Écriture d’attributsWriting attributes

Vous pouvez utiliser les méthodes de XmlWriter suivantes pour écrire des attributs sur des nœuds d’élément.You can use the following XmlWriter methods to write attributes on element nodes. Ces méthodes peuvent également être utilisées pour créer des déclarations d’espaces de noms sur un élément, comme indiqué dans la section suivante.These methods can also be used to create namespace declarations on an element, as discussed in the next section.

UtilisezUse PourTo
WriteAttributeString Pour écrire un nœud d’attribut entier, y compris une valeur de chaîne.To write an entire attribute node, including a string value.
WriteStartAttribute Pour écrire la valeur d’attribut à l’aide de plusieurs appels de méthode.To write the attribute value using multiple method calls. Par exemple, vous pouvez appeler WriteValue pour écrire une valeur typée.For example, you can call WriteValue to write a typed value. Il s’agit d’une version plus sophistiquée de la méthode WriteElementString.This is a more sophisticated version of the WriteElementString method.

Pour fermer l’élément, vous appelez la méthode WriteEndAttribute.To close the element, you call the WriteEndAttribute method.
WriteAttributes Pour copier tous les attributs trouvés à la position actuelle d’un objet XmlReader.To copy all the attributes found at the current position of an XmlReader object. Les attributs écrits dépendent du type de nœud sur lequel le lecteur est actuellement positionné :The attributes that are written depend on the type of node the reader is currently positioned on:

-Pour un nœud d’attribut, il écrit l’attribut actuel, puis le reste des attributs jusqu’à la balise de fermeture de l’élément.- For an attribute node, it writes the current attribute, and then the rest of the attributes until the element closing tag.
-Pour un nœud d’élément, il écrit tous les attributs contenus dans l’élément.- For an element node, it writes all attributes contained by the element.
-Pour un nœud de déclaration XML, il écrit tous les attributs dans la déclaration.- For an XML declaration node, it writes all the attributes in the declaration.
-Pour tous les autres types de nœuds, la méthode lève une exception.- For all other node types, the method throws an exception.

Gestion des espaces de nomsHandling namespaces

Les espaces de noms sont utilisés pour qualifier des noms d'attributs et d'éléments dans un document XML.Namespaces are used to qualify element and attribute names in an XML document. Les préfixes d’espaces de noms associent des éléments et des attributs à des espaces de noms, qui sont à leur tour associés à des références URI.Namespace prefixes associate elements and attributes with namespaces, which are in turn associated with URI references. Les espaces de noms garantissent l'unicité des noms d'attributs et d'éléments dans un document XML.Namespaces create element and attribute name uniqueness in an XML document.

Le XmlWriter gère une pile d’espaces de noms qui correspond à tous les espaces de noms définis dans la portée espace de noms actuelle.The XmlWriter maintains a namespace stack that corresponds to all the namespaces defined in the current namespace scope. Lors de l'écriture des éléments et attributs, vous pouvez utiliser les espaces de noms comme suit :When writing elements and attributes you can utilize namespaces in the following ways:

  • Déclarez manuellement les espaces de noms à l’aide de la méthode WriteAttributeString.Declare namespaces manually by using the WriteAttributeString method. Cela peut s'avérer utile si vous savez comment optimiser le nombre de déclarations d'espaces de noms.This can be useful when you know how to best optimize the number of namespace declarations. Pour obtenir un exemple, consultez la méthode WriteAttributeString(String, String, String, String).For an example, see the WriteAttributeString(String, String, String, String) method.

  • substituer la déclaration d'un nouvel espace de noms à celle de l'espace de noms en cours ;Override the current namespace declaration with a new namespace. Dans le code suivant, la méthode WriteAttributeString remplace l’URI d’espace de noms du préfixe "x" de "123" par "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()
    

    Le code génère la chaîne XML suivante :The code generates the following XML string:

    <x:root xmlns:x="123">  
      <item xmlns:x="abc" />  
    </x:root>  
    
  • spécifier un préfixe d'espace de noms lors de l'écriture des attributs ou éléments.Specify a namespace prefix when writing attributes or elements. La plupart des méthodes utilisées pour écrire un élément et des attributs vous permettent de le faire.Many of the methods used to write element and attributes enable you to do this. Par exemple, la méthode WriteStartElement(String, String, String) écrit une balise de début et l’associe à un espace de noms et un préfixe spécifiés.For example, the WriteStartElement(String, String, String) method writes a start tag and associates it with a specified namespace and prefix.

Écriture de données typéesWriting typed data

La méthode WriteValue accepte un objet common language runtime (CLR), convertit la valeur d’entrée en sa représentation sous forme de chaîne en fonction des règles de conversion de type de données XSD (XML Schema Definition) et l’écrit à l’aide de la méthode WriteString.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. C’est plus facile que d’utiliser les méthodes de la classe XmlConvert pour convertir les données typées en valeur de chaîne avant de les écrire.This is easier than using the methods in the XmlConvert class to convert the typed data to a string value before writing it out.

Lors de l’écriture dans du texte, la valeur typée est sérialisée en texte à l’aide des règles de XmlConvert pour ce type de schéma.When writing to text, the typed value is serialized to text by using the XmlConvert rules for that schema type.

Pour les types de données XSD par défaut qui correspondent aux types CLR, consultez la méthode WriteValue.For default XSD data types that correspond to CLR types, see the WriteValue method.

Le XmlWriter peut également être utilisé pour écrire dans un magasin de données XML.The XmlWriter can also be used to write to an XML data store. Par exemple, la classe XPathNavigator peut créer un objet XmlWriter pour créer des nœuds pour un objet XmlDocument.For example, the XPathNavigator class can create an XmlWriter object to create nodes for an XmlDocument object. Si les informations de schéma sont disponibles dans le magasin de données, la méthode WriteValue lève une exception si vous essayez de convertir en un type qui n’est pas autorisé. Si le magasin de données ne dispose pas d’informations de schéma, la méthode WriteValue traite toutes les valeurs comme un type xsd:anySimpleType.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.

Fermeture de l’enregistreur XMLClosing the XML writer

Lorsque vous utilisez XmlWriter méthodes pour la sortie XML, les éléments et les attributs ne sont pas écrits tant que vous n’appelez pas la méthode Close.When you use XmlWriter methods to output XML, the elements and attributes are not written until you call the Close method. Par exemple, si vous utilisez XmlWriter pour remplir un objet XmlDocument, vous ne pourrez pas voir les éléments et attributs écrits dans le document cible tant que vous n’aurez pas fermé l’instance 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.

Programmation asynchroneAsynchronous programming

La plupart des méthodes XmlWriter ont des équivalents asynchrones qui ont « Async » à la fin de leurs noms de méthode.Most of the XmlWriter methods have asynchronous counterparts that have "Async" at the end of their method names. Par exemple, l’équivalent asynchrone de WriteAttributeString est WriteAttributeStringAsync.For example, the asynchronous equivalent of WriteAttributeString is WriteAttributeStringAsync.

Pour la méthode WriteValue, qui n’a pas d’équivalent asynchrone, convertissez la valeur de retour en chaîne et utilisez la méthode WriteStringAsync à la place.For the WriteValue method, which doesn't have an asynchronous counterpart, convert the return value to a string and use the WriteStringAsync method instead.

Considérations relatives à la sécuritéSecurity considerations

Lorsque vous utilisez la classe XmlWriter, tenez compte des points suivants :Consider the following when working with the XmlWriter class:

  • Les exceptions levées par la XmlWriter peuvent divulguer des informations de chemin d’accès que vous ne souhaitez pas propager à l’application.Exceptions thrown by the XmlWriter can disclose path information that you do not want bubbled up to the app. Votre application doit intercepter les exceptions et les traiter de manière appropriée.Your app must catch exceptions and process them appropriately.

  • XmlWriter ne valide pas les données passées à la méthode WriteDocType ou WriteRaw.XmlWriter does not validate any data that is passed to the WriteDocType or WriteRaw method. Vous ne devez pas passer de données arbitraires à ces méthodes.You should not pass arbitrary data to these methods.

Constructeurs

XmlWriter()

Initialise une nouvelle instance de la classe XmlWriter.Initializes a new instance of the XmlWriter class.

Propriétés

Settings

Obtient l'objet XmlWriterSettings permettant de créer cette instance de XmlWriter.Gets the XmlWriterSettings object used to create this XmlWriter instance.

WriteState

En cas de substitution dans une classe dérivée, obtient l'état du writer.When overridden in a derived class, gets the state of the writer.

XmlLang

En cas de substitution dans une classe dérivée, obtient la portée xml:lang en cours.When overridden in a derived class, gets the current xml:lang scope.

XmlSpace

En cas de substitution dans une classe dérivée, obtient XmlSpace représentant la portée xml:space en cours.When overridden in a derived class, gets an XmlSpace representing the current xml:space scope.

Méthodes

Close()

En cas de substitution dans une classe dérivée, ferme ce flux et le flux sous-jacent.When overridden in a derived class, closes this stream and the underlying stream.

Create(Stream)

Crée une nouvelle instance de XmlWriter à l'aide du flux spécifié.Creates a new XmlWriter instance using the specified stream.

Create(Stream, XmlWriterSettings)

Crée une instance de XmlWriter à l'aide du flux et de l'objet XmlWriterSettings.Creates a new XmlWriter instance using the stream and XmlWriterSettings object.

Create(String)

Crée une instance de XmlWriter à l'aide du nom de fichier spécifié.Creates a new XmlWriter instance using the specified filename.

Create(String, XmlWriterSettings)

Crée une instance de XmlWriter à l'aide du nom de fichier et de l'objet XmlWriterSettings.Creates a new XmlWriter instance using the filename and XmlWriterSettings object.

Create(StringBuilder)

Crée une nouvelle instance de XmlWriter à l'aide du StringBuilder spécifié.Creates a new XmlWriter instance using the specified StringBuilder.

Create(StringBuilder, XmlWriterSettings)

Crée une nouvelle instance de XmlWriter à l'aide des objets StringBuilder et XmlWriterSettings.Creates a new XmlWriter instance using the StringBuilder and XmlWriterSettings objects.

Create(TextWriter)

Crée une nouvelle instance de XmlWriter à l'aide du TextWriter spécifié.Creates a new XmlWriter instance using the specified TextWriter.

Create(TextWriter, XmlWriterSettings)

Crée une nouvelle instance de XmlWriter à l'aide des objets TextWriter et XmlWriterSettings.Creates a new XmlWriter instance using the TextWriter and XmlWriterSettings objects.

Create(XmlWriter)

Crée une instance de XmlWriter à l'aide de l'objet XmlWriter spécifié.Creates a new XmlWriter instance using the specified XmlWriter object.

Create(XmlWriter, XmlWriterSettings)

Crée une nouvelle instance de XmlWriter à l'aide des objets XmlWriter et XmlWriterSettings spécifiés.Creates a new XmlWriter instance using the specified XmlWriter and XmlWriterSettings objects.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe XmlWriter.Releases all resources used by the current instance of the XmlWriter class.

Dispose(Boolean)

Libère les ressources non managées utilisées par XmlWriter et libère éventuellement les ressources managées.Releases the unmanaged resources used by the XmlWriter and optionally releases the managed resources.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Flush()

En cas de substitution dans une classe dérivée, vide le contenu de la mémoire tampon dans les flux sous-jacents, puis vide le flux sous-jacent.When overridden in a derived class, flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

FlushAsync()

Vide de façon asynchrone le contenu de la mémoire tampon dans les flux sous-jacents, puis vide le flux sous-jacent.Asynchronously flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
LookupPrefix(String)

En cas de substitution dans une classe dérivée, retourne le préfixe le plus proche défini dans la portée espace de noms actuelle pour l'URI de l'espace de noms.When overridden in a derived class, returns the closest prefix defined in the current namespace scope for the namespace URI.

MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)
WriteAttributes(XmlReader, Boolean)

En cas de substitution dans une classe dérivée, écrit tous les attributs trouvés à la position actuelle dans XmlReader.When overridden in a derived class, writes out all the attributes found at the current position in the XmlReader.

WriteAttributesAsync(XmlReader, Boolean)

Écrit de façon asynchrone tous les attributs trouvés à la position actuelle dans le XmlReader.Asynchronously writes out all the attributes found at the current position in the XmlReader.

WriteAttributeString(String, String)

En cas de substitution dans une classe dérivée, écrit l'attribut avec le nom local et la valeur spécifiés.When overridden in a derived class, writes out the attribute with the specified local name and value.

WriteAttributeString(String, String, String)

En cas de substitution dans une classe dérivée, écrit un attribut avec le nom local, l'URI de l'espace de noms et la valeur spécifiés.When overridden in a derived class, writes an attribute with the specified local name, namespace URI, and value.

WriteAttributeString(String, String, String, String)

En cas de substitution dans une classe dérivée, écrit l'attribut avec le préfixe, le nom local, l'URI de l'espace de noms et la valeur spécifiés.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)

Écrit de façon asynchrone l'attribut avec le préfixe, le nom local, l'URI de l'espace de noms et la valeur spécifiés.Asynchronously writes out the attribute with the specified prefix, local name, namespace URI, and value.

WriteBase64(Byte[], Int32, Int32)

En cas de substitution dans une classe dérivée, code les octets binaires spécifiés au format Base64 et écrit le texte obtenu.When overridden in a derived class, encodes the specified binary bytes as Base64 and writes out the resulting text.

WriteBase64Async(Byte[], Int32, Int32)

Encode de façon asynchrone les octets binaires spécifiés au format base64 et écrit le texte résultant.Asynchronously encodes the specified binary bytes as Base64 and writes out the resulting text.

WriteBinHex(Byte[], Int32, Int32)

En cas de substitution dans une classe dérivée, code les octets binaires spécifiés au format BinHex et écrit le texte obtenu.When overridden in a derived class, encodes the specified binary bytes as BinHex and writes out the resulting text.

WriteBinHexAsync(Byte[], Int32, Int32)

Encode de façon asynchrone les octets binaires spécifiés au format BinHex et écrit le texte résultant.Asynchronously encodes the specified binary bytes as BinHex and writes out the resulting text.

WriteCData(String)

En cas de substitution dans une classe dérivée, écrit un bloc <![CDATA[...]]> contenant le texte spécifié.When overridden in a derived class, writes out a <![CDATA[...]]> block containing the specified text.

WriteCDataAsync(String)

Écrit de façon asynchrone un bloc <![CDATA[...]]> contenant le texte spécifié.Asynchronously writes out a <![CDATA[...]]> block containing the specified text.

WriteCharEntity(Char)

En cas de substitution dans une classe dérivée, force la génération d'une entité de caractère pour la valeur du caractère Unicode spécifiée.When overridden in a derived class, forces the generation of a character entity for the specified Unicode character value.

WriteCharEntityAsync(Char)

Force de façon asynchrone la génération d'une entité de caractère pour la valeur du caractère Unicode spécifiée.Asynchronously forces the generation of a character entity for the specified Unicode character value.

WriteChars(Char[], Int32, Int32)

En cas de substitution dans une classe dérivée, écrit du texte mémoire tampon par mémoire tampon.When overridden in a derived class, writes text one buffer at a time.

WriteCharsAsync(Char[], Int32, Int32)

Écrit de façon asynchrone du texte mémoire tampon par mémoire tampon.Asynchronously writes text one buffer at a time.

WriteComment(String)

En cas de substitution dans une classe dérivée, écrit un commentaire <!--...--> contenant le texte spécifié.When overridden in a derived class, writes out a comment <!--...--> containing the specified text.

WriteCommentAsync(String)

Écrit de façon asynchrone un commentaire <!--...--> contenant le texte spécifié.Asynchronously writes out a comment <!--...--> containing the specified text.

WriteDocType(String, String, String, String)

En cas de substitution dans une classe dérivée, écrit la déclaration DOCTYPE avec le nom et les attributs facultatifs spécifiés.When overridden in a derived class, writes the DOCTYPE declaration with the specified name and optional attributes.

WriteDocTypeAsync(String, String, String, String)

Écrit de façon asynchrone la déclaration DOCTYPE avec le nom et les attributs facultatifs spécifiés.Asynchronously writes the DOCTYPE declaration with the specified name and optional attributes.

WriteElementString(String, String)

Écrit un élément avec la valeur et le nom locaux spécifiés.Writes an element with the specified local name and value.

WriteElementString(String, String, String)

Écrit un élément avec le nom local, l'URI de l'espace de noms et la valeur spécifiés.Writes an element with the specified local name, namespace URI, and value.

WriteElementString(String, String, String, String)

Écrit un élément avec le préfixe spécifié, le nom local, l'URI de l'espace de noms et la valeur spécifiés.Writes an element with the specified prefix, local name, namespace URI, and value.

WriteElementStringAsync(String, String, String, String)

Écrit de façon asynchrone un élément avec le préfixe spécifié, le nom local, l'URI de l'espace de noms et la valeur spécifiés.Asynchronously writes an element with the specified prefix, local name, namespace URI, and value.

WriteEndAttribute()

En cas de substitution dans une classe dérivée, ferme le précédent appel de WriteStartAttribute(String, String).When overridden in a derived class, closes the previous WriteStartAttribute(String, String) call.

WriteEndAttributeAsync()

Ferme de façon asynchrone l'appel WriteStartAttribute(String, String) précédent.Asynchronously closes the previous WriteStartAttribute(String, String) call.

WriteEndDocument()

En cas de substitution dans une classe dérivée, ferme les éléments ou attributs ouverts, et replace le writer à l'état Start.When overridden in a derived class, closes any open elements or attributes and puts the writer back in the Start state.

WriteEndDocumentAsync()

Ferme de façon asynchrone les éléments ou attributs ouverts, et replace le writer à l'état Start.Asynchronously closes any open elements or attributes and puts the writer back in the Start state.

WriteEndElement()

En cas de substitution dans une classe dérivée, ferme un élément et dépile la portée espace de noms correspondante.When overridden in a derived class, closes one element and pops the corresponding namespace scope.

WriteEndElementAsync()

Ferme de façon asynchrone un élément et exécute un pop sur la portée espace de noms correspondante.Asynchronously closes one element and pops the corresponding namespace scope.

WriteEntityRef(String)

En cas de substitution dans une classe dérivée, écrit une référence d'entité comme suit : &name;.When overridden in a derived class, writes out an entity reference as &name;.

WriteEntityRefAsync(String)

Écrit de façon asynchrone une référence d'entité comme suit : &name;.Asynchronously writes out an entity reference as &name;.

WriteFullEndElement()

En cas de substitution dans une classe dérivée, ferme un élément et dépile la portée espace de noms correspondante.When overridden in a derived class, closes one element and pops the corresponding namespace scope.

WriteFullEndElementAsync()

Ferme de façon asynchrone un élément et exécute un pop sur la portée espace de noms correspondante.Asynchronously closes one element and pops the corresponding namespace scope.

WriteName(String)

En cas de remplacement dans une classe dérivée, écrit le nom spécifié, en vérifiant qu’il s’agit d’un nom valide conformément à la recommandation W3C pour le 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)

Écrit le nom spécifié de façon asynchrone, en vérifiant qu’il s’agit d’un nom valide conformément à la recommandation W3C pour le 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)

En cas de remplacement dans une classe dérivée, écrit le nom spécifié, en vérifiant qu’il s’agit d’un NmToken valide conformément à la recommandation W3C pour le 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)

Écrit le nom spécifié de façon asynchrone, en vérifiant qu’il s’agit d’un NmToken valide conformément à la recommandation W3C pour le 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)

En cas de substitution dans une classe dérivée, copie tout le contenu du lecteur vers le writer, puis déplace le lecteur vers le début du frère suivant.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)

Copie tout de l'objet XPathNavigator vers le writer.Copies everything from the XPathNavigator object to the writer. La position du XPathNavigator reste inchangée.The position of the XPathNavigator remains unchanged.

WriteNodeAsync(XmlReader, Boolean)

Copie de façon asynchrone tout le contenu du lecteur vers le writer, puis déplace le lecteur vers le début du frère suivant.Asynchronously copies everything from the reader to the writer and moves the reader to the start of the next sibling.

WriteNodeAsync(XPathNavigator, Boolean)

Copie de façon asynchrone tout le contenu de l'objet XPathNavigator vers le writer.Asynchronously copies everything from the XPathNavigator object to the writer. La position du XPathNavigator reste inchangée.The position of the XPathNavigator remains unchanged.

WriteProcessingInstruction(String, String)

En cas de substitution dans une classe dérivée, écrit une instruction de traitement avec un espace entre le nom et le texte : <?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)

Écrit de façon asynchrone une instruction de traitement avec un espace entre le nom et le texte, comme suit : <?name text?>.Asynchronously writes out a processing instruction with a space between the name and text as follows: <?name text?>.

WriteQualifiedName(String, String)

En cas de substitution dans une classe dérivée, écrit le nom qualifié de l'espace de noms.When overridden in a derived class, writes out the namespace-qualified name. Cette méthode recherche le préfixe situé dans la portée de l'espace de noms spécifié.This method looks up the prefix that is in scope for the given namespace.

WriteQualifiedNameAsync(String, String)

Écrit de façon asynchrone le nom qualifié de l'espace de noms.Asynchronously writes out the namespace-qualified name. Cette méthode recherche le préfixe situé dans la portée de l'espace de noms spécifié.This method looks up the prefix that is in scope for the given namespace.

WriteRaw(Char[], Int32, Int32)

En cas de substitution dans une classe dérivée, écrit manuellement un balisage brut à partir d'une mémoire tampon de caractères.When overridden in a derived class, writes raw markup manually from a character buffer.

WriteRaw(String)

En cas de substitution dans une classe dérivée, écrit manuellement un balisage brut à partir d'une chaîne.When overridden in a derived class, writes raw markup manually from a string.

WriteRawAsync(Char[], Int32, Int32)

Écrit manuellement de façon asynchrone un balisage brut à partir d'une mémoire tampon de caractères.Asynchronously writes raw markup manually from a character buffer.

WriteRawAsync(String)

Écrit de façon asynchrone un balisage brut à partir d'une chaîne.Asynchronously writes raw markup manually from a string.

WriteStartAttribute(String)

Écrit le début d'un attribut avec le nom local spécifié.Writes the start of an attribute with the specified local name.

WriteStartAttribute(String, String)

Écrit le début d'un attribut avec le nom local et l'URI de l'espace de noms spécifiés.Writes the start of an attribute with the specified local name and namespace URI.

WriteStartAttribute(String, String, String)

En cas de substitution dans une classe dérivée, écrit le début d'un attribut avec le préfixe, le nom local et l'URI de l'espace de noms spécifiés.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)

Écrit de façon asynchrone le début d'un attribut avec le préfixe, le nom local et l'URI de l'espace de noms spécifiés.Asynchronously writes the start of an attribute with the specified prefix, local name, and namespace URI.

WriteStartDocument()

En cas de substitution dans une classe dérivée, écrit la déclaration XML avec la version "1.0".When overridden in a derived class, writes the XML declaration with the version "1.0".

WriteStartDocument(Boolean)

En cas de substitution dans une classe dérivée, écrit la déclaration XML avec la version "1.0" et l'attribut autonome.When overridden in a derived class, writes the XML declaration with the version "1.0" and the standalone attribute.

WriteStartDocumentAsync()

Écrit de façon asynchrone la déclaration XML avec la version « 1.0 ».Asynchronously writes the XML declaration with the version "1.0".

WriteStartDocumentAsync(Boolean)

Écrit de façon asynchrone la déclaration XML avec la version « 1.0 » et l'attribut autonome.Asynchronously writes the XML declaration with the version "1.0" and the standalone attribute.

WriteStartElement(String)

En cas de substitution dans une classe dérivée, écrit une balise de début avec le nom local spécifié.When overridden in a derived class, writes out a start tag with the specified local name.

WriteStartElement(String, String)

En cas de substitution dans une classe dérivée, écrit l’étiquette de début spécifiée et l’associe à l’espace de noms indiqué.When overridden in a derived class, writes the specified start tag and associates it with the given namespace.

WriteStartElement(String, String, String)

En cas de substitution dans une classe dérivée, écrit l’étiquette de début spécifiée, puis l’associe à l’espace de noms et au préfixe indiqués.When overridden in a derived class, writes the specified start tag and associates it with the given namespace and prefix.

WriteStartElementAsync(String, String, String)

Écrit de façon asynchrone l’étiquette de début indiquée et l’associe à l’espace de noms et au préfixe spécifiés.Asynchronously writes the specified start tag and associates it with the given namespace and prefix.

WriteString(String)

En cas de substitution dans une classe dérivée, écrit le texte spécifié.When overridden in a derived class, writes the given text content.

WriteStringAsync(String)

Écrit de façon asynchrone le texte spécifié.Asynchronously writes the given text content.

WriteSurrogateCharEntity(Char, Char)

En cas de substitution dans une classe dérivée, génère et écrit l'entité de caractère de substitution correspondant à la paire de caractères de substitution.When overridden in a derived class, generates and writes the surrogate character entity for the surrogate character pair.

WriteSurrogateCharEntityAsync(Char, Char)

Génère de façon asynchrone et écrit l'entité de caractère de substitution correspondant à la paire de caractères de substitution.Asynchronously generates and writes the surrogate character entity for the surrogate character pair.

WriteValue(Boolean)

Écrit une valeur Boolean.Writes a Boolean value.

WriteValue(DateTime)

Écrit une valeur DateTime.Writes a DateTime value.

WriteValue(DateTimeOffset)

Écrit une valeur DateTimeOffset.Writes a DateTimeOffset value.

WriteValue(Decimal)

Écrit une valeur Decimal.Writes a Decimal value.

WriteValue(Double)

Écrit une valeur Double.Writes a Double value.

WriteValue(Int32)

Écrit une valeur Int32.Writes a Int32 value.

WriteValue(Int64)

Écrit une valeur Int64.Writes a Int64 value.

WriteValue(Object)

Écrit la valeur de l'objet.Writes the object value.

WriteValue(Single)

Écrit un nombre à virgule flottante simple précision.Writes a single-precision floating-point number.

WriteValue(String)

Écrit une valeur String.Writes a String value.

WriteWhitespace(String)

En cas de substitution dans une classe dérivée, écrit l'espace blanc spécifié.When overridden in a derived class, writes out the given white space.

WriteWhitespaceAsync(String)

Écrit de façon asynchrone l'espace blanc spécifié.Asynchronously writes out the given white space.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Pour obtenir une description de ce membre, consultez Dispose().For a description of this member, see Dispose().

S’applique à

Voir aussi