Encoding Classe

Definição

public ref class Encoding abstract

public ref class Encoding abstract : ICloneable

public abstract class Encoding

public abstract class Encoding : ICloneable

[System.Serializable]
public abstract class Encoding

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Encoding : ICloneable

type Encoding = class

type Encoding = class
    interface ICloneable

[<System.Serializable>]
type Encoding = class

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Encoding = class
    interface ICloneable

Public MustInherit Class Encoding

Public MustInherit Class Encoding
Implements ICloneable

Herança

Object

Encoding

Derivado

System.Text.ASCIIEncoding

System.Text.UnicodeEncoding

System.Text.UTF32Encoding

System.Text.UTF7Encoding

System.Text.UTF8Encoding

Atributos

SerializableAttribute ComVisibleAttribute

Implementações

ICloneable

Exemplos

O exemplo a seguir converte uma cadeia de caracteres de uma codificação para outra.

using System;
using System.Text;

class ConvertExample
{
   static void Run()
   {
      string unicodeString = "This string contains the unicode character Pi (\u03a0)";

      // Create two different encodings.
      Encoding ascii = Encoding.ASCII;
      Encoding unicode = Encoding.Unicode;

      // Convert the string into a byte array.
      byte[] unicodeBytes = unicode.GetBytes(unicodeString);

      // Perform the conversion from one encoding to the other.
      byte[] asciiBytes = Encoding.Convert(unicode, ascii, unicodeBytes);
         
      // Convert the new byte[] into a char[] and then into a string.
      char[] asciiChars = new char[ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)];
      ascii.GetChars(asciiBytes, 0, asciiBytes.Length, asciiChars, 0);
      string asciiString = new string(asciiChars);

      // Display the strings created before and after the conversion.
      Console.WriteLine("Original string: {0}", unicodeString);
      Console.WriteLine("Ascii converted string: {0}", asciiString);
   }
}

// The example displays the following output:
//    Original string: This string contains the unicode character Pi (Π)
//    Ascii converted string: This string contains the unicode character Pi (?)

Imports System.Text

Class Example1
   Shared Sub Run()
      Dim unicodeString As String = "This string contains the unicode character Pi (" & ChrW(&H03A0) & ")"

      ' Create two different encodings.
      Dim ascii As Encoding = Encoding.ASCII
      Dim unicode As Encoding = Encoding.Unicode

      ' Convert the string into a byte array.
      Dim unicodeBytes As Byte() = unicode.GetBytes(unicodeString)

      ' Perform the conversion from one encoding to the other.
      Dim asciiBytes As Byte() = Encoding.Convert(unicode, ascii, unicodeBytes)

      ' Convert the new byte array into a char array and then into a string.
      Dim asciiChars(ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)-1) As Char
      ascii.GetChars(asciiBytes, 0, asciiBytes.Length, asciiChars, 0)
      Dim asciiString As New String(asciiChars)

      ' Display the strings created before and after the conversion.
      Console.WriteLine("Original string: {0}", unicodeString)
      Console.WriteLine("Ascii converted string: {0}", asciiString)
   End Sub
End Class
' The example displays the following output:
'    Original string: This string contains the unicode character Pi (Π)
'    Ascii converted string: This string contains the unicode character Pi (?)

Comentários

A Encoding classe representa uma codificação de caracteres.

A codificação é o processo de transformação de um conjunto de caracteres Unicode em uma sequência de bytes. Por outro lado, a decodificação é o processo de transformar uma sequência de bytes codificados em um conjunto de caracteres Unicode. Para obter informações sobre os UTFs (Formatos de Transformação Unicode) e outras codificações com Encodingsuporte, consulte Codificação de Caracteres no .NET.

Encoding destina-se a operar em caracteres Unicode em vez de dados binários arbitrários, como matrizes de bytes. Se você precisar codificar dados binários arbitrários em texto, deverá usar um protocolo como uuencode, que é implementado por métodos como Convert.ToBase64CharArray.

O .NET fornece as seguintes implementações da Encoding classe para dar suporte a codificações Unicode atuais e outras codificações:

• ASCIIEncoding codifica caracteres Unicode como caracteres ASCII de 7 bits únicos. Essa codificação só dá suporte a valores de caractere entre U+0000 e U+007F. Página de código 20127. Também disponível pela propriedade ASCII.

• UTF7Encoding codifica caracteres Unicode usando a codificação UTF-7. Essa codificação dá suporte a todos os valores de caractere Unicode. Página de código 65000. Também disponível pela propriedade UTF7.

• UTF8Encoding codifica caracteres Unicode usando a codificação UTF-8. Essa codificação dá suporte a todos os valores de caractere Unicode. Página de código 65001. Também disponível pela propriedade UTF8.

• UnicodeEncoding codifica caracteres Unicode usando a codificação UTF-16. Há suporte para ordens de byte little endian e big endian. Também disponível pela propriedade Unicode e pela propriedade BigEndianUnicode.

• UTF32Encoding codifica caracteres Unicode usando a codificação UTF-32. Os pedidos de bytes little endian (página de código 12000) e big endian (página de código 12001) contam com suporte. Também disponível pela propriedade UTF32.

A Encoding classe destina-se principalmente a converter entre codificações diferentes e Unicode. Geralmente, uma das classes Unicode derivadas é a escolha correta para seu aplicativo.

Use o GetEncoding método para obter outras codificações e chame o GetEncodings método para obter uma lista de todas as codificações.

Lista de codificações

A tabela a seguir lista as codificações compatíveis com o .NET. Ele lista o número da página de código de cada codificação e os valores das propriedades EncodingInfo.Name e EncodingInfo.DisplayName da codificação. Uma marca de verificação no suporte ao .NET Framework, suporte ao .NET Core ou suporte ao .NET 5 e posterior indica que a página de código é suportada nativamente por essa implementação do .NET, independentemente da plataforma subjacente. Para o .NET Framework, a disponibilidade de outras codificações listadas na tabela depende do sistema operacional. Para versões .NET Core e .NET 5 e posteriores, outras codificações estão disponíveis usando a System.Text.CodePagesEncodingProvider classe ou derivando da System.Text.EncodingProvider classe.

O exemplo a seguir chama os métodos GetEncoding(Int32) e GetEncoding(String) para obter a codificação da página de código grego (Windows). Ele compara os Encoding objetos retornados pelas chamadas de método para mostrar que eles são iguais e, em seguida, mapeia e exibe o ponto de código Unicode e o valor da página de código correspondente para cada caractere no alfabeto grego.

using System;
using System.Text;

public class GetEncodingExample
{
   public static void Run()
   {
      Encoding enc = Encoding.GetEncoding(1253);
      Encoding altEnc = Encoding.GetEncoding("windows-1253");
      Console.WriteLine($"{enc.EncodingName} = Code Page {altEnc.CodePage}: {enc.Equals(altEnc)}");
      string greekAlphabet = "Α α Β β Γ γ Δ δ Ε ε Ζ ζ Η η " +
                             "Θ θ Ι ι Κ κ Λ λ Μ μ Ν ν Ξ ξ " +
                             "Ο ο Π π Ρ ρ Σ σ ς Τ τ Υ υ " +
                             "Φ φ Χ χ Ψ ψ Ω ω";
      Console.OutputEncoding = Encoding.UTF8;
      byte[] bytes = enc.GetBytes(greekAlphabet);
      Console.WriteLine("{0,-12} {1,20} {2,20:X2}", "Character",
                        "Unicode Code Point", "Code Page 1253");
      for (int ctr = 0; ctr < bytes.Length; ctr++) {
         if (greekAlphabet[ctr].Equals(' '))
            continue;

         Console.WriteLine("{0,-12} {1,20} {2,20:X2}", greekAlphabet[ctr],
                           GetCodePoint(greekAlphabet[ctr]), bytes[ctr]);
      }
   }

   private static string GetCodePoint(char ch)
   {
      string retVal = "u+";
      byte[] bytes = Encoding.Unicode.GetBytes(ch.ToString());
      for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
         retVal += bytes[ctr].ToString("X2");

      return retVal;
   }
}

// The example displays the following output:
//       Character      Unicode Code Point       Code Page 1253
//       Α                          u+0391                   C1
//       α                          u+03B1                   E1
//       Β                          u+0392                   C2
//       β                          u+03B2                   E2
//       Γ                          u+0393                   C3
//       γ                          u+03B3                   E3
//       Δ                          u+0394                   C4
//       δ                          u+03B4                   E4
//       Ε                          u+0395                   C5
//       ε                          u+03B5                   E5
//       Ζ                          u+0396                   C6
//       ζ                          u+03B6                   E6
//       Η                          u+0397                   C7
//       η                          u+03B7                   E7
//       Θ                          u+0398                   C8
//       θ                          u+03B8                   E8
//       Ι                          u+0399                   C9
//       ι                          u+03B9                   E9
//       Κ                          u+039A                   CA
//       κ                          u+03BA                   EA
//       Λ                          u+039B                   CB
//       λ                          u+03BB                   EB
//       Μ                          u+039C                   CC
//       μ                          u+03BC                   EC
//       Ν                          u+039D                   CD
//       ν                          u+03BD                   ED
//       Ξ                          u+039E                   CE
//       ξ                          u+03BE                   EE
//       Ο                          u+039F                   CF
//       ο                          u+03BF                   EF
//       Π                          u+03A0                   D0
//       π                          u+03C0                   F0
//       Ρ                          u+03A1                   D1
//       ρ                          u+03C1                   F1
//       Σ                          u+03A3                   D3
//       σ                          u+03C3                   F3
//       ς                          u+03C2                   F2
//       Τ                          u+03A4                   D4
//       τ                          u+03C4                   F4
//       Υ                          u+03A5                   D5
//       υ                          u+03C5                   F5
//       Φ                          u+03A6                   D6
//       φ                          u+03C6                   F6
//       Χ                          u+03A7                   D7
//       χ                          u+03C7                   F7
//       Ψ                          u+03A8                   D8
//       ψ                          u+03C8                   F8
//       Ω                          u+03A9                   D9
//       ω                          u+03C9                   F9

Imports System.Text

Module Example2
   Public Sub Run()
      Dim enc As Encoding = Encoding.GetEncoding(1253)
      Dim altEnc As Encoding = Encoding.GetEncoding("windows-1253")
      Console.WriteLine("{0} = Code Page {1}: {2}", enc.EncodingName,
                        altEnc.CodePage, enc.Equals(altEnc))
      Dim greekAlphabet As String = "Α α Β β Γ γ Δ δ Ε ε Ζ ζ Η η " +
                                    "Θ θ Ι ι Κ κ Λ λ Μ μ Ν ν Ξ ξ " +
                                    "Ο ο Π π Ρ ρ Σ σ ς Τ τ Υ υ " +
                                    "Φ φ Χ χ Ψ ψ Ω ω"
      Console.OutputEncoding = Encoding.UTF8
      Dim bytes() As Byte = enc.GetBytes(greekAlphabet)
      Console.WriteLine("{0,-12} {1,20} {2,20:X2}", "Character",
                        "Unicode Code Point", "Code Page 1253")
      For ctr As Integer = 0 To bytes.Length - 1
         If greekAlphabet(ctr).Equals(" "c) Then Continue For

         Console.WriteLine("{0,-12} {1,20} {2,20:X2}", greekAlphabet(ctr),
                           GetCodePoint(greekAlphabet(ctr)), bytes(ctr))
      Next

   End Sub

   Private Function GetCodePoint(ch As String) As String
      Dim retVal As String = "u+"
      Dim bytes() As Byte = Encoding.Unicode.GetBytes(ch)
      For ctr As Integer = bytes.Length - 1 To 0 Step -1
         retVal += bytes(ctr).ToString("X2")
      Next
      Return retVal
   End Function
End Module
' The example displays the following output:
'    Character      Unicode Code Point       Code Page 1253
'    Α                          u+0391                   C1
'    α                          u+03B1                   E1
'    Β                          u+0392                   C2
'    β                          u+03B2                   E2
'    Γ                          u+0393                   C3
'    γ                          u+03B3                   E3
'    Δ                          u+0394                   C4
'    δ                          u+03B4                   E4
'    Ε                          u+0395                   C5
'    ε                          u+03B5                   E5
'    Ζ                          u+0396                   C6
'    ζ                          u+03B6                   E6
'    Η                          u+0397                   C7
'    η                          u+03B7                   E7
'    Θ                          u+0398                   C8
'    θ                          u+03B8                   E8
'    Ι                          u+0399                   C9
'    ι                          u+03B9                   E9
'    Κ                          u+039A                   CA
'    κ                          u+03BA                   EA
'    Λ                          u+039B                   CB
'    λ                          u+03BB                   EB
'    Μ                          u+039C                   CC
'    μ                          u+03BC                   EC
'    Ν                          u+039D                   CD
'    ν                          u+03BD                   ED
'    Ξ                          u+039E                   CE
'    ξ                          u+03BE                   EE
'    Ο                          u+039F                   CF
'    ο                          u+03BF                   EF
'    Π                          u+03A0                   D0
'    π                          u+03C0                   F0
'    Ρ                          u+03A1                   D1
'    ρ                          u+03C1                   F1
'    Σ                          u+03A3                   D3
'    σ                          u+03C3                   F3
'    ς                          u+03C2                   F2
'    Τ                          u+03A4                   D4
'    τ                          u+03C4                   F4
'    Υ                          u+03A5                   D5
'    υ                          u+03C5                   F5
'    Φ                          u+03A6                   D6
'    φ                          u+03C6                   F6
'    Χ                          u+03A7                   D7
'    χ                          u+03C7                   F7
'    Ψ                          u+03A8                   D8
'    ψ                          u+03C8                   F8
'    Ω                          u+03A9                   D9
'    ω                          u+03C9                   F9

Se os dados a serem convertidos estiverem disponíveis apenas em blocos sequenciais (como dados lidos de um fluxo) ou se a quantidade de dados for tão grande que precisar ser dividida em blocos menores, você deverá usar o Decoder método ou Encoder o GetDecoder método fornecido pelo GetEncoder método, respectivamente, de uma classe derivada.

Os codificadores UTF-16 e UTF-32 podem usar a ordem de byte big endian (com o byte mais significativo primeiro) ou a ordem de byte little endian (com o byte menos significativo primeiro). Por exemplo, a Letra Maiúscula Latina A (U+0041) é serializada da seguinte maneira (em hexadecimal):

• A ordem de bytes de big endian UTF-16: 00 41
• A ordem de bytes de little endian UTF-16: 41 00
• A ordem de bytes de big endian UTF-32: 00 00 00 41
• A ordem de bytes de little endian UTF-32: 41 00 00 00

Geralmente, é mais eficiente armazenar caracteres Unicode usando a ordem de bytes nativa. Por exemplo, é melhor usar a ordem dos bytes de little endian em plataformas little endian, como computadores da Intel.

O GetPreamble método recupera uma matriz de bytes que inclui a marca de ordem de bytes (BOM). Se essa matriz de bytes for prefixada em um fluxo codificado, ela ajudará o decodificador a identificar o formato de codificação usado.

Para obter mais informações sobre a ordem de bytes e a marca de ordem de bytes, consulte o Padrão Unicode na home page unicode.

Observe que as classes de codificação permitem erros em:

• Troque silenciosamente para um caractere "?".
• Use um caractere "mais adequado".
• Troque por um comportamento específico do aplicativo com o uso das classes EncoderFallback e DecoderFallback com o caractere de substituição Unicode U+FFFD.

Você deve lançar uma exceção em qualquer erro de transmissão de dados. Um aplicativo usa um sinalizador "throwonerror" quando pertinente ou usa as classes EncoderExceptionFallback e DecoderExceptionFallback. Geralmente, o fallback de melhor ajuste não é recomendado, pois pode causar perda de dados ou confusão, além de ser mais lento do que substituições simples de caracteres. Para codificações ANSI, o melhor comportamento de ajuste é o padrão.

Confira também

• Como usar classes de codificação de caracteres no .NET