Partager via


Decoder Classe

Définition

Convertit une séquence d'octets codés en jeu de caractères.

public ref class Decoder abstract
public abstract class Decoder
[System.Serializable]
public abstract class Decoder
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Decoder
type Decoder = class
[<System.Serializable>]
type Decoder = class
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Decoder = class
Public MustInherit Class Decoder
Héritage
Decoder
Attributs

Exemples

L’exemple suivant illustre l’utilisation d’un Decoder pour convertir deux tableaux d’octets différents en un tableau de caractères. L’un des octets du caractère s’étend sur les tableaux. Cela est similaire à ce qu’un StreamReader objet fait en interne lors de la lecture d’un flux.

using namespace System;
using namespace System::Text;
int main()
{
   
   // These bytes in UTF-8 correspond to 3 different Unicode
   // characters: space (U+0020), # (U+0023), and the biohazard
   // symbol (U+2623).  Note the biohazard symbol requires 3 bytes
   // in UTF-8 (hexadecimal e2, 98, a3).  Decoders store state across
   // multiple calls to GetChars, handling the case when one char
   // is in multiple byte arrays.
   array<Byte>^bytes1 = {0x20,0x23,0xe2};
   array<Byte>^bytes2 = {0x98,0xa3};
   array<Char>^chars = gcnew array<Char>(3);
   Decoder^ d = Encoding::UTF8->GetDecoder();
   int charLen = d->GetChars( bytes1, 0, bytes1->Length, chars, 0 );
   
   // The value of charLen should be 2 now.
   charLen += d->GetChars( bytes2, 0, bytes2->Length, chars, charLen );
   for ( UInt16 index(0); index < chars->Length; ++index )
   {
      Console::Write( "U+{0:X4}  ", static_cast<UInt16>(chars[ index ]) );

   }
}
using System;
using System.Text;
public class dec
{
    public static void Main()
    {
        // These bytes in UTF-8 correspond to 3 different Unicode
        // characters: space (U+0020), # (U+0023), and the biohazard
        // symbol (U+2623).  Note the biohazard symbol requires 3 bytes
        // in UTF-8 (hexadecimal e2, 98, a3).  Decoders store state across
        // multiple calls to GetChars, handling the case when one char
        // is in multiple byte arrays.
        byte[] bytes1 = { 0x20, 0x23, 0xe2 };
        byte[] bytes2 = { 0x98, 0xa3 };
        char[] chars = new char[3];

        Decoder d = Encoding.UTF8.GetDecoder();
        int charLen = d.GetChars(bytes1, 0, bytes1.Length, chars, 0);
        // The value of charLen should be 2 now.
        charLen += d.GetChars(bytes2, 0, bytes2.Length, chars, charLen);
        foreach(char c in chars)
            Console.Write("U+{0:X4}  ", (ushort)c);
    }
}
Imports System.Text

Public Class dec
    
    Public Shared Sub Main()
        ' These bytes in UTF-8 correspond to 3 different Unicode
        ' characters: space (U+0020), # (U+0023), and the biohazard
        ' symbol (U+2623).  Note the biohazard symbol requires 3 bytes
        ' in UTF-8 (hexadecimal e2, 98, a3).  Decoders store state across
        ' multiple calls to GetChars, handling the case when one char
        ' is in multiple byte arrays.
        Dim bytes1 As Byte() =  {&H20, &H23, &HE2}
        Dim bytes2 As Byte() =  {&H98, &HA3}
        Dim chars(3) As Char
        
        Dim d As Decoder = Encoding.UTF8.GetDecoder()
        Dim charLen As Integer = d.GetChars(bytes1, 0, bytes1.Length, chars, 0)
        ' The value of charLen should be 2 now.
        charLen += d.GetChars(bytes2, 0, bytes2.Length, chars, charLen)
        Dim c As Char
        For Each c In  chars
            Console.Write("U+{0:X4}  ", Convert.ToUInt16(c) )
        Next c
    End Sub
End Class

Remarques

Pour obtenir une instance d’une implémentation de la Decoder classe , appelez la GetDecoder méthode d’une Encoding implémentation.

La GetCharCount méthode détermine le nombre de caractères qui entraînent le décodage d’une séquence d’octets, et la GetChars méthode effectue le décodage réel. Plusieurs versions de ces deux méthodes sont disponibles dans la Decoder classe . Pour plus d'informations, consultez Encoding.GetChars. Un Decoder objet conserve les informations d’état entre les appels successifs à GetChars des méthodes ou Convert afin de pouvoir décoder correctement les séquences d’octets qui s’étendent sur des blocs. Le Decoder conserve également les octets de fin à la fin des blocs de données et utilise les octets de fin lors de l’opération de décodage suivante. Par conséquent, et GetEncoder sont utiles pour les opérations de transmission réseau et de fichiers, GetDecoder car ces opérations traitent souvent des blocs de données au lieu d’un flux de données complet.

Notes

Lorsque l’application a terminé avec un flux de données, elle doit s’assurer que les informations d’état sont vidées en définissant le flush paramètre true sur dans l’appel de méthode approprié. Si une exception se produit ou si l’application change de flux, elle doit appeler Reset pour effacer l’état interne de l’objet Decoder .

Notes pour les responsables de l’implémentation

Lorsque votre application hérite de cette classe, elle doit remplacer tous les membres.

Constructeurs

Decoder()

Initialise une nouvelle instance de la classe Decoder.

Propriétés

Fallback

Obtient ou définit un objet DecoderFallback pour l'objet Decoder actuel.

FallbackBuffer

Obtient l'objet DecoderFallbackBuffer associé à l'objet Decoder en cours.

Méthodes

Convert(Byte*, Int32, Char*, Int32, Boolean, Int32, Int32, Boolean)

Convertit une mémoire tampon d’octets encodés en caractères encodés en UTF-16 et stocke le résultat dans une autre mémoire tampon.

Convert(Byte[], Int32, Int32, Char[], Int32, Int32, Boolean, Int32, Int32, Boolean)

Convertit un tableau d’octets encodés en caractères encodés en UTF-16 et stocke le résultat dans un tableau de caractères.

Convert(ReadOnlySpan<Byte>, Span<Char>, Boolean, Int32, Int32, Boolean)

Convertit une étendue d’octets encodés en caractères encodés en UTF-16 et stocke le résultat dans une autre étendue.

Equals(Object)

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

(Hérité de Object)
GetCharCount(Byte*, Int32, Boolean)

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é. Un paramètre indique s’il convient d’effacer l’état interne du décodeur après le calcul.

GetCharCount(Byte[], Int32, 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 du tableau d'octets spécifié.

GetCharCount(Byte[], Int32, Int32, Boolean)

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 du tableau d'octets spécifié. Un paramètre indique s’il convient d’effacer l’état interne du décodeur après le calcul.

GetCharCount(ReadOnlySpan<Byte>, Boolean)

En cas de substitution dans une classe dérivée, calcule le nombre de caractères produits par le décodage de la séquence d'octets dans l’étendue. Un paramètre indique s’il convient d’effacer l’état interne du décodeur après le calcul.

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

En cas de substitution dans une classe dérivée, décode une séquence d'octets démarrant au pointeur d'octet spécifié et les octets de la mémoire tampon interne en un jeu de caractères, stockés à partir du pointeur de caractère spécifié. Un paramètre indique si l'état interne du décodeur doit être effacé après la conversion.

GetChars(Byte[], Int32, Int32, Char[], Int32)

En cas de substitution dans une classe dérivée, décode une séquence d'octets du tableau d'octets spécifié et les octets de la mémoire tampon interne dans le tableau de caractères spécifié.

GetChars(Byte[], Int32, Int32, Char[], Int32, Boolean)

En cas de substitution dans une classe dérivée, décode une séquence d'octets du tableau d'octets spécifié et les octets de la mémoire tampon interne dans le tableau de caractères spécifié. Un paramètre indique si l'état interne du décodeur doit être effacé après la conversion.

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

En cas de substitution dans une classe dérivée, décode une séquence d’octets d’étendue et les octets de la mémoire tampon interne en un jeu de caractères, stockés à partir du pointeur de caractère spécifié. Un paramètre indique si l'état interne du décodeur doit être effacé après la conversion.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
Reset()

En cas de substitution dans une classe dérivée, redéfinit le décodeur à son état initial.

ToString()

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

(Hérité de Object)

Méthodes d’extension

Convert(Decoder, ReadOnlySequence<Byte>, IBufferWriter<Char>, Boolean, Int64, Boolean)

Convertit un ReadOnlySequence<T> en caractères encodés UTF-16 et écrit le résultat dans writer.

Convert(Decoder, ReadOnlySpan<Byte>, IBufferWriter<Char>, Boolean, Int64, Boolean)

Convertit un ReadOnlySpan<T> en caractères à l’aide de decoder et écrit le résultat dans writer.

S’applique à

Voir aussi