Classe Encoding (System.Text)

La codifica è il processo di trasformazione di un insieme di caratteri Unicode in una sequenza di byte. La decodifica è il processo inverso, ovvero la trasformazione di una sequenza di byte codificati in un insieme di caratteri Unicode.

Secondo lo standard Unicode viene assegnato un punto di codice (un numero) a ciascun carattere in ogni script supportato. Un formato UTF (Unicode Transformation Format) consente di codificare tale punto di codice. Nello standard Unicode versione 3.2 vengono utilizzati i seguenti formati UTF:

• UTF-8, che rappresenta ogni punto di codice come una sequenza da uno a quattro byte.

• UTF-16, che rappresenta ogni punto di codice come una sequenza di uno o due valori integer a 16 bit.

• UTF-32, che rappresenta ogni punto di codice come valore integer a 32 bit.

Di seguito sono riportate le implementazioni della classe Encoding fornite da .NET Framework per supportare le attuali codifiche Unicode e altre codifiche:

• ASCIIEncoding consente di codificare caratteri Unicode come caratteri singoli ASCII a 7 bit. La codifica supporta solo valori di carattere compresi tra U+0000 e U+007F. Tabella codici 20127. Disponibile anche tramite la proprietà ASCII.

• UTF7Encoding codifica i caratteri Unicode utilizzando la codifica UTF-7. La codifica supporta i valori di tutti i caratteri Unicode. Tabella codici 65000. Disponibile anche tramite la proprietà UTF7.

• UTF8Encoding codifica i caratteri Unicode utilizzando la codifica UTF-8. La codifica supporta i valori di tutti i caratteri Unicode. Tabella codici 65001. Disponibile anche tramite la proprietà UTF8.

• UnicodeEncoding codifica i caratteri Unicode utilizzando la codifica UTF-16. Sono supportati gli ordini di byte "little-endian" (tabella codici 1200) e "big-endian" (tabella codici 1201). Disponibile anche tramite le proprietà Unicode e BigEndianUnicode.

• UTF32Encoding codifica i caratteri Unicode utilizzando la codifica UTF-32. Sono supportati gli ordini di byte "little-endian" (tabella codici 65005) e "big-endian" (tabella codici 65006). Disponibile anche tramite la proprietà UTF32.

Utilizzare il metodo GetEncoding per ottenere altre codifiche. Utilizzare il metodo GetEncodings per ottenere un elenco di tutte le modifiche.

Nella tabella riportata di seguito sono elencate tutte le codifiche e le tabelle codici associate. Un asterisco visualizzato nell'ultima colonna indica che la tabella codici è supportata in modo nativo da .NET Framework, indipendentemente dalla piattaforma sottostante.

Il metodo GetByteCount consente di determinare il numero di byte risultanti dalla codifica di un set di caratteri Unicode, mentre il metodo GetBytes consente di eseguire la codifica.

Analogamente, il metodo GetCharCount consente di determinare il numero di caratteri risultanti dalla decodifica di una sequenza di byte, mentre il metodo GetChars esegue la decodifica effettiva.

Se i dati da convertire sono disponibili solo in blocchi sequenziali (ad esempio i dati letti da un flusso) o se la quantità di dati è talmente elevata da richiedere la suddivisione in blocchi di dimensioni inferiori, utilizzare l'oggetto Decoder o Encoder fornito dal metodo GetDecoder o GetEncoder, rispettivamente, di una classe derivata.

I codificatori UTF-16 e UTF-32 possono utilizzare l'ordine dei byte big-endian (byte più significativo al primo posto) o little-endian (byte meno significativo al primo posto). La lettera A maiuscola dell'alfabeto latino (U+0041), ad esempio, è serializzata come segue in formato esadecimale:

• Ordine dei byte big-endian UTF-16: 00 41

• Ordine dei byte little-endian UTF-16: 41 00

• Ordine dei byte big-endian UTF-32: 00 00 00 41

• Ordine dei byte little-endian UTF-32: 41 00 00 00

L'oggetto Encoding può anche fornire un preambolo, ovvero una matrice di byte utilizzabile come prefisso della sequenza di byte risultante dal processo di codifica. Se il preambolo contiene un indicatore per l'ordine dei byte (in Unicode, punto di codice U+FEFF), consente al decodificatore di determinare l'ordine dei byte e il formato di trasformazione o UTF. L'indicatore per l'ordine dei byte Unicode è serializzato come segue (in formato esadecimale):

• UTF-8: EF BB BF

• Ordine dei byte big-endian UTF-16: FE FF

• Ordine dei byte little-endian UTF-16: FF FE

• Ordine dei byte big-endian UTF-32: 00 00 FE FF

• Ordine dei byte little-endian UTF-32: FF FE 00 00

In genere è più efficiente l'archiviazione dei caratteri Unicode nell'ordine dei byte nativo. Si consiglia ad esempio di utilizzare l'ordine dei byte little-endian su piattaforme little-endian, quali i computer Intel.

Il metodo GetPreamble restituisce una matrice di byte che può includere l'indicatore dell'ordine dei byte. Se questa matrice di byte viene utilizzata come prefisso di un flusso codificato, consente al decodificatore di identificare il formato di codifica utilizzato.

Per ulteriori informazioni sull'ordine dei byte e sull'indicatore per l'ordine dei byte, vedere lo standard Unicode all'indirizzo www.unicode.org (informazioni in lingua inglese).

Nell'esempio di codice riportato di seguito una stringa viene convertita da una codifica a un'altra.

Imports System
Imports System.Text
Imports Microsoft.VisualBasic

Namespace Convert_Example
    Class MyConvertExampleClass
        Shared Sub Main()
            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[].
            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[] into a char[] and then into a string.
            ' This is a slightly different approach to converting to illustrate
            ' the use of GetCharCount/GetChars.
            Dim asciiChars(ascii.GetCharCount(asciiBytes, 0, asciiBytes.Length)) 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
End Namespace

using System;
using System.Text;

namespace ConvertExample
{
   class ConvertExampleClass
   {
      static void Main()
      {
         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[].
         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.
         // This is a slightly different approach to converting to illustrate
         // the use of GetCharCount/GetChars.
         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);
      }
   }
}

using namespace System;
using namespace System::Text;
int main()
{
   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->Item[].
   array<Byte>^unicodeBytes = unicode->GetBytes( unicodeString );
   
   // Perform the conversion from one encoding to the other.
   array<Byte>^asciiBytes = Encoding::Convert( unicode, ascii, unicodeBytes );
   
   // Convert the new Byte into[] a char and[] then into a string.
   // This is a slightly different approach to converting to illustrate
   // the use of GetCharCount/GetChars.
   array<Char>^asciiChars = gcnew array<Char>(ascii->GetCharCount( asciiBytes, 0, asciiBytes->Length ));
   ascii->GetChars( asciiBytes, 0, asciiBytes->Length, asciiChars, 0 );
   String^ asciiString = gcnew String( asciiChars );
   
   // Display the strings created before and after the conversion.
   Console::WriteLine( "Original String*: {0}", unicodeString );
   Console::WriteLine( "Ascii converted String*: {0}", asciiString );
}

package ConvertExample; 

import System.*;
import System.Text.*;

class ConvertExampleClass
{
    public static void main(String[] args)
    {
        String unicodeString = 
                "This string contains the unicode character Pi(\u03a0)";

        // Create two different encodings.
        Encoding ascii = Encoding.get_ASCII();
        Encoding unicode = Encoding.get_Unicode();

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

        // Perform the conversion from one encoding to the other.
        ubyte asciiBytes[] = Encoding.Convert(unicode, ascii, unicodeBytes);

        // Convert the new byte[] into a char[] and then into a string.
        // This is a slightly different approach to converting to illustrate
        // the use of GetCharCount/GetChars.
        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);
    } //main
} //ConvertExampleClass 

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

.NET Compact Framework