UTF8Encoding Classe

Définition

Espace de noms:

System.Text

Assemblys:

netstandard.dll, System.Text.Encoding.Extensions.dll

Source:

UTF8Encoding.cs

Représente un encodage UTF-8 de caractères Unicode.

public ref class UTF8Encoding : System::Text::Encoding

public class UTF8Encoding : System.Text.Encoding

type UTF8Encoding = class
    inherit Encoding

Public Class UTF8Encoding
Inherits Encoding

Héritage

Object

Encoding

UTF8Encoding

Exemples

L’exemple suivant utilise un UTF8Encoding objet pour encoder une chaîne de caractères Unicode et les stocker dans un tableau d’octets. La chaîne Unicode comprend deux caractères, Pi (U+03A0) et Sigma (U+03A3), qui se trouvent en dehors de la plage de caractères ASCII. Lorsque le tableau d’octets encodé est décodé en chaîne, les caractères Pi et Sigma sont toujours présents.

using System;
using System.Text;

class Example
{
    public static void Main()
    {
        // Create a UTF-8 encoding.
        UTF8Encoding utf8 = new UTF8Encoding();
        
        // A Unicode string with two characters outside an 8-bit code range.
        String unicodeString =
            "This Unicode string has 2 characters outside the " +
            "ASCII range:\n" +
            "Pi (\u03a0), and Sigma (\u03a3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);

        // Encode the string.
        Byte[] encodedBytes = utf8.GetBytes(unicodeString);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for (int ctr = 0; ctr < encodedBytes.Length; ctr++) {
            Console.Write("{0:X2} ", encodedBytes[ctr]);
            if ((ctr + 1) %  25 == 0)
               Console.WriteLine();
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        String decodedString = utf8.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded bytes:");
        Console.WriteLine(decodedString);
    }
}
// The example displays the following output:
//    Original string:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Encoded bytes:
//    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
//    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
//    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
//    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).

Imports System.Text

Class Example
    Public Shared Sub Main()
        ' Create a UTF-8 encoding.
        Dim utf8 As New UTF8Encoding()
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim unicodeString As String = _
            "This Unicode string has 2 characters outside the " &
            "ASCII range: " & vbCrLf &
            "Pi (" & ChrW(&h03A0) & "), and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine(unicodeString)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = utf8.GetBytes(unicodeString)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        For ctr As Integer = 0 To encodedBytes.Length - 1
            Console.Write("{0:X2} ", encodedBytes(ctr))
            If (ctr + 1) Mod 25 = 0 Then Console.WriteLine
        Next
        Console.WriteLine()
        
        ' Decode bytes back to string.
        Dim decodedString As String = utf8.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded bytes:")
        Console.WriteLine(decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Encoded bytes:
'    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
'    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
'    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
'    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
'
'    Decoded bytes:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

L’exemple suivant utilise la même chaîne que l’exemple précédent, sauf qu’il écrit les octets encodés dans un fichier et préfixe le flux d’octets avec une marque d’ordre d’octet (BOM). Il lit ensuite le fichier de deux façons différentes : en tant que fichier texte à l’aide d’un StreamReader objet ; et en tant que fichier binaire. Comme prévu, aucune chaîne nouvellement lue n’inclut le boM.

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
        // Create a UTF-8 encoding that supports a BOM.
        Encoding utf8 = new UTF8Encoding(true);

        // A Unicode string with two characters outside an 8-bit code range.
        String unicodeString =
            "This Unicode string has 2 characters outside the " +
            "ASCII range:\n" +
            "Pi (\u03A0)), and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);
        Console.WriteLine();

        // Encode the string.
        Byte[] encodedBytes = utf8.GetBytes(unicodeString);
        Console.WriteLine("The encoded string has {0} bytes.",
                          encodedBytes.Length);
        Console.WriteLine();

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Create);
        Byte[] bom = utf8.GetPreamble();
        fs.Write(bom, 0, bom.Length);
        fs.Write(encodedBytes, 0, encodedBytes.Length);
        Console.WriteLine("Wrote {0} bytes to the file.", fs.Length);
        fs.Close();
        Console.WriteLine();

        // Open the file using StreamReader.
        var sr = new StreamReader(@".\UTF8Encoding.txt");
        String newString = sr.ReadToEnd();
        sr.Close();
        Console.WriteLine("String read using StreamReader:");
        Console.WriteLine(newString);
        Console.WriteLine();

        // Open the file as a binary file and decode the bytes back to a string.
        fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Open);
        Byte[] bytes = new Byte[fs.Length];
        fs.Read(bytes, 0, (int)fs.Length);
        fs.Close();

        String decodedString = utf8.GetString(bytes);
        Console.WriteLine("Decoded bytes:");
        Console.WriteLine(decodedString);
   }
}
// The example displays the following output:
//    Original string:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    The encoded string has 88 bytes.
//
//    Wrote 91 bytes to the file.
//
//    String read using StreamReader:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).

Imports System.IO
Imports System.Text

Class Example
    Public Shared Sub Main()
        ' Create a UTF-8 encoding that supports a BOM.
        Dim utf8 As New UTF8Encoding(True)
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim unicodeString As String = _
            "This Unicode string has 2 characters outside the " &
            "ASCII range: " & vbCrLf &
            "Pi (" & ChrW(&h03A0) & "), and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine(unicodeString)
        Console.WriteLine()
        
        ' Encode the string.
        Dim encodedBytes As Byte() = utf8.GetBytes(unicodeString)
        Console.WriteLine("The encoded string has {0} bytes.",
                          encodedBytes.Length)
        Console.WriteLine()
        
        ' Write the bytes to a file with a BOM.
        Dim fs As New FileStream(".\UTF8Encoding.txt", FileMode.Create)
        Dim bom() As Byte = utf8.GetPreamble()
        fs.Write(bom, 0, bom.Length)
        fs.Write(encodedBytes, 0, encodedBytes.Length)
        Console.WriteLine("Wrote {0} bytes to the file.", fs.Length)
        fs.Close()
        Console.WriteLine()
        
        ' Open the file using StreamReader.
        Dim sr As New StreamReader(".\UTF8Encoding.txt")
        Dim newString As String = sr.ReadToEnd()
        sr.Close()
        Console.WriteLine("String read using StreamReader:")
        Console.WriteLine(newString)
        Console.WriteLine()
        
        ' Open the file as a binary file and decode the bytes back to a string.
        fs = new FileStream(".\UTF8Encoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = utf8.GetString(bytes)
        Console.WriteLine("Decoded bytes:")
        Console.WriteLine(decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    The encoded string has 88 bytes.
'
'    Wrote 91 bytes to the file.
'
'    String read using StreamReader:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Decoded bytes:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

Remarques

L’encodage est le processus de transformation d’un ensemble de caractères Unicode en une séquence d’octets. Le décodage est le processus de transformation d’une séquence d’octets encodés en un ensemble de caractères Unicode.

UTF-8 est un encodage Unicode qui représente chaque point de code sous la forme d’une séquence d’un à quatre octets. Contrairement aux encodages UTF-16 et UTF-32, l’encodage UTF-8 ne nécessite pas de « endianness » ; le schéma d’encodage est le même, que le processeur soit big-endian ou little-endian. UTF8Encoding correspond à la page de codes Windows 65001. Pour plus d’informations sur les UTFs et d’autres encodages pris en charge par System.Text, consultez Encodage de caractères dans le .NET Framework.

Vous pouvez instancier un UTF8Encoding objet de plusieurs façons, selon que vous souhaitez lui fournir une marque d’ordre d’octet (BOM) et si vous souhaitez activer la détection des erreurs. Le tableau suivant répertorie les constructeurs et la Encoding propriété qui retournent un UTF8Encoding objet.

Membre	BOM	Détection d'erreurs
Encoding.UTF8	Oui	Non (remplacement de secours)
UTF8Encoding.UTF8Encoding()	Non	Non (remplacement de secours)
UTF8Encoding.UTF8Encoding(Boolean)	Paramétrable	Non (remplacement de secours)
UTF8Encoding.UTF8Encoding(Boolean, Boolean)	Paramétrable	Paramétrable

La GetByteCount méthode détermine le nombre d’octets résultant de l’encodage d’un jeu de caractères Unicode, et la GetBytes méthode effectue l’encodage réel.

De même, la GetCharCount méthode détermine le nombre de caractères qui entraînent le décodage d’une séquence d’octets et les GetCharsGetString méthodes effectuent le décodage réel.

Pour un encodeur ou un décodeur capable d’enregistrer des informations d’état lors de l’encodage ou du décodage des données qui s’étendent sur plusieurs blocs (par exemple, une chaîne de 1 million de caractères codés dans des segments de 100 000 caractères), utilisez respectivement les propriétés et GetDecoder les GetEncoder propriétés.

Si vous le souhaitez, l’objet UTF8Encoding fournit une marque d’ordre d’octets (BOM), qui est un tableau d’octets qui peut être précédé du début du flux d’octets qui résulte du processus d’encodage. Si un flux d’octets codé en UTF-8 est précédé avec une marque d’ordre d’octet (BOM), il aide le décodeur à déterminer l’ordre d’octet et le format de transformation ou UTF. Notez toutefois que la norme Unicode ne nécessite ni recommande un boM dans les flux codés en UTF-8. Pour plus d’informations sur l’ordre d’octet et la marque d’ordre d’octet, consultez la norme Unicode sur la page d’accueil Unicode.

Si l’encodeur est configuré pour fournir un boM, vous pouvez le récupérer en appelant la GetPreamble méthode ; sinon, la méthode retourne un tableau vide. Notez que, même si un UTF8Encoding objet est configuré pour la prise en charge des boM, vous devez inclure le boM au début du flux d’octets encodé selon les besoins ; les méthodes d’encodage de la UTF8Encoding classe ne le font pas automatiquement.

Avertissement

Pour activer la détection des erreurs et rendre l’instance de classe plus sécurisée, vous devez appeler le UTF8Encoding(Boolean, Boolean) constructeur et définir le throwOnInvalidBytes paramètre truesur . Une fois la détection d’erreur activée, une méthode qui détecte une séquence de caractères ou d’octets non valide lève une ArgumentException exception. Sans détection d’erreur, aucune exception n’est levée et la séquence non valide est généralement ignorée.

Note

L’état d’un objet encodé UTF-8 n’est pas conservé si l’objet est sérialisé et désérialisé à l’aide de différentes versions du .NET Framework.

Constructeurs

Nom	Description
UTF8Encoding()	Initialise une nouvelle instance de la classe UTF8Encoding.
UTF8Encoding(Boolean, Boolean)	Initialise une nouvelle instance de la classe UTF8Encoding. Les paramètres spécifient s’il faut fournir une marque d’ordre d’octet Unicode et s’il faut lever une exception lorsqu’un encodage non valide est détecté.
UTF8Encoding(Boolean)	Initialise une nouvelle instance de la classe UTF8Encoding. Un paramètre spécifie s’il faut fournir une marque d’ordre d’octet Unicode.

Propriétés

Nom	Description
BodyName	En cas de substitution dans une classe dérivée, obtient un nom pour l’encodage actuel qui peut être utilisé avec des balises de corps de l’agent de messagerie. (Hérité de Encoding)
CodePage	En cas de substitution dans une classe dérivée, obtient l’identificateur de la page de codes du fichier actif Encoding. (Hérité de Encoding)
DecoderFallback	Obtient ou définit l’objet DecoderFallback de l’objet actif Encoding . (Hérité de Encoding)
EncoderFallback	Obtient ou définit l’objet EncoderFallback de l’objet actif Encoding . (Hérité de Encoding)
EncodingName	En cas de substitution dans une classe dérivée, obtient la description lisible par l’homme de l’encodage actuel. (Hérité de Encoding)
HeaderName	En cas de substitution dans une classe dérivée, obtient un nom pour l’encodage actuel qui peut être utilisé avec les balises d’en-tête de l’agent de messagerie. (Hérité de Encoding)
IsBrowserDisplay	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel peut être utilisé par les clients de navigateur pour afficher du contenu. (Hérité de Encoding)
IsBrowserSave	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel peut être utilisé par les clients de navigateur pour enregistrer du contenu. (Hérité de Encoding)
IsMailNewsDisplay	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel peut être utilisé par les clients de messagerie et d’actualités pour afficher du contenu. (Hérité de Encoding)
IsMailNewsSave	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel peut être utilisé par les clients de messagerie et d’actualités pour enregistrer du contenu. (Hérité de Encoding)
IsReadOnly	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel est en lecture seule. (Hérité de Encoding)
IsSingleByte	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel utilise des points de code à octet unique. (Hérité de Encoding)
Preamble	Obtient une marque d’ordre d’octet Unicode encodée au format UTF-8, si cet objet est configuré pour en fournir un.
WebName	En cas de substitution dans une classe dérivée, obtient le nom inscrit auprès de l’IANA (Internet Assigned Numbers Authority) pour l’encodage actuel. (Hérité de Encoding)
WindowsCodePage	En cas de substitution dans une classe dérivée, obtient la page de codes du système d’exploitation Windows qui correspond le plus étroitement à l’encodage actuel. (Hérité de Encoding)

Méthodes

Nom	Description
Clone()	En cas de substitution dans une classe dérivée, crée une copie superficielle de l’objet actuel Encoding . (Hérité de Encoding)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel UTF8Encoding .
GetByteCount(Char[], Int32, Int32)	Calcule le nombre d’octets générés par l’encodage d’un jeu de caractères à partir du tableau de caractères spécifié.
GetByteCount(Char[])	En cas de substitution dans une classe dérivée, calcule le nombre d’octets produits par l’encodage de tous les caractères du tableau de caractères spécifié. (Hérité de Encoding)
GetByteCount(Char*, Int32)	Calcule le nombre d’octets générés par l’encodage d’un jeu de caractères commençant par le pointeur de caractère spécifié.
GetByteCount(ReadOnlySpan<Char>)	Calcule le nombre d’octets générés par l’encodage de l’étendue de caractères spécifiée.
GetByteCount(String, Int32, Int32)	En cas de substitution dans une classe dérivée, calcule le nombre d’octets produits par l’encodage d’un jeu de caractères à partir de la chaîne spécifiée. (Hérité de Encoding)
GetByteCount(String)	Calcule le nombre d’octets générés par l’encodage des caractères dans le fichier spécifié String.
GetBytes(Char[], Int32, Int32, Byte[], Int32)	Encode un jeu de caractères du tableau de caractères spécifié dans le tableau d’octets spécifié.
GetBytes(Char[], Int32, Int32)	En cas de substitution dans une classe dérivée, encode un jeu de caractères du tableau de caractères spécifié dans une séquence d’octets. (Hérité de Encoding)
GetBytes(Char[])	En cas de substitution dans une classe dérivée, encode tous les caractères du tableau de caractères spécifié dans une séquence d’octets. (Hérité de Encoding)
GetBytes(Char*, Int32, Byte*, Int32)	Encode un jeu de caractères commençant par le pointeur de caractères spécifié dans une séquence d’octets stockés à partir du pointeur d’octet spécifié.
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	Encode l’étendue de caractères spécifiée dans l’étendue d’octets spécifiée.
GetBytes(String, Int32, Int32, Byte[], Int32)	Encode un jeu de caractères du tableau d’octets String spécifié.
GetBytes(String, Int32, Int32)	En cas de substitution dans une classe dérivée, encode dans un tableau d’octets le nombre de caractères spécifié par count la chaîne spécifiée, à partir de la valeur spécifiée index. (Hérité de Encoding)
GetBytes(String)	En cas de substitution dans une classe dérivée, encode tous les caractères de la chaîne spécifiée dans une séquence d’octets. (Hérité de Encoding)
GetCharCount(Byte[], Int32, Int32)	Calcule le nombre de caractères générés par le décodage d’une séquence d’octets à partir du tableau d’octets spécifié.
GetCharCount(Byte[])	En cas de substitution dans une classe dérivée, calcule le nombre de caractères produits par le décodage de tous les octets du tableau d’octets spécifié. (Hérité de Encoding)
GetCharCount(Byte*, Int32)	Calcule le nombre de caractères générés par le décodage d’une séquence d’octets commençant au pointeur d’octet spécifié.
GetCharCount(ReadOnlySpan<Byte>)	Calcule le nombre de caractères générés par le décodage de l’étendue d’octets spécifiée.
GetChars(Byte[], Int32, Int32, Char[], Int32)	Décode une séquence d’octets du tableau d’octets spécifié dans le tableau de caractères spécifié.
GetChars(Byte[], Int32, Int32)	En cas de substitution dans une classe dérivée, décode une séquence d’octets du tableau d’octets spécifié en un ensemble de caractères. (Hérité de Encoding)
GetChars(Byte[])	En cas de substitution dans une classe dérivée, décode tous les octets du tableau d’octets spécifié en un ensemble de caractères. (Hérité de Encoding)
GetChars(Byte*, Int32, Char*, Int32)	Décode une séquence d’octets commençant au pointeur d’octet spécifié dans un ensemble de caractères stockés à partir du pointeur de caractères spécifié.
GetChars(ReadOnlySpan<Byte>, Span<Char>)	Décode l’étendue d’octets spécifiée dans l’étendue de caractères spécifiée.
GetDecoder()	Obtient un décodeur qui convertit une séquence codée en UTF-8 d’octets en une séquence de caractères Unicode.
GetEncoder()	Obtient un encodeur qui convertit une séquence de caractères Unicode en séquence codée UTF-8 d’octets.
GetHashCode()	Retourne le code de hachage de l’instance actuelle.
GetMaxByteCount(Int32)	Calcule le nombre maximal d’octets produits par encodage du nombre spécifié de caractères.
GetMaxCharCount(Int32)	Calcule le nombre maximal de caractères produits par décodage du nombre spécifié d’octets.
GetPreamble()	Retourne une marque d’ordre d’octet Unicode encodée au format UTF-8, si l’objet UTF8Encoding d’encodage est configuré pour en fournir un.
GetString(Byte[], Int32, Int32)	Décode une plage d’octets d’un tableau d’octets dans une chaîne.
GetString(Byte[])	En cas de substitution dans une classe dérivée, décode tous les octets du tableau d’octets spécifié dans une chaîne. (Hérité de Encoding)
GetString(Byte*, Int32)	En cas de substitution dans une classe dérivée, décode un nombre spécifié d’octets à partir d’une adresse spécifiée dans une chaîne. (Hérité de Encoding)
GetString(ReadOnlySpan<Byte>)	En cas de substitution dans une classe dérivée, décode tous les octets de l’étendue d’octets spécifiée dans une chaîne. (Hérité de Encoding)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
IsAlwaysNormalized()	Obtient une valeur indiquant si l’encodage actuel est toujours normalisé, à l’aide du formulaire de normalisation par défaut. (Hérité de Encoding)
IsAlwaysNormalized(NormalizationForm)	En cas de substitution dans une classe dérivée, obtient une valeur indiquant si l’encodage actuel est toujours normalisé, à l’aide du formulaire de normalisation spécifié. (Hérité de Encoding)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TryGetBytes(ReadOnlySpan<Char>, Span<Byte>, Int32)	Encode dans une étendue d’octets un jeu de caractères de l’étendue en lecture seule spécifiée si la destination est suffisamment grande.
TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32)	Décode dans une étendue de caractères un ensemble d’octets de l’étendue en lecture seule spécifiée si la destination est suffisamment grande.

Méthodes d’extension

Nom	Description
GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)	Décode la valeur spécifiée ReadOnlySequence<T> à bytel’aide du résultat spécifié Encoding et écrit le résultat dans writer.
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	Encode le paramètre spécifié ReadOnlySequence<T> à bytel’aide du résultat spécifié Encoding et génère le résultat vers bytes.
GetBytes(Encoding, ReadOnlySequence<Char>)	Encode le spécifié ReadOnlySequence<T> dans un Byte tableau à l’aide de l’élément spécifié Encoding.
GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)	Encode le contenu spécifié ReadOnlySpan<T> à l’aide du résultat spécifié byte et écrit le résultat dans Encodingwriter.
GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)	Décode la valeur spécifiée ReadOnlySequence<T> à charl’aide du résultat spécifié Encoding et écrit le résultat dans writer.
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	Décode les valeurs spécifiées ReadOnlySequence<T> à charl’aide des résultats spécifiés Encoding et génère le résultat vers chars.
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	Décode la valeur spécifiée ReadOnlySpan<T> à charl’aide du résultat spécifié Encoding et écrit le résultat dans writer.
GetString(Encoding, ReadOnlySequence<Byte>)	Décode le spécifié ReadOnlySequence<T> en String utilisant le fichier spécifié Encoding.

Voir aussi

• Decoder
• Encoder
• Présentation des encodages