UnicodeEncoding Classe

Definição

public ref class UnicodeEncoding : System::Text::Encoding

public class UnicodeEncoding : System.Text.Encoding

[System.Serializable]
public class UnicodeEncoding : System.Text.Encoding

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class UnicodeEncoding : System.Text.Encoding

type UnicodeEncoding = class
    inherit Encoding

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

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

Public Class UnicodeEncoding
Inherits Encoding

Herança

Object

Encoding

UnicodeEncoding

Atributos

SerializableAttribute ComVisibleAttribute

Exemplos

O exemplo seguinte demonstra como codificar uma cadeia de caracteres Unicode num array de bytes usando um UnicodeEncoding objeto. O array de bytes é descodificado numa string para demonstrar que não há perda de dados.

using System;
using System.Text;

class UnicodeEncodingExample {
    public static void Main() {
        // The encoding.
        UnicodeEncoding unicode = new UnicodeEncoding();
        
        // Create a string that contains Unicode characters.
        String unicodeString =
            "This Unicode string contains two characters " +
            "with codes outside the traditional ASCII code range, " +
            "Pi (\u03a0) and Sigma (\u03a3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);

        // Encode the string.
        Byte[] encodedBytes = unicode.GetBytes(unicodeString);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        foreach (Byte b in encodedBytes) {
            Console.Write("[{0}]", b);
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        // Notice Pi and Sigma characters are still present.
        String decodedString = unicode.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded bytes:");
        Console.WriteLine(decodedString);
    }
}

Imports System.Text
Imports Microsoft.VisualBasic.Strings

Class UnicodeEncodingExample
    
    Public Shared Sub Main()
        ' The encoding.
        Dim uni As New UnicodeEncoding()
        
        ' Create a string that contains Unicode characters.
        Dim unicodeString As String = _
            "This Unicode string contains two characters " & _
            "with codes outside the traditional ASCII code range, " & _
            "Pi (" & ChrW(928) & ") and Sigma (" & ChrW(931) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine(unicodeString)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = uni.GetBytes(unicodeString)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        Dim b As Byte
        For Each b In  encodedBytes
            Console.Write("[{0}]", b)
        Next b
        Console.WriteLine()
        
        ' Decode bytes back to string.
        ' Notice Pi and Sigma characters are still present.
        Dim decodedString As String = uni.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded bytes:")
        Console.WriteLine(decodedString)
    End Sub
End Class

O exemplo seguinte usa a mesma cadeia de caracteres do anterior, exceto que escreve os bytes codificados num ficheiro e prefixa o fluxo de bytes com uma marca de ordem de bytes (BOM). Depois, lê o ficheiro de duas formas diferentes: como ficheiro de texto usando um StreamReader objeto; e como ficheiro binário. Como seria de esperar, nenhuma das sequências recém-lidas inclui a lista de materiais (BOM).

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

public class Example
{
   public static void Main()
   {
        // Create a UTF-16 encoding that supports a BOM.
        Encoding unicode = new UnicodeEncoding();

        // 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 = unicode.GetBytes(unicodeString);
        Console.WriteLine("The encoded string has {0} bytes.\n",
                          encodedBytes.Length);

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Create);
        Byte[] bom = unicode.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(@".\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 = unicode.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 172 bytes.
//
//    Wrote 174 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-16 encoding that supports a BOM.
        Dim unicode As New UnicodeEncoding()
        
        ' 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() = unicode.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(".\UnicodeEncoding.txt", FileMode.Create)
        Dim bom() As Byte = unicode.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(".\UnicodeEncoding.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(".\UnicodeEncoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = unicode.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 172 bytes.
'
'    Wrote 174 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 (Σ).

Observações

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

O Padrão Unicode atribui um ponto de código (um número) a cada carácter em cada script suportado. Um Formato de Transformação Unicode (UTF) é uma forma de codificar esse ponto de código. O Padrão Unicode utiliza 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 mais informações sobre as UTFs e outras codificações suportadas por System.Text, consulte Codificação de Caracteres no Framework .NET.

A UnicodeEncoding classe representa uma codificação UTF-16. O codificador pode usar ordem de bytes big endian (byte mais significativo primeiro) ou ordem de bytes little endian (byte mínimo significativo primeiro). Por exemplo, a letra maiúscula latina A (ponto de código U+0041) é serializada da seguinte forma (em hexadecimal):

• Ordem dos bytes big endian: 00 00 00 41

• Ordem de bytes do little endian: 41 00 00 00

É geralmente mais eficiente armazenar caracteres Unicode usando a ordem nativa dos bytes de uma determinada plataforma. Por exemplo, é melhor usar a ordem de bytes little endian em plataformas little endian, tais como computadores Intel. A classe UnicodeEncoding corresponde às páginas de código Windows 1200 (ordem dos bytes little endian) e 1201 (ordem dos bytes big endian). Pode determinar a "endianidade" de uma determinada arquitetura chamando o BitConverter.IsLittleEndian método.

Opcionalmente, o UnicodeEncoding objeto fornece uma marca de ordem de bytes (BOM), que é um array de bytes que pode ser prefixado à sequência de bytes resultante do processo de codificação. Se o preâmbulo contiver uma marca de ordem de bytes (BOM), ajuda o descodificador a determinar a ordem dos bytes e o formato de transformação ou UTF.

Se a UnicodeEncoding instância estiver configurada para fornecer uma lista de materiais (BOM), pode recuperá-la chamando o GetPreamble método; caso contrário, o método devolve um array vazio. Note que, mesmo que um UnicodeEncoding objeto esteja configurado para suporte a listas de bebidas, deve incluir a lista de materiais no início do fluxo de bytes codificados, conforme apropriado; os métodos de codificação da UnicodeEncoding classe não fazem isto automaticamente.

Podes instanciar um UnicodeEncoding objeto de várias formas, dependendo se queres que ele forneça uma marca de ordem de bytes (BOM), se queres codificação big-endian ou little-endian, e se queres ativar a deteção de erros. A tabela seguinte lista os UnicodeEncoding construtores e as Encoding propriedades que retornam um UnicodeEncoding objeto.

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 propriamente dita.

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 propriamente dita.

Para um codificador ou descodificador que consiga guardar informação de estado ao codificar ou decodificar dados que abrangem vários blocos (como uma cadeia de 1 milhão de caracteres codificada em segmentos de 100.000 caracteres), use as GetEncoder propriedades e GetDecoder respetivamente.

Ver também

• Encoding
• Encoder
• Decoder
• UTF32Encoding
• UTF8Encoding
• UTF7Encoding
• ASCIIEncoding
• UnicodeCategory
• CharUnicodeInfo
• Compreensão das Codificações