UTF32Encoding Classe

Referência

Definição

Namespace:: System.Text

Assemblies:: mscorlib.dll, System.Text.Encoding.Extensions.dll

Assembly:: System.Text.Encoding.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: UTF32Encoding.cs

Origem:: UTF32Encoding.cs

Origem:: UTF32Encoding.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa uma codificação de caracteres Unicode UTF-32.

public ref class UTF32Encoding sealed : System::Text::Encoding

public sealed class UTF32Encoding : System.Text.Encoding

[System.Serializable]
public sealed class UTF32Encoding : System.Text.Encoding

type UTF32Encoding = class
    inherit Encoding

[<System.Serializable>]
type UTF32Encoding = class
    inherit Encoding

Public NotInheritable Class UTF32Encoding
Inherits Encoding

Herança: Object

Encoding
UTF32Encoding

Atributos: SerializableAttribute

Exemplos

O exemplo a seguir demonstra o comportamento de UTF32Encoding objetos com e sem a detecção de erros habilitada. Ele cria uma matriz de bytes cujos últimos quatro bytes representam um par alternativo inválido; O U+D8FF substituto alto é seguido por um U+01FF, que está fora do intervalo de substitutos baixos (0xDC00 por meio de 0xDFFF). Sem detecção de erros, o decodificador UTF32 usa fallback de substituição para substituir o par alternativo inválido por REPLACEMENT CHARACTER (U+FFFD).

using namespace System;
using namespace System::Text;
void PrintDecodedString( array<Byte>^bytes, Encoding^ enc );
int main()
{
   
   // Create an instance of UTF32Encoding using little-endian byte order.
   // This will be used for encoding.
   UTF32Encoding^ u32LE = gcnew UTF32Encoding( false,true );
   
   // Create two instances of UTF32Encoding using big-endian byte order: one with error detection and one without.
   // These will be used for decoding.
   UTF32Encoding^ u32withED = gcnew UTF32Encoding( true,true,true );
   UTF32Encoding^ u32noED = gcnew UTF32Encoding( true,true,false );
   
   // Create byte arrays from the same string containing the following characters:
   //    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)
   String^ myStr = L"za\u0306\u01FD\u03B2\xD8FF\xDCFF";
   
   // Encode the string using little-endian byte order.
   array<Byte>^myBytes = gcnew array<Byte>(u32LE->GetByteCount( myStr ));
   u32LE->GetBytes( myStr, 0, myStr->Length, myBytes, 0 );
   
   // Decode the byte array with error detection.
   Console::WriteLine( "Decoding with error detection:" );
   PrintDecodedString( myBytes, u32withED );
   
   // Decode the byte array without error detection.
   Console::WriteLine( "Decoding without error detection:" );
   PrintDecodedString( myBytes, u32noED );
}


// Decode the bytes and display the string.
void PrintDecodedString( array<Byte>^bytes, Encoding^ enc )
{
   try
   {
      Console::WriteLine( "   Decoded string: {0}", enc->GetString( bytes, 0, bytes->Length ) );
   }
   catch ( System::ArgumentException^ e ) 
   {
      Console::WriteLine( e );
   }

   Console::WriteLine();
}

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
     // Create a UTF32Encoding object with error detection enabled.
      var encExc = new UTF32Encoding(! BitConverter.IsLittleEndian, true, true);
      // Create a UTF32Encoding object with error detection disabled.
      var encRepl = new UTF32Encoding(! BitConverter.IsLittleEndian, true, false);

      // Create a byte arrays from a string, and add an invalid surrogate pair, as follows.
      //    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)
      //    a high-surrogate value (U+D8FF)
      //    an invalid low surrogate (U+01FF)
      String s = "za\u0306\u01FD\u03B2";

      // Encode the string using little-endian byte order.
      int index = encExc.GetByteCount(s);
      Byte[] bytes = new Byte[index + 4];
      encExc.GetBytes(s, 0, s.Length, bytes, 0);
      bytes[index] = 0xFF;
      bytes[index + 1] = 0xD8;
      bytes[index + 2] = 0xFF;
      bytes[index + 3] = 0x01;

      // Decode the byte array with error detection.
      Console.WriteLine("Decoding with error detection:");
      PrintDecodedString(bytes, encExc);

      // Decode the byte array without error detection.
      Console.WriteLine("Decoding without error detection:");
      PrintDecodedString(bytes, encRepl);
   }

   // Decode the bytes and display the string.
   public static void PrintDecodedString(Byte[] bytes, Encoding enc)
   {
      try {
         Console.WriteLine("   Decoded string: {0}", enc.GetString(bytes, 0, bytes.Length));
      }
      catch (DecoderFallbackException e) {
         Console.WriteLine(e.ToString());
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Decoding with error detection:
//    System.Text.DecoderFallbackException: Unable to translate bytes [FF][D8][FF][01] at index
//    20 from specified code page to Unicode.
//       at System.Text.DecoderExceptionFallbackBuffer.Throw(Byte[] bytesUnknown, Int32 index)
//       at System.Text.DecoderExceptionFallbackBuffer.Fallback(Byte[] bytesUnknown, Int32 index
//    )
//       at System.Text.DecoderFallbackBuffer.InternalFallback(Byte[] bytes, Byte* pBytes)
//       at System.Text.UTF32Encoding.GetCharCount(Byte* bytes, Int32 count, DecoderNLS baseDeco
//    der)
//       at System.Text.UTF32Encoding.GetString(Byte[] bytes, Int32 index, Int32 count)
//       at Example.PrintDecodedString(Byte[] bytes, Encoding enc)
//
//    Decoding without error detection:
//       Decoded string: zăǽβ�

Imports System.Text

Public Module Example
   Public Sub Main()
      ' Create a UTF32Encoding object with error detection enabled.
      Dim encExc As New UTF32Encoding(Not BitConverter.IsLittleEndian, True, True)
      ' Create a UTF32Encoding object with error detection disabled.
      Dim encRepl As New UTF32Encoding(Not BitConverter.IsLittleEndian, True, False)

      ' Create a byte arrays from a string, and add an invalid surrogate pair, as follows.
      '    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)
      '    a high-surrogate value (U+D8FF)
      '    an invalid low surrogate (U+01FF)
      Dim s As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2)

      ' Encode the string using little-endian byte order.
      Dim index As Integer = encExc.GetBytecount(s)
      Dim bytes(index + 3) As Byte
      encExc.GetBytes(s, 0, s.Length, bytes, 0)
      bytes(index) = &hFF
      bytes(index + 1) = &hD8
      bytes(index + 2) = &hFF
      bytes(index + 3) = &h01

      ' Decode the byte array with error detection.
      Console.WriteLine("Decoding with error detection:")
      PrintDecodedString(bytes, encExc)

      ' Decode the byte array without error detection.
      Console.WriteLine("Decoding without error detection:")
      PrintDecodedString(bytes, encRepl)
   End Sub

   ' Decode the bytes and display the string.
   Public Sub PrintDecodedString(bytes() As Byte, enc As Encoding)
      Try
         Console.WriteLine("   Decoded string: {0}", enc.GetString(bytes, 0, bytes.Length))
      Catch e As DecoderFallbackException
         Console.WriteLine(e.ToString())
      End Try
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Decoding with error detection:
'    System.Text.DecoderFallbackException: Unable to translate bytes [FF][D8][FF][01] at index
'    20 from specified code page to Unicode.
'       at System.Text.DecoderExceptionFallbackBuffer.Throw(Byte[] bytesUnknown, Int32 index)
'       at System.Text.DecoderExceptionFallbackBuffer.Fallback(Byte[] bytesUnknown, Int32 index
'    )
'       at System.Text.DecoderFallbackBuffer.InternalFallback(Byte[] bytes, Byte* pBytes)
'       at System.Text.UTF32Encoding.GetCharCount(Byte* bytes, Int32 count, DecoderNLS baseDeco
'    der)
'       at System.Text.UTF32Encoding.GetString(Byte[] bytes, Int32 index, Int32 count)
'       at Example.PrintDecodedString(Byte[] bytes, Encoding enc)
'
'    Decoding without error detection:
'       Decoded string: zăǽβ�

O exemplo a seguir codifica uma cadeia de caracteres Unicode em uma matriz de bytes usando um UTF32Encoding objeto . A matriz de bytes é decodificada em uma cadeia de caracteres para demonstrar que não há perda de dados.

using System;
using System.Text;

public class Example
{
    public static void Main()
    {
        // The encoding.
        var enc = new UTF32Encoding();
        
        // Create a string.
        String s = "This string contains two characters " +
                   "with codes outside the ASCII code range: " +
                   "Pi (\u03A0) and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine("   {0}", s);
        
        // Encode the string.
        Byte[] encodedBytes = enc.GetBytes(s);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for (int ctr = 0; ctr < encodedBytes.Length; ctr++) {
            Console.Write("[{0:X2}]{1}", encodedBytes[ctr],
                                         (ctr + 1) % 4 == 0 ? " " : "" );
            if ((ctr + 1) % 16 == 0) Console.WriteLine();
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        // Notice Pi and Sigma characters are still present.
        String decodedString = enc.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded string:");
        Console.WriteLine("   {0}", decodedString);
    }
}
// The example displays the following output:
//    Original string:
//       This string contains two characters with codes outside the ASCII code range:
//    Pi (π) and Sigma (Σ).
//
//    Encoded bytes:
//    [54][00][00][00] [68][00][00][00] [69][00][00][00] [73][00][00][00]
//    [20][00][00][00] [73][00][00][00] [74][00][00][00] [72][00][00][00]
//    [69][00][00][00] [6E][00][00][00] [67][00][00][00] [20][00][00][00]
//    [63][00][00][00] [6F][00][00][00] [6E][00][00][00] [74][00][00][00]
//    [61][00][00][00] [69][00][00][00] [6E][00][00][00] [73][00][00][00]
//    [20][00][00][00] [74][00][00][00] [77][00][00][00] [6F][00][00][00]
//    [20][00][00][00] [63][00][00][00] [68][00][00][00] [61][00][00][00]
//    [72][00][00][00] [61][00][00][00] [63][00][00][00] [74][00][00][00]
//    [65][00][00][00] [72][00][00][00] [73][00][00][00] [20][00][00][00]
//    [77][00][00][00] [69][00][00][00] [74][00][00][00] [68][00][00][00]
//    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
//    [65][00][00][00] [73][00][00][00] [20][00][00][00] [6F][00][00][00]
//    [75][00][00][00] [74][00][00][00] [73][00][00][00] [69][00][00][00]
//    [64][00][00][00] [65][00][00][00] [20][00][00][00] [74][00][00][00]
//    [68][00][00][00] [65][00][00][00] [20][00][00][00] [41][00][00][00]
//    [53][00][00][00] [43][00][00][00] [49][00][00][00] [49][00][00][00]
//    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
//    [65][00][00][00] [20][00][00][00] [72][00][00][00] [61][00][00][00]
//    [6E][00][00][00] [67][00][00][00] [65][00][00][00] [3A][00][00][00]
//    [20][00][00][00] [50][00][00][00] [69][00][00][00] [20][00][00][00]
//    [28][00][00][00] [A0][03][00][00] [29][00][00][00] [20][00][00][00]
//    [61][00][00][00] [6E][00][00][00] [64][00][00][00] [20][00][00][00]
//    [53][00][00][00] [69][00][00][00] [67][00][00][00] [6D][00][00][00]
//    [61][00][00][00] [20][00][00][00] [28][00][00][00] [A3][03][00][00]
//    [29][00][00][00] [2E][00][00][00]
//
//    Decoded string:
//       This string contains two characters with codes outside the ASCII code range:
//    Pi (π) and Sigma (Σ).

Imports System.Text

Class Example
    Public Shared Sub Main()
        ' The encoding.
        Dim enc As New UTF32Encoding()
        
        ' Create a string.
        Dim s As String =
            "This string contains two characters " &
            "with codes outside the ASCII code range: " &
            "Pi (" & ChrW(&h03A0) & ") and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine("   {0}", s)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = enc.GetBytes(s)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        For ctr As Integer = 0 To encodedBytes.Length - 1
            Console.Write("[{0:X2}]{1}", encodedBytes(ctr),
                                         If((ctr + 1) Mod 4 = 0, " ", "" ))
            If (ctr + 1) Mod 16 = 0 Then Console.WriteLine()
        Next
        Console.WriteLine()
        
        ' Decode bytes back to string.
        ' Notice Pi and Sigma characters are still present.
        Dim decodedString As String = enc.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded string:")
        Console.WriteLine("   {0}", decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'       This string contains two characters with codes outside the ASCII code range:
'    Pi (π) and Sigma (Σ).
'
'    Encoded bytes:
'    [54][00][00][00] [68][00][00][00] [69][00][00][00] [73][00][00][00]
'    [20][00][00][00] [73][00][00][00] [74][00][00][00] [72][00][00][00]
'    [69][00][00][00] [6E][00][00][00] [67][00][00][00] [20][00][00][00]
'    [63][00][00][00] [6F][00][00][00] [6E][00][00][00] [74][00][00][00]
'    [61][00][00][00] [69][00][00][00] [6E][00][00][00] [73][00][00][00]
'    [20][00][00][00] [74][00][00][00] [77][00][00][00] [6F][00][00][00]
'    [20][00][00][00] [63][00][00][00] [68][00][00][00] [61][00][00][00]
'    [72][00][00][00] [61][00][00][00] [63][00][00][00] [74][00][00][00]
'    [65][00][00][00] [72][00][00][00] [73][00][00][00] [20][00][00][00]
'    [77][00][00][00] [69][00][00][00] [74][00][00][00] [68][00][00][00]
'    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
'    [65][00][00][00] [73][00][00][00] [20][00][00][00] [6F][00][00][00]
'    [75][00][00][00] [74][00][00][00] [73][00][00][00] [69][00][00][00]
'    [64][00][00][00] [65][00][00][00] [20][00][00][00] [74][00][00][00]
'    [68][00][00][00] [65][00][00][00] [20][00][00][00] [41][00][00][00]
'    [53][00][00][00] [43][00][00][00] [49][00][00][00] [49][00][00][00]
'    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
'    [65][00][00][00] [20][00][00][00] [72][00][00][00] [61][00][00][00]
'    [6E][00][00][00] [67][00][00][00] [65][00][00][00] [3A][00][00][00]
'    [20][00][00][00] [50][00][00][00] [69][00][00][00] [20][00][00][00]
'    [28][00][00][00] [A0][03][00][00] [29][00][00][00] [20][00][00][00]
'    [61][00][00][00] [6E][00][00][00] [64][00][00][00] [20][00][00][00]
'    [53][00][00][00] [69][00][00][00] [67][00][00][00] [6D][00][00][00]
'    [61][00][00][00] [20][00][00][00] [28][00][00][00] [A3][03][00][00]
'    [29][00][00][00] [2E][00][00][00]
'
'    Decoded string:
'       This string contains two characters with codes outside the ASCII code range:
'    Pi (π) and Sigma (Σ).

O exemplo a seguir usa a mesma cadeia de caracteres que a anterior, exceto que ele grava os bytes codificados em um arquivo e prefixa o fluxo de bytes com uma marca de ordem de byte (BOM). Em seguida, ele lê o arquivo de duas maneiras diferentes: como um arquivo de texto usando um StreamReader objeto e como um arquivo binário. Como era de se esperar, nenhuma cadeia de caracteres recém-lida inclui a BOM.

using System;
using System.IO;
using System.Text;

public class Example
{
    public static void Main()
    {
        // Create a UTF-32 encoding that supports a BOM.
        var enc = new UTF32Encoding();
        
        // A Unicode string with two characters outside an 8-bit code range.
        String s = "This Unicode string has 2 characters " +
                   "outside the ASCII range: \n" +
                   "Pi (\u03A0), and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(s);
        Console.WriteLine();
        
        // Encode the string.
        Byte[] encodedBytes = enc.GetBytes(s);
        Console.WriteLine("The encoded string has {0} bytes.\n",
                          encodedBytes.Length);

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF32Encoding.txt", FileMode.Create);
        Byte[] bom = enc.GetPreamble();
        fs.Write(bom, 0, bom.Length);
        fs.Write(encodedBytes, 0, encodedBytes.Length);
        Console.WriteLine("Wrote {0} bytes to the file.\n", fs.Length);
        fs.Close();

        // Open the file using StreamReader.
        var sr = new StreamReader(@".\UTF32Encoding.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(@".\Utf32Encoding.txt", FileMode.Open);
        Byte[] bytes = new Byte[fs.Length];
        fs.Read(bytes, 0, (int)fs.Length);
        fs.Close();

        String decodedString = enc.GetString(bytes);
        Console.WriteLine("Decoded bytes from binary file:");
        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 340 bytes.
//
//    Wrote 344 bytes to the file.
//
//    String read using StreamReader:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Decoded bytes from binary file:
//    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-32 encoding that supports a BOM.
        Dim enc As New UTF32Encoding()
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim s 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(s)
        Console.WriteLine()
        
        ' Encode the string.
        Dim encodedBytes As Byte() = enc.GetBytes(s)
        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(".\UTF32Encoding.txt", FileMode.Create)
        Dim bom() As Byte = enc.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(".\UTF32Encoding.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(".\Utf32Encoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = enc.GetString(bytes)
        Console.WriteLine("Decoded bytes from binary file:")
        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 344 bytes.
'
'    Wrote 348 bytes to the file.
'
'    String read using StreamReader:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Decoded bytes from binary file:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

Comentários

A codificação é o processo de transformar um conjunto de caracteres Unicode em uma sequência de bytes. A decodificação é o processo de transformação de uma sequência de bytes codificados em um conjunto de caracteres Unicode.

O Padrão Unicode atribui um ponto de código (um número) a cada caractere em cada script com suporte. Um UTF (Formato de Transformação Unicode) é uma maneira de codificar esse ponto de código. O Padrão Unicode usa os seguintes UTFs:

UTF-8, que representa cada ponto de código como uma sequência de um a quatro bytes.
UTF-16, que representa cada ponto de código como uma sequência de um a dois inteiros de 16 bits.
UTF-32, que representa cada ponto de código como um inteiro de 32 bits.

Para obter mais informações sobre os UTFs e outras codificações compatíveis com System.Texto , consulte Codificação de caracteres no .NET.

A UTF32Encoding classe representa uma codificação UTF-32. O codificador pode usar a ordem de byte big endian (byte mais significativo primeiro) ou a ordem de byte do pequeno endian (byte menos significativo primeiro). Por exemplo, a Letra Maiúscula Latina A (ponto de código U+0041) é serializada da seguinte maneira (em hexadecimal):

Ordem de bytes big endian: 00 00 00 41
Ordem de byte little endian: 41 00 00 00

Em geral, é mais eficiente armazenar caracteres Unicode usando a ordem de bytes nativa. Por exemplo, é melhor usar a ordem little endian byte em plataformas little endian, como computadores Intel. UTF32Encoding corresponde às páginas de código do Windows 12000 (ordem de bytes little endian) e 12001 (ordem de bytes big endian). Você pode determinar a "endianness" de uma arquitetura específica chamando o BitConverter.IsLittleEndian método .

Opcionalmente, o UTF32Encoding objeto fornece uma BOM (marca de ordem de byte), que é uma matriz de bytes que pode ser prefixada para a sequência de bytes resultante do processo de codificação. Se o preâmbulo contiver uma BOM (marca de ordem de byte), ele ajudará o decodificador a determinar a ordem de bytes e o formato de transformação ou UTF de uma matriz de bytes.

Se a UTF32Encoding instância estiver configurada para fornecer uma BOM, você poderá recuperá-la chamando o GetPreamble método ; caso contrário, o método retornará uma matriz vazia. Observe que, mesmo que um UTF32Encoding objeto esteja configurado para suporte à BOM, você deve incluir a BOM no início do fluxo de bytes codificado conforme apropriado; os métodos de codificação da UTF32Encoding classe não fazem isso automaticamente.

Cuidado

Para habilitar a detecção de erros e tornar a instância de classe mais segura, você deve instanciar um UTF32Encoding objeto chamando o UTF32Encoding(Boolean, Boolean, Boolean) construtor e definindo seu throwOnInvalidBytes argumento truecomo . Com a detecção de erros, um método que detecta uma sequência inválida de caracteres ou bytes gera uma exceção ArgumentException . Sem a detecção de erros, nenhuma exceção é gerada e a sequência inválida geralmente é ignorada.

Você pode criar uma instância de um UTF32Encoding objeto de várias maneiras, dependendo se deseja fornecer uma BOM (marca de ordem de byte), se deseja codificação big-endian ou little-endian e se deseja habilitar a detecção de erros. A tabela a seguir lista os UTF32Encoding construtores e as Encoding propriedades que retornam um UnicodeEncoding objeto .

Membro	Endianness	BOM	Detecção de erro
Encoding.UTF32	Little-endian	Sim	Não (fallback de substituição)
UTF32Encoding.UTF32Encoding()	Little-endian	Sim	Não (fallback de substituição)
UTF32Encoding.UTF32Encoding(Boolean, Boolean)	Configurável	Configurável	Não (fallback de substituição)
UTF32Encoding.UTF32Encoding(Boolean, Boolean, Boolean)	Configurável	Configurável	Configurável

O GetByteCount método determina quantos bytes resultam na codificação de um conjunto de caracteres Unicode e o GetBytes método executa a codificação real.

Da mesma forma, o GetCharCount método determina quantos caracteres resultam na decodificação de uma sequência de bytes e os GetChars métodos e GetString executam a decodificação real.

Para um codificador ou decodificador capaz de salvar informações de estado ao codificar ou decodificar dados que abrangem vários blocos (como cadeia de caracteres de 1 milhão de caracteres codificados em segmentos de 100.000 caracteres), use as GetEncoder propriedades e GetDecoder , respectivamente.

Construtores

UTF32Encoding()	Inicializa uma nova instância da classe UTF32Encoding.
UTF32Encoding(Boolean, Boolean)	Inicializa uma nova instância da classe UTF32Encoding. Os parâmetros especificam se é necessário usar a ordem de byte big endian e se o método GetPreamble() retorna uma marca de ordem de byte Unicode.
UTF32Encoding(Boolean, Boolean, Boolean)	Inicializa uma nova instância da classe UTF32Encoding. Os parâmetros especificam se é necessário usar a ordem de byte big endian, fornecer uma marca de ordem de byte Unicode e gerar uma exceção quando uma codificação inválida for detectada.

Propriedades

BodyName	Quando substituído em uma classe derivada, obtém um nome para a codificação atual que pode ser usado com marcas de corpo do agente de email. (Herdado de Encoding)
CodePage	Quando é substituído em uma classe derivada, obtém o identificador de página de código do Encoding atual. (Herdado de Encoding)
DecoderFallback	Obtém ou define o objeto DecoderFallback para o objeto Encoding atual. (Herdado de Encoding)
EncoderFallback	Obtém ou define o objeto EncoderFallback para o objeto Encoding atual. (Herdado de Encoding)
EncodingName	Quando substituído em uma classe derivada, obtém a descrição legível por humanos da codificação atual. (Herdado de Encoding)
HeaderName	Quando substituído em uma classe derivada, obtém um nome para a codificação atual que pode ser usado com marcas de cabeçalho do agente de email. (Herdado de Encoding)
IsBrowserDisplay	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual pode ser usada por clientes do navegador para exibir conteúdo. (Herdado de Encoding)
IsBrowserSave	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual pode ser usada por clientes do navegador para salvar conteúdo. (Herdado de Encoding)
IsMailNewsDisplay	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual pode ser usada por clientes do navegador e email para exibir conteúdo. (Herdado de Encoding)
IsMailNewsSave	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual pode ser usada por clientes do navegador e email para salvar conteúdo. (Herdado de Encoding)
IsReadOnly	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual é somente leitura. (Herdado de Encoding)
IsSingleByte	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual usa pontos de código de byte único. (Herdado de Encoding)
Preamble	Obtém uma marca de ordem de byte Unicode codificada no formato UTF-32 caso o objeto de codificação esteja configurado para fornecer uma.
Preamble	Quando substituído em uma classe derivada, retorna um intervalo que contém a sequência de bytes que especifica a codificação usada. (Herdado de Encoding)
WebName	Quando substituído em uma classe derivada, obtém o nome registrado na IANA (Internet Assigned Numbers Authority) da codificação atual. (Herdado de Encoding)
WindowsCodePage	Quando substituído em uma classe derivada, obtém a página de código de sistema operacional Windows que mais bem corresponde à codificação atual. (Herdado de Encoding)

Métodos

Clone()	Quando substituído em uma classe derivada, cria uma cópia superficial do objeto Encoding atual. (Herdado de Encoding)
Equals(Object)	Determina se o Object especificado é igual ao objeto UTF32Encoding atual.
GetByteCount(Char*, Int32)	Calcula o número de bytes produzidos ao codificar um conjunto de caracteres, começando no ponteiro de caracteres especificado.
GetByteCount(Char[])	Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de todos os caracteres na matriz de caracteres especificada. (Herdado de Encoding)
GetByteCount(Char[], Int32, Int32)	Calcula o número de bytes produzidos codificando um conjunto de caracteres da matriz de caracteres especificada.
GetByteCount(ReadOnlySpan<Char>)	Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação dos caracteres no intervalo de caracteres especificado. (Herdado de Encoding)
GetByteCount(String)	Calcula o número de bytes produzidos codificando todos os caracteres no String especificado.
GetByteCount(String, Int32, Int32)	Quando substituído em uma classe derivada, calcula o número de bytes produzidos pela codificação de um conjunto de caracteres da cadeia de caracteres especificada. (Herdado de Encoding)
GetBytes(Char, Int32, Byte, Int32)	Codifica um conjunto de caracteres começando no ponteiro de caractere especificado em uma sequência de bytes armazenados começando no ponteiro de byte especificado.
GetBytes(Char[])	Quando substituído em uma classe derivada, codifica todos os caracteres na matriz de caracteres especificada em uma sequência de bytes. (Herdado de Encoding)
GetBytes(Char[], Int32, Int32)	Quando substituído em uma classe derivada, codifica um conjunto de caracteres na matriz de caracteres especificada em uma sequência de bytes. (Herdado de Encoding)
GetBytes(Char[], Int32, Int32, Byte[], Int32)	Codifica um conjunto de caracteres da matriz de caracteres especificada na matriz de bytes especificada.
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	Quando substituído em uma classe derivada, codifica em um intervalo de bytes um conjunto de caracteres do intervalo somente leitura especificado. (Herdado de Encoding)
GetBytes(String)	Quando substituído em uma classe derivada, codifica todos os caracteres na cadeia de caracteres especificada em uma sequência de bytes. (Herdado de Encoding)
GetBytes(String, Int32, Int32)	Quando substituído em uma classe derivada, codifica em uma matriz de bytes o número de caracteres especificado por `count` na cadeia de caracteres especificada, começando do `index` especificado. (Herdado de Encoding)
GetBytes(String, Int32, Int32, Byte[], Int32)	Codifica um conjunto de caracteres do String especificado para a matriz de bytes especificada.
GetCharCount(Byte*, Int32)	Calcula o número de caracteres produzidos pela decodificação de uma sequência de bytes começando no ponteiro de bytes especificado.
GetCharCount(Byte[])	Quando substituído em uma classe derivada, calcula o número de caracteres produzidos decodificando todos os bytes na matriz de bytes especificada. (Herdado de Encoding)
GetCharCount(Byte[], Int32, Int32)	Calcula o número de caracteres produzidos pela decodificação de uma sequência de bytes da matriz de bytes especificada.
GetCharCount(ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, calcula o número de caracteres produzidos decodificando o intervalo de bytes somente leitura fornecido. (Herdado de Encoding)
GetChars(Byte, Int32, Char, Int32)	Decodifica uma sequência de bytes começando no ponteiro de byte especificado em um conjunto de caracteres armazenados começando no ponteiro de caractere especificado.
GetChars(Byte[])	Quando substituído em uma classe derivada, decodifica todos os bytes na matriz de bytes especificada em um conjunto de caracteres. (Herdado de Encoding)
GetChars(Byte[], Int32, Int32)	Quando substituído em uma classe derivada, decodifica uma sequência de bytes da matriz de bytes especificada em um conjunto de caracteres. (Herdado de Encoding)
GetChars(Byte[], Int32, Int32, Char[], Int32)	Decodifica uma sequência de bytes da matriz de bytes especificada na matriz de caracteres especificada.
GetChars(ReadOnlySpan<Byte>, Span<Char>)	Quando substituído em uma classe derivada, decodifica todos os bytes no intervalo de bytes somente leitura especificado em um intervalo de caracteres. (Herdado de Encoding)
GetDecoder()	Obtém um decodificador que converte uma sequência de bytes codificada em UTF-32 em uma sequência de caracteres Unicode.
GetEncoder()	Obtém um codificador que converte uma sequência de caracteres Unicode em uma sequência de bytes codificada em UTF-32.
GetHashCode()	Retorna o código hash para a instância atual.
GetMaxByteCount(Int32)	Calcula o número máximo de bytes produzidos pela codificação do número de caracteres especificado.
GetMaxCharCount(Int32)	Calcula o número máximo de caracteres produzidos decodificando o número de bytes especificado.
GetPreamble()	Retornará uma marca de ordem de byte Unicode codificada no formato UTF-32, se o objeto de codificação UTF32Encoding for configurado para fornecer uma.
GetString(Byte*, Int32)	Quando substituído em uma classe derivada, decodifica um número especificado de bytes, começando em um endereço especificado em uma cadeia de caracteres. (Herdado de Encoding)
GetString(Byte[])	Quando substituído em uma classe derivada, decodifica todos os bytes na matriz de bytes especificada em uma cadeia de caracteres. (Herdado de Encoding)
GetString(Byte[], Int32, Int32)	Decodifica um intervalo de bytes de uma matriz de bytes em uma cadeia de caracteres.
GetString(ReadOnlySpan<Byte>)	Quando substituído em uma classe derivada, decodifica todos os bytes no intervalo de bytes especificado em uma cadeia de caracteres. (Herdado de Encoding)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
IsAlwaysNormalized()	Obtém um valor que indica se a codificação atual sempre é normalizada usando o formulário de normalização padrão. (Herdado de Encoding)
IsAlwaysNormalized(NormalizationForm)	Quando substituído em uma classe derivada, obtém um valor que indica se a codificação atual sempre é normalizada usando a forma de normalização especificada. (Herdado de Encoding)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TryGetBytes(ReadOnlySpan<Char>, Span<Byte>, Int32)	Codifica em um intervalo de bytes um conjunto de caracteres do intervalo somente leitura especificado se o destino for grande o suficiente. (Herdado de Encoding)
TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32)	Decodifica em um intervalo de caracteres um conjunto de bytes do intervalo somente leitura especificado se o destino for grande o suficiente. (Herdado de Encoding)

Métodos de Extensão

GetBytes(Encoding, ReadOnlySequence<Char>)	Codifica o ReadOnlySequence<T> especificado em uma matriz Byte usando o Encoding especificado.
GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)	Decodifica o ReadOnlySequence<T> especificado para `byte`s usando o Encoding especificado e grava o resultado em `writer`.
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	Codifica o ReadOnlySequence<T> especificado para `byte`s usando o Encoding especificado e gera o resultado para `bytes`.
GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)	Codifica o ReadOnlySpan<T> especificado para `byte`s usando o Encoding especificado e grava o resultado em `writer`.
GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)	Decodifica o ReadOnlySequence<T> especificado para `char`s usando o Encoding especificado e grava o resultado em `writer`.
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	Decodifica o ReadOnlySequence<T> especificado para `char`s usando o Encoding especificado e gera o resultado para `chars`.
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	Decodifica o ReadOnlySpan<T> especificado para `char`s usando o Encoding especificado e grava o resultado em `writer`.
GetString(Encoding, ReadOnlySequence<Byte>)	Decodifica o ReadOnlySequence<T> especificado em um String usando o Encoding especificado.

Aplica-se a

Partilhar via