UTF8Encoding Classe

Définition

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

public ref class UTF8Encoding : System::Text::Encoding
public class UTF8Encoding : System.Text.Encoding
[System.Serializable]
public class UTF8Encoding : System.Text.Encoding
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class UTF8Encoding : System.Text.Encoding
type UTF8Encoding = class
    inherit Encoding
[<System.Serializable>]
type UTF8Encoding = class
    inherit Encoding
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type UTF8Encoding = class
    inherit Encoding
Public Class UTF8Encoding
Inherits Encoding
Héritage
UTF8Encoding
Attributs

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 sont en dehors de la plage de caractères ASCII. Lorsque le tableau d’octets encodé est décodé en une chaîne, les caractères pi et Sigma sont toujours présents.

using namespace System;
using namespace System::Text;
//using namespace System::Collections;

int main()
{
   // Create a UTF-8 encoding.
   UTF8Encoding^ utf8 = gcnew UTF8Encoding;
   
   // A Unicode string with two characters outside an 8-bit code range.
   String^ unicodeString = L"This Unicode string has 2 characters " +
                           L"outside the ASCII range:\n" +
                           L"Pi (\u03a0), and Sigma (\u03a3).";
   Console::WriteLine("Original string:");
   Console::WriteLine(unicodeString);
   
   // Encode the string.
   array<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 (Σ).
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, à ceci près 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 manières différentes : en tant que fichier texte à l’aide d’un StreamReader objet et en tant que fichier binaire. Comme vous pouvez vous y attendre, aucune chaîne récemment lue n’intègre la nomenclature.

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 jeu 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 jeu de caractères Unicode.

UTF-8 est un encodage Unicode qui représente chaque point de code sous la forme d’une séquence de un à quatre octets. Contrairement aux encodages UTF-16 et UTF-32, l’encodage UTF-8 ne requiert pas « endianness ». le schéma d’encodage est le même, que le processeur soit Big-endian ou Little-endian. UTF8Encodingcorrespond à la page de codes Windows 65001. Pour plus d’informations sur les UTFs et 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 qu’il fournisse une marque d’ordre d’octet (BOM) et si vous souhaitez activer la détection d’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) Configurable Non (remplacement de secours)
UTF8Encoding.UTF8Encoding(Boolean, Boolean) Configurable Configurable

La GetByteCount méthode détermine le nombre d’octets entraînant 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 entraînant le décodage d’une séquence d’octets, et les GetChars GetString méthodes et effectuent le décodage réel.

Pour un encodeur ou un décodeur capable d’enregistrer les 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 caractères qui est encodée en segments de 100 000 caractères), utilisez les GetEncoder GetDecoder Propriétés et, respectivement.

L' UTF8Encoding objet fournit éventuellement une marque d’ordre d’octet (BOM), qui est un tableau d’octets qui peut être préfixé au début du flux d’octets résultant du processus d’encodage. Si un flux d’octets encodé UTF-8 est précédé d’une marque d’ordre d’octet (BOM), il permet au décodeur de déterminer l’ordre d’octet et le format de transformation ou UTF. Notez, toutefois, que la norme Unicode ne requiert pas et ne recommande pas de nomenclature dans les flux encodé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’hébergement Unicode.

Si l’encodeur est configuré pour fournir une nomenclature, 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 nomenclatures, vous devez inclure la nomenclature au début du flux d’octets encodé, le cas échéant ; les méthodes d’encodage de la UTF8Encoding classe n’effectuent pas cette opération automatiquement.

Attention

Pour activer la détection d’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 avec la valeur true . Si la détection d’erreurs est 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 la détection d’erreurs, aucune exception n’est levée et la séquence non valide est généralement ignorée.

Notes

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

Constructeurs

UTF8Encoding()

Initialise une nouvelle instance de la classe UTF8Encoding.

UTF8Encoding(Boolean)

Initialise une nouvelle instance de la classe UTF8Encoding. Un paramètre spécifie si une marque d'ordre d'octet Unicode doit être fournie.

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 si une exception doit être levée quand un encodage non valide est détecté.

Propriétés

BodyName

En cas de substitution dans une classe dérivée, obtient un nom pour l’encodage actuel qui peut être utilisé avec les étiquettes de corps de texte 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 Encoding actuel.

(Hérité de Encoding)
DecoderFallback

Obtient ou définit l'objet DecoderFallback actuel de l'objet Encoding actuel.

(Hérité de Encoding)
EncoderFallback

Obtient ou définit l'objet EncoderFallback actuel de l'objet Encoding actuel.

(Hérité de Encoding)
EncodingName

En cas de substitution dans une classe dérivée, obtient la description explicite 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 étiquettes 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 navigation pour afficher le 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 navigation 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 de news 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 de news 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 codés sur un octet.

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

Preamble

En cas de substitution dans une classe dérivée, retourne une étendue contenant la séquence d'octets qui spécifie l'encodage utilisé.

(Hérité de Encoding)
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 la plus proche de l'encodage actuel.

(Hérité de Encoding)

Méthodes

Clone()

En cas de substitution dans une classe dérivée, crée une copie superficielle de l'objet Encoding actuel.

(Hérité de Encoding)
Equals(Object)

Détermine si l'objet spécifié est identique à l'objet UTF8Encoding actuel.

GetByteCount(Char*, Int32)

Calcule le nombre d'octets produits par l'encodage d'un jeu de caractères commençant au pointeur de caractère spécifié.

GetByteCount(Char*, 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 commençant au pointeur de caractère spécifié.

(Hérité de Encoding)
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, Int32)

Calcule le nombre d'octets produits par l'encodage d'un jeu de caractères du tableau de caractères 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(ReadOnlySpan<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 de l’étendue de caractères spécifiée.

(Hérité de Encoding)
GetByteCount(String)

Calcule le nombre d'octets générés en encodant les caractères dans le String spécifié.

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 de la chaîne spécifiée.

(Hérité de Encoding)
GetBytes(Char*, Int32, Byte*, Int32)

Code une séquence de caractères commençant au pointeur de caractère spécifié en une séquence d'octets, qui sera stockée à partir du pointeur d'octet spécifié.

GetBytes(Char*, Int32, Byte*, Int32)

En cas de substitution dans une classe dérivée, encode un jeu de caractères commençant au pointeur de caractère spécifié en une séquence d'octets stockés à partir du pointeur d'octet spécifié.

(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é en une séquence d'octets.

(Hérité de Encoding)
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é en une séquence d'octets.

(Hérité de Encoding)
GetBytes(Char[], Int32, Int32, Byte[], Int32)

Encode un jeu de caractères du tableau de caractères spécifié dans le tableau d'octets indiqué.

GetBytes(ReadOnlySpan<Char>, Span<Byte>)

Encode l’étendue de caractères spécifiée dans l’étendue d’octets spécifiée.

GetBytes(ReadOnlySpan<Char>, Span<Byte>)

En cas de substitution dans une classe dérivée, encode un jeu de caractères du tableau de caractères en lecture seule spécifié en séquence d'octets.

(Hérité de Encoding)
GetBytes(String)

Encode les caractères contenus dans un objet String spécifié dans une séquence d'octets.

GetBytes(String)

En cas de substitution dans une classe dérivée, encode tous les caractères de la chaîne spécifiée en une séquence d'octets.

(Hérité de Encoding)
GetBytes(String, Int32, Int32)

En cas de substitution dans une classe dérivée, encode en un tableau d'octets le nombre de caractères spécifié par count dans la chaîne spécifiée, à partir de l’élément index spécifié.

(Hérité de Encoding)
GetBytes(String, Int32, Int32, Byte[], Int32)

Encode un jeu de caractères de la chaîne String spécifiée dans le tableau d'octets indiqué.

GetCharCount(Byte*, Int32)

Calcule le nombre de caractères produits par le décodage d'une séquence d'octets commençant au pointeur d'octet spécifié.

GetCharCount(Byte*, Int32)

En cas de substitution dans une classe dérivée, calcule le nombre de caractères produits par le décodage d'une séquence d'octets commençant au pointeur d'octet spécifié.

(Hérité de Encoding)
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, Int32)

Calcule le nombre de caractères produits par le décodage d'une séquence d'octets du tableau d'octets spécifié.

GetCharCount(ReadOnlySpan<Byte>)

Calcule le nombre de caractères produits par le décodage de l’étendue d’octets spécifiée.

GetCharCount(ReadOnlySpan<Byte>)

En cas de substitution dans une classe dérivée, calcule le nombre de caractères produits par le décodage de l’étendue d’octets en lecture seule fournie.

(Hérité de Encoding)
GetChars(Byte*, Int32, Char*, Int32)

Décode une séquence d'octets commençant au pointeur d'octet spécifié en un jeu de caractères qui sera stocké à partir du pointeur de caractère spécifié.

GetChars(Byte*, Int32, Char*, Int32)

En cas de substitution dans une classe dérivée, décode une séquence d'octets commençant au pointeur d'octet spécifié en un jeu de caractères stockés à partir du pointeur de caractère spécifié.

(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 jeu de caractères.

(Hérité de Encoding)
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 jeu de caractères.

(Hérité de Encoding)
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(ReadOnlySpan<Byte>, Span<Char>)

Décode l’étendue d’octets spécifiée dans l’étendue de caractères spécifiée.

GetChars(ReadOnlySpan<Byte>, Span<Char>)

En cas de substitution dans une classe dérivée, décode tous les octets de l’étendue d’octets en lecture seule spécifiée en jeu de caractères.

(Hérité de Encoding)
GetDecoder()

Obtient un décodeur qui convertit une séquence d'octets encodée en UTF-8 en une séquence de caractères Unicode.

GetEncoder()

Obtient un encodeur qui convertit une séquence de caractères Unicode en une séquence d'octets encodée en UTF-8.

GetHashCode()

Retourne le code de hachage pour l'instance actuelle.

GetMaxByteCount(Int32)

Calcule le nombre maximal d'octets produits par l'encodage du nombre de caractères spécifié.

GetMaxCharCount(Int32)

Calcule le nombre maximal de caractères produits par le décodage du nombre d'octets spécifié.

GetPreamble()

Retourne une marque d'ordre d'octet Unicode au format UTF-8, si l'objet de codage UTF8Encoding est configuré pour en fournir une.

GetString(Byte*, Int32)

En cas de substitution dans une classe dérivée, décode un nombre d'octets spécifié en commençant à une adresse spécifiée dans une chaîne.

(Hérité de Encoding)
GetString(Byte[])

En cas de substitution dans une classe dérivée, décode tous les octets du tableau d'octets spécifié en chaîne.

(Hérité de Encoding)
GetString(Byte[], Int32, Int32)

Décode une plage d'octets d'un tableau d'octets en une chaîne.

GetString(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 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 en chaîne.

(Hérité de Encoding)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
IsAlwaysNormalized()

Obtient une valeur indiquant si l'encodage actuel est toujours normalisé en utilisant le 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é en utilisant le formulaire de normalisation spécifié.

(Hérité de Encoding)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Méthodes d’extension

GetBytes(Encoding, ReadOnlySequence<Char>)

Encode le ReadOnlySequence<T> spécifié dans un tableau Byte à l’aide du Encoding spécifié.

GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)

Décode le ReadOnlySequence<T> spécifié en bytes à l’aide du Encoding spécifié et écrit le résultat dans writer.

GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)

Encode le ReadOnlySequence<T> spécifié en bytes à l’aide du Encoding spécifié et génère le résultat dans bytes.

GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)

Encode le ReadOnlySpan<T> spécifié en bytes à l’aide du Encoding spécifié et écrit le résultat dans writer.

GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)

Décode le ReadOnlySequence<T> spécifié en chars à l’aide du Encoding spécifié et écrit le résultat dans writer.

GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)

Décode le ReadOnlySequence<T> spécifié en chars à l’aide du Encoding spécifié et génère le résultat dans chars.

GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)

Décode le ReadOnlySpan<T> spécifié en chars à l’aide du Encoding spécifié et écrit le résultat dans writer.

GetString(Encoding, ReadOnlySequence<Byte>)

Décode le ReadOnlySequence<T> spécifié en un String à l’aide du Encoding spécifié.

S’applique à

Voir aussi