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 codé est décodé en 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, 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 vous le souhaitez, 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 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 codé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 identique, que le processeur soit big-endian ou little-endian. UTF8Encodingcorrespond à la page de code 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 .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 (secours de remplacement)
UTF8Encoding.UTF8Encoding() Non Non (secours de remplacement)
UTF8Encoding.UTF8Encoding(Boolean) Configurable Non (secours de remplacement)
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 qui entraînent le décodage d’une séquence d’octets, et les GetChars méthodes et GetString 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 couvrent plusieurs blocs (par exemple, 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 peuvent être précédés du début du flux d’octets qui résulte du processus d’encodage. Si un flux d’octets codé 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 des flux codés 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 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é comme approprié ; les méthodes d’encodage de la UTF8Encoding classe ne le font pas automatiquement.

Attention

Pour activer la détection des erreurs et pour rendre l’instance de classe plus sécurisée, vous devez appeler le UTF8Encoding(Boolean, Boolean) constructeur et définir le throwOnInvalidBytes paramètre sur true. Avec la détection d’erreurs 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.

Notes

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

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