UTF8Encoding Classe

Définition

Représente un encodage UTF-8 de caractères Unicode.Represents a UTF-8 encoding of Unicode characters.

public ref class UTF8Encoding : System::Text::Encoding
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class UTF8Encoding : System.Text.Encoding
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.The following example uses a UTF8Encoding object to encode a string of Unicode characters and store them in a byte array. 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.The Unicode string includes two characters, Pi (U+03A0) and Sigma (U+03A3), that are outside the ASCII character range. Lorsque le tableau d’octets encodé est décodé en une chaîne, les caractères pi et Sigma sont toujours présents.When the encoded byte array is decoded back to a string, the Pi and Sigma characters are still present.

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).The following example uses the same string as the previous example, except that it writes the encoded bytes to a file and prefixes the byte stream with a byte order mark (BOM). Il lit ensuite le fichier de deux manières différentes: en tant que fichier texte à l' StreamReader aide d’un objet et en tant que fichier binaire.It then reads the file in two different ways: as a text file by using a StreamReader object; and as a binary file. Comme vous pouvez vous y attendre, aucune chaîne récemment lue n’intègre la nomenclature.As you would expect, neither newly-read string includes the 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.Encoding is the process of transforming a set of Unicode characters into a sequence of bytes. Le décodage est le processus de transformation d’une séquence d’octets encodés en un jeu de caractères Unicode.Decoding is the process of transforming a sequence of encoded bytes into a set of Unicode characters.

UTF-8 est un encodage Unicode qui représente chaque point de code sous la forme d’une séquence de un à quatre octets.UTF-8 is a Unicode encoding that represents each code point as a sequence of one to four bytes. 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.Unlike the UTF-16 and UTF-32 encodings, the UTF-8 encoding does not require "endianness"; the encoding scheme is the same regardless of whether the processor is big-endian or little-endian. UTF8Encodingcorrespond à la page de codes Windows 65001.UTF8Encoding corresponds to the Windows code page 65001. Pour plus d’informations sur les UTFs et autres encodages pris System.Texten charge par, consultez encodage de caractères dans le .NET Framework.For more information about the UTFs and other encodings supported by System.Text, see Character Encoding in the .NET Framework.

Vous pouvez instancier UTF8Encoding un 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.You can instantiate a UTF8Encoding object in a number of ways, depending on whether you want to it to provide a byte order mark (BOM) and whether you want to enable error detection. Le tableau suivant répertorie les constructeurs et la Encoding propriété qui retournent un UTF8Encoding objet.The following table lists the constructors and the Encoding property that return a UTF8Encoding object.

MembreMember BOMBOM Détection d’erreursError detection
Encoding.UTF8 OuiYes Non (remplacement de secours)No (Replacement fallback)
UTF8Encoding.UTF8Encoding() NonNo Non (remplacement de secours)No (Replacement fallback)
UTF8Encoding.UTF8Encoding(Boolean) ConfigurableConfigurable Non (remplacement de secours)No (Replacement fallback)
UTF8Encoding.UTF8Encoding(Boolean, Boolean) ConfigurableConfigurable ConfigurableConfigurable

La GetByteCount méthode détermine le nombre d’octets entraînant l’encodage d’un jeu de caractères GetBytes Unicode, et la méthode effectue l’encodage réel.The GetByteCount method determines how many bytes result in encoding a set of Unicode characters, and the GetBytes method performs the actual encoding.

De même, GetCharCount la méthode détermine le nombre de caractères entraînant le décodage d’une séquence d' GetChars octets GetString , et les méthodes et effectuent le décodage réel.Likewise, the GetCharCount method determines how many characters result in decoding a sequence of bytes, and the GetChars and GetString methods perform the actual decoding.

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 GetEncoder encodée en segments de 100 000 caractères), utilisez les propriétés et. GetDecoder conséquence.For an encoder or decoder that is able to save state information when encoding or decoding data that spans multiple blocks (such as string of 1 million characters that is encoded in 100,000-character segments), use the GetEncoder and GetDecoder properties, respectively.

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.Optionally, the UTF8Encoding object provides a byte order mark (BOM), which is an array of bytes that can be prefixed to the beginning of the byte stream that results from the encoding process. 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.If a UTF-8 encoded byte stream is prefaced with a byte order mark (BOM), it helps the decoder determine the byte order and the transformation format or UTF. Notez, toutefois, que la norme Unicode ne requiert pas et ne recommande pas de nomenclature dans les flux encodés en UTF-8.Note, however, that the Unicode Standard neither requires nor recommends a BOM in UTF-8 encoded streams. 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.For more information on byte order and the byte order mark, see The Unicode Standard at the Unicode home page.

Si l’encodeur est configuré pour fournir une nomenclature, vous pouvez le récupérer en GetPreamble appelant la méthode; sinon, la méthode retourne un tableau vide.If the encoder is configured to provide a BOM, you can retrieve it by calling the GetPreamble method; otherwise, the method returns an empty array. 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 UTF8Encoding méthodes d’encodage de la classe n’effectuent pas cette opération automatiquement.Note that, even if a UTF8Encoding object is configured for BOM support, you must include the BOM at the beginning of the encoded byte stream as appropriate; the encoding methods of the UTF8Encoding class do not do this automatically.

Attention

Pour activer la détection d’erreurs et rendre l’instance de classe plus sécurisée, vous UTF8Encoding(Boolean, Boolean) devez appeler le constructeur throwOnInvalidBytes et définir truele paramètre avec la valeur.To enable error detection and to make the class instance more secure, you should call the UTF8Encoding(Boolean, Boolean) constructor and set the throwOnInvalidBytes parameter to 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 ArgumentException valide lève une exception.With error detection enabled, a method that detects an invalid sequence of characters or bytes throws an 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.Without error detection, no exception is thrown, and the invalid sequence is generally ignored.

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.The state of a UTF-8 encoded object is not preserved if the object is serialized and deserialized using different .NET Framework versions.

Constructeurs

UTF8Encoding()

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

UTF8Encoding(Boolean)

Initialise une nouvelle instance de la classe UTF8Encoding.Initializes a new instance of the UTF8Encoding class. Un paramètre spécifie si une marque d'ordre d'octet Unicode doit être fournie.A parameter specifies whether to provide a Unicode byte order mark.

UTF8Encoding(Boolean, Boolean)

Initialise une nouvelle instance de la classe UTF8Encoding.Initializes a new instance of the UTF8Encoding class. 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é.Parameters specify whether to provide a Unicode byte order mark and whether to throw an exception when an invalid encoding is detected.

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.When overridden in a derived class, gets a name for the current encoding that can be used with mail agent body tags.

(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.When overridden in a derived class, gets the code page identifier of the current Encoding.

(Hérité de Encoding)
DecoderFallback

Obtient ou définit l'objet DecoderFallback actuel de l'objet Encoding actuel.Gets or sets the DecoderFallback object for the current Encoding object.

(Hérité de Encoding)
EncoderFallback

Obtient ou définit l'objet EncoderFallback actuel de l'objet Encoding actuel.Gets or sets the EncoderFallback object for the current Encoding object.

(Hérité de Encoding)
EncodingName

En cas de substitution dans une classe dérivée, obtient la description explicite de l'encodage actuel.When overridden in a derived class, gets the human-readable description of the current encoding.

(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.When overridden in a derived class, gets a name for the current encoding that can be used with mail agent header tags.

(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.When overridden in a derived class, gets a value indicating whether the current encoding can be used by browser clients for displaying content.

(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.When overridden in a derived class, gets a value indicating whether the current encoding can be used by browser clients for saving content.

(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.When overridden in a derived class, gets a value indicating whether the current encoding can be used by mail and news clients for displaying content.

(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.When overridden in a derived class, gets a value indicating whether the current encoding can be used by mail and news clients for saving content.

(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.When overridden in a derived class, gets a value indicating whether the current encoding is read-only.

(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.When overridden in a derived class, gets a value indicating whether the current encoding uses single-byte code points.

(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.Gets a Unicode byte order mark encoded in UTF-8 format, if this object is configured to supply one.

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.When overridden in a derived class, gets the name registered with the Internet Assigned Numbers Authority (IANA) for the current encoding.

(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.When overridden in a derived class, gets the Windows operating system code page that most closely corresponds to the current encoding.

(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.When overridden in a derived class, creates a shallow copy of the current Encoding object.

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

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

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é.Calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.

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é.When overridden in a derived class, calculates the number of bytes produced by encoding all the characters in the specified character array.

(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é.Calculates the number of bytes produced by encoding a set of characters from the specified character array.

GetByteCount(ReadOnlySpan<Char>)

Calcule le nombre d’octets générés par l’encodage de l’étendue de caractères spécifiée.Calculates the number of bytes produced by encoding the specified character span.

GetByteCount(String)

Calcule le nombre d'octets générés en encodant les caractères dans le String spécifié.Calculates the number of bytes produced by encoding the characters in the specified String.

GetByteCount(String, Int32, Int32) (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é.Encodes a set of characters starting at the specified character pointer into a sequence of bytes that are stored starting at the specified byte pointer.

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 séquence d'octets.When overridden in a derived class, encodes all the characters in the specified character array into a sequence of bytes.

(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 séquence d'octets.When overridden in a derived class, encodes a set of characters from the specified character array into a sequence of bytes.

(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é.Encodes a set of characters from the specified character array into the specified byte array.

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

Encode l’étendue de caractères spécifiée dans l’étendue d’octets spécifiée.Encodes the specified character span into the specified byte span.

GetBytes(String)

Encode les caractères contenus dans un objet String spécifié dans une séquence d'octets.Encodes the characters in a specified String object into a sequence of bytes.

GetBytes(String, Int32, Int32) (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é.Encodes a set of characters from the specified String into the specified byte array.

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é.Calculates the number of characters produced by decoding a sequence of bytes starting at the specified byte pointer.

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é.When overridden in a derived class, calculates the number of characters produced by decoding all the bytes in the specified byte array.

(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é.Calculates the number of characters produced by decoding a sequence of bytes from the specified byte array.

GetCharCount(ReadOnlySpan<Byte>)

Calcule le nombre de caractères produits par le décodage de l’étendue d’octets spécifiée.Calculates the number of characters produced by decoding the specified byte span.

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é.Decodes a sequence of bytes starting at the specified byte pointer into a set of characters that are stored starting at the specified character pointer.

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.When overridden in a derived class, decodes all the bytes in the specified byte array into a set of characters.

(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 jeu de caractères.When overridden in a derived class, decodes a sequence of bytes from the specified byte array into a set of characters.

(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é.Decodes a sequence of bytes from the specified byte array into the specified character array.

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

Décode l’étendue d’octets spécifiée dans l’étendue de caractères spécifiée.Decodes the specified byte span into the specified character span.

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.Obtains a decoder that converts a UTF-8 encoded sequence of bytes into a sequence of Unicode characters.

GetEncoder()

Obtient un encodeur qui convertit une séquence de caractères Unicode en une séquence d'octets encodée en UTF-8.Obtains an encoder that converts a sequence of Unicode characters into a UTF-8 encoded sequence of bytes.

GetHashCode()

Retourne le code de hachage pour l'instance actuelle.Returns the hash code for the current instance.

GetMaxByteCount(Int32)

Calcule le nombre maximal d'octets produits par l'encodage du nombre de caractères spécifié.Calculates the maximum number of bytes produced by encoding the specified number of characters.

GetMaxCharCount(Int32)

Calcule le nombre maximal de caractères produits par le décodage du nombre d'octets spécifié.Calculates the maximum number of characters produced by decoding the specified number of bytes.

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.Returns a Unicode byte order mark encoded in UTF-8 format, if the UTF8Encoding encoding object is configured to supply one.

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.When overridden in a derived class, decodes a specified number of bytes starting at a specified address into a string.

(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.When overridden in a derived class, decodes all the bytes in the specified byte array into a string.

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

Décode une plage d'octets d'un tableau d'octets en une chaîne.Decodes a range of bytes from a byte array into a string.

GetString(ReadOnlySpan<Byte>) (Hérité de Encoding)
GetType()

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

(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.Gets a value indicating whether the current encoding is always normalized, using the default normalization form.

(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é.When overridden in a derived class, gets a value indicating whether the current encoding is always normalized, using the specified normalization form.

(Hérité de Encoding)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

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

(Hérité de Object)

S’applique à

Voir aussi