UTF32Encoding.GetDecoder Méthode

Définition

Espace de noms:

System.Text

Assembly:

System.Text.Encoding.Extensions.dll

Source:

UTF32Encoding.cs

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

public:
 override System::Text::Decoder ^ GetDecoder();

public override System.Text.Decoder GetDecoder ();

override this.GetDecoder : unit -> System.Text.Decoder

Public Overrides Function GetDecoder () As Decoder

Retours

Decoder

Decoder qui convertit une séquence d'octets encodée en UTF-32 en une séquence de caractères Unicode.

Exemples

L’exemple suivant utilise un encodeur et un décodeur pour encoder une chaîne dans un tableau d’octets, puis décoder les octets en un tableau de caractères.

using namespace System;
using namespace System::Text;
int main()
{
   
   // Get an encoder and a decoder from UTF32Encoding.
   UTF32Encoding ^ u32 = gcnew UTF32Encoding( false,true,true );
   Encoder^ myEnc = u32->GetEncoder();
   Decoder^ myDec = u32->GetDecoder();
   
   // The characters to encode:
   //    Latin Small Letter Z (U+007A)
   //    Latin Small Letter A (U+0061)
   //    Combining Breve (U+0306)
   //    Latin Small Letter AE With Acute (U+01FD)
   //    Greek Small Letter Beta (U+03B2)
   array<Char>^myChars = gcnew array<Char>(5){
      L'z',L'a',L'\u0306',L'\u01FD',L'\u03B2'
   };
   Console::Write( "The original characters : " );
   Console::WriteLine( myChars );
   
   // Encode the character array.
   int iBC = myEnc->GetByteCount( myChars, 0, myChars.Length, true );
   array<Byte>^myBytes = gcnew array<Byte>(iBC);
   myEnc->GetBytes( myChars, 0, myChars.Length, myBytes, 0, true );
   
   // Print the resulting bytes.
   Console::Write( "Using the encoder       : " );
   for ( int i = 0; i < myBytes.Length; i++ )
      Console::Write( "{0:X2} ", myBytes[ i ] );
   Console::WriteLine();
   
   // Decode the byte array back into an array of characters.
   int iCC = myDec->GetCharCount( myBytes, 0, myBytes.Length, true );
   array<Char>^myDecodedChars = gcnew array<Char>(iCC);
   myDec->GetChars( myBytes, 0, myBytes.Length, myDecodedChars, 0, true );
   
   // Print the resulting characters.
   Console::Write( "Using the decoder       : " );
   Console::WriteLine( myDecodedChars );
}

/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

The original characters : za??
Using the encoder       : 7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00
Using the decoder       : za??

*/

using System;
using System.Text;

public class SamplesUTF32Encoding  {

   public static void Main()  {

      // Get an encoder and a decoder from UTF32Encoding.
      UTF32Encoding u32 = new UTF32Encoding( false, true, true );
      Encoder myEnc = u32.GetEncoder();
      Decoder myDec = u32.GetDecoder();

      // The characters to encode:
      //    Latin Small Letter Z (U+007A)
      //    Latin Small Letter A (U+0061)
      //    Combining Breve (U+0306)
      //    Latin Small Letter AE With Acute (U+01FD)
      //    Greek Small Letter Beta (U+03B2)
      char[] myChars = new char[5] { 'z', 'a', '\u0306', '\u01FD', '\u03B2' };
      Console.Write( "The original characters : " );
      Console.WriteLine( myChars );

      // Encode the character array.
      int iBC  = myEnc.GetByteCount( myChars, 0, myChars.Length, true );
      byte[] myBytes = new byte[iBC];
      myEnc.GetBytes( myChars, 0, myChars.Length, myBytes, 0, true );

      // Print the resulting bytes.
      Console.Write( "Using the encoder       : " );
      for ( int i = 0; i < myBytes.Length; i++ )
         Console.Write( "{0:X2} ", myBytes[i] );
      Console.WriteLine();

      // Decode the byte array back into an array of characters.
      int iCC  = myDec.GetCharCount( myBytes, 0, myBytes.Length, true );
      char[] myDecodedChars = new char[iCC];
      myDec.GetChars( myBytes, 0, myBytes.Length, myDecodedChars, 0, true );

      // Print the resulting characters.
      Console.Write( "Using the decoder       : " );
      Console.WriteLine( myDecodedChars );
   }
}


/* 
This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.

The original characters : za??ß
Using the encoder       : 7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00
Using the decoder       : za??ß

*/

Imports System.Text

Public Class SamplesUTF32Encoding   

   Public Shared Sub Main()

      ' Get an encoder and a decoder from UTF32Encoding.
      Dim u32 As New UTF32Encoding(False, True, True)
      Dim myEnc As Encoder = u32.GetEncoder()
      Dim myDec As Decoder = u32.GetDecoder()

      ' The characters to encode:
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      Dim myChars() As Char = {"z"c, "a"c, ChrW(&H0306), ChrW(&H01FD), ChrW(&H03B2)}
      Console.Write("The original characters : ")
      Console.WriteLine(myChars)

      ' Encode the character array.
      Dim iBC As Integer = myEnc.GetByteCount(myChars, 0, myChars.Length, True)
      ' NOTE: In Visual Basic, arrays contain one extra element by default.
      '       The following line creates an array with the exact number of elements required.
      Dim myBytes(iBC - 1) As Byte
      myEnc.GetBytes(myChars, 0, myChars.Length, myBytes, 0, True)

      ' Print the resulting bytes.
      Console.Write("Using the encoder       : ")
      Dim i As Integer
      For i = 0 To myBytes.Length - 1
         Console.Write("{0:X2} ", myBytes(i))
      Next i
      Console.WriteLine()

      ' Decode the byte array back into an array of characters.
      Dim iCC As Integer = myDec.GetCharCount(myBytes, 0, myBytes.Length, True)
      ' NOTE: In Visual Basic, arrays contain one extra element by default.
      '       The following line creates an array with the exact number of elements required.
      Dim myDecodedChars(iCC - 1) As Char
      myDec.GetChars(myBytes, 0, myBytes.Length, myDecodedChars, 0, True)

      ' Print the resulting characters.
      Console.Write("Using the decoder       : ")
      Console.WriteLine(myDecodedChars)

   End Sub

End Class


'This code produces the following output.  The question marks take the place of characters that cannot be displayed at the console.
'
'The original characters : za??ß
'Using the encoder       : 7A 00 00 00 61 00 00 00 06 03 00 00 FD 01 00 00 B2 03 00 00
'Using the decoder       : za??ß

Remarques

La Decoder.GetChars méthode convertit des blocs séquentiels d’octets en blocs séquentiels de caractères, d’une manière similaire à la GetChars méthode . Toutefois, un Decoder conserve les informations d’état entre les appels 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, GetDecoder et GetEncoder sont utiles pour la transmission réseau et les opérations de fichier, car ces opérations traitent souvent des blocs de données au lieu d’un flux de données complet.

Si la détection d’erreurs est activée, c’est-à-dire trueque le throwOnInvalidCharacters paramètre du constructeur a été défini sur , la détection des erreurs est également activée dans le Decoder retourné par cette méthode. Si la détection d’erreur est activée et qu’une séquence non valide est rencontrée, l’état du décodeur n’est pas défini et le traitement doit s’arrêter.

Voir aussi

• Decoder
• GetChars(Byte[], Int32, Int32, Char[], Int32)
• GetString(Byte[], Int32, Int32)
• GetCharCount(Byte[], Int32, Int32)
• GetEncoder()
• Fonctionnement des encodages