UnicodeEncoding Klas

Definitie

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

Overname

Object

Encoding

UnicodeEncoding

Kenmerken

SerializableAttribute ComVisibleAttribute

Voorbeelden

In het volgende voorbeeld ziet u hoe u een tekenreeks met Unicode-tekens in een bytematrix kunt coderen met behulp van een UnicodeEncoding object. De bytematrix wordt gedecodeerd in een tekenreeks om aan te tonen dat er geen gegevensverlies is.

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

In het volgende voorbeeld wordt dezelfde tekenreeks als de vorige gebruikt, behalve dat de gecodeerde bytes naar een bestand worden geschreven en de bytestroom voorafgaat door een bytevolgordemarkering (BOM). Vervolgens wordt het bestand op twee verschillende manieren gelezen: als tekstbestand met behulp van een StreamReader object en als binair bestand. Zoals u zou verwachten, bevat geen nieuwe tekenreeks de 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 (Σ).

Opmerkingen

Encoding is het proces van het transformeren van een set Unicode-tekens in een reeks bytes. Decodering is het proces van het transformeren van een reeks gecodeerde bytes in een set Unicode-tekens.

De Unicode-standaard wijst een codepunt (een getal) toe aan elk teken in elk ondersteund script. Een Unicode Transformation Format (UTF) is een manier om dat codepunt te coderen. De Unicode-standaard maakt gebruik van de volgende UDF's:

• UTF-8, die elk codepunt vertegenwoordigt als een reeks van één tot vier bytes.

• UTF-16, die elk codepunt vertegenwoordigt als een reeks van één tot twee 16-bits gehele getallen.

• UTF-32, die elk codepunt vertegenwoordigt als een 32-bits geheel getal.

Zie Character Encoding in het .NET Framework voor meer informatie over de UDF's en andere coderingen die worden ondersteund door System.Text.

De UnicodeEncoding klasse vertegenwoordigt een UTF-16-codering. De encoder kan de volgorde van big endian byte (de belangrijkste byte eerst) of een kleine bytevolgorde (minst significante byte eerst) gebruiken. De Latijnse hoofdletter A (codepunt U+0041) wordt bijvoorbeeld als volgt geserialiseerd (in hexadecimaal):

• Big endian byte order: 00 00 00 41

• Little endian byte order: 41 00 00 00

Het is over het algemeen efficiënter om Unicode-tekens op te slaan met behulp van de systeemeigen bytevolgorde van een bepaald platform. Het is bijvoorbeeld beter om de bytevolgorde little endian te gebruiken op little endian-platforms, zoals Intel-computers. De klasse UnicodeEncoding komt overeen met de Windows codepagina's 1200 (little endian byte order) en 1201 (big endian byte order). U kunt de 'endianness' van een bepaalde architectuur bepalen door de methode aan te BitConverter.IsLittleEndian roepen.

Optioneel biedt het UnicodeEncoding object een bytevolgordemarkering (BOM), een matrix van bytes die kan worden voorafgegaan door de reeks bytes die het gevolg zijn van het coderingsproces. Als de preambule een bytevolgorde (BOM) bevat, helpt de decoder de bytevolgorde en de transformatienotatie of UTF te bepalen.

Als het UnicodeEncoding exemplaar is geconfigureerd om een stuklijst op te geven, kunt u deze ophalen door de GetPreamble methode aan te roepen. Anders retourneert de methode een lege matrix. Houd er rekening mee dat, zelfs als een UnicodeEncoding object is geconfigureerd voor BOM-ondersteuning, u de BOM moet opnemen aan het begin van de gecodeerde bytestroom, indien van toepassing. De coderingsmethoden van de UnicodeEncoding klasse doen dit niet automatisch.

U kunt een UnicodeEncoding object op verschillende manieren instantiëren, afhankelijk van of u een bytevolgordemarkering (BOM) wilt opgeven, of u nu big-endian- of little-endian-codering wilt, en of u foutdetectie wilt inschakelen. De volgende tabel bevat de UnicodeEncoding constructors en de Encoding eigenschappen die een UnicodeEncoding object retourneren.

De GetByteCount methode bepaalt hoeveel bytes resulteren in het coderen van een set Unicode-tekens en de GetBytes methode voert de daadwerkelijke codering uit.

Op dezelfde manier bepaalt de GetCharCount methode hoeveel tekens resulteren in het decoderen van een reeks bytes, en de GetChars en GetString methoden voeren de daadwerkelijke decodering uit.

Voor een encoder of decoder die statusinformatie kan opslaan bij het coderen of decoderen van gegevens die meerdere blokken omvatten (zoals een tekenreeks van 1 miljoen tekens die in segmenten van 100.000 tekens zijn gecodeerd), gebruikt u respectievelijk de GetEncoder en GetDecoder eigenschappen.

Zie ook

• Encoding
• Encoder
• Decoder
• UTF32Encoding
• UTF8Encoding
• UTF7Encoding
• ASCIIEncoding
• UnicodeCategory
• CharUnicodeInfo
• Informatie over coderingen