UnicodeEncoding-Klasse

Stellt eine UTF-16-Codierung von Unicode-Zeichen dar.

Namespace: System.Text
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Class UnicodeEncoding
    Inherits Encoding
'Usage
Dim instance As UnicodeEncoding

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public class UnicodeEncoding : Encoding

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public ref class UnicodeEncoding : public Encoding

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public class UnicodeEncoding extends Encoding

SerializableAttribute 
ComVisibleAttribute(true) 
public class UnicodeEncoding extends Encoding

Hinweise

Beim Codieren werden Unicode-Zeichen in eine Bytefolge transformiert. Beim Decodieren wird dieser Vorgang umgekehrt: Eine Folge codierter Bytes wird in Unicode-Zeichen transformiert.

Gemäß Unicode-Standard wird jedem Zeichen aller unterstützten Schriften ein Codepunkt (eine Zahl) zugewiesen. Dieser Codepunkt kann beispielsweise mit UTF (Unicode Transformation Format) codiert werden. Im Unicode-Standard, Version 3.2, werden folgende UTFs verwendet:

• UTF-8, bei dem jeder Codepunkt als eine Folge von einem bis vier Bytes dargestellt wird.

• UTF-16, bei dem jeder Codepunkt als eine Folge von einer bis zwei 16-Bit-Ganzzahlen dargestellt wird.

• UTF-32, bei dem jeder Codepunkt als eine 32-Bit-Ganzzahl dargestellt wird.

Die GetByteCount-Methode bestimmt, wie viele Bytes zum Codieren von Unicode-Zeichen benötigt werden, und die GetBytes-Methode führt die tatsächliche Codierung aus.

Ebenso bestimmt die GetCharCount-Methode, wie viele Zeichen sich aus der Decodierung einer Bytefolge ergeben, und die GetChars-Methode sowie die GetString-Methode führen die eigentliche Decodierung aus.

Der Encoder kann die Big-Endian-Bytereihenfolge (mit dem höchstwertigen Byte an erster Stelle) oder die Little-Endian-Bytereihenfolge (mit dem niedrigstwertigen Byte an erster Stelle) verwenden. Beispielsweise wird der lateinische Großbuchstabe A (Codepunkt U+0041) wie folgt serialisiert (Hexadezimalwert):

• Big-Endian-Bytereihenfolge: 00 41

• Little-Endian-Bytereihenfolge: 41 00

Optional stellt UnicodeEncoding eine Präambel bereit. Dabei handelt es sich um ein Bytearray, das der Bytefolge vorangestellt werden kann, die sich aus dem Codierungsprozess ergibt. Falls die Präambel eine Bytereihenfolgemarkierung (Codepunkt U+FEFF) enthält, kann der Decoder daraus die Bytereihenfolge und das Transformationsformat oder UTF ermitteln. Die Unicode-Bytereihenfolgemarkierung wird wie folgt serialisiert (Hexadezimalwert):

• Big-Endian-Bytereihenfolge: FE FF

• Little-Endian-Bytereihenfolge: FF FE

Im Allgemeinen ist es effizienter, Unicode-Zeichen in der systemeigenen Bytereihenfolge zu speichern. Beispielsweise ist es besser, die Little-Endian-Bytereihenfolge auf entsprechenden Plattformen, z. B. auf Intel-Computern, zu verwenden.

Die GetPreamble-Methode gibt ein Bytearray zurück, das die Bytereihenfolgemarkierung enthält. Wenn dieses Bytearray einem codierten Stream vorangestellt ist, unterstützt es den Decoder bei der Ermittlung des verwendeten Codierungsformats.

Weitere Informationen über die Unicode-Codierung, die Bytereihenfolge und die Bytereihenfolgemarkierung finden Sie im Unicode-Standard unter http://www.unicode.org (nur auf Englisch verfügbar).

UnicodeEncoding entspricht den Windows-Codepages 1200 (Little-Endian-Bytereihenfolge) und 1201 (Big-Endian-Bytereihenfolge).

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie die Zeichenfolge von Unicode-Zeichen mit UnicodeEncoding in ein Bytearray codiert wird. Das Bytearray wird zurück in eine Zeichenfolge decodiert, um zu demonstrieren, dass kein Datenverlust auftritt.

Imports System
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

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);
    }
}

using namespace System;
using namespace System::Text;
using namespace System::Collections;
int main()
{
   
   // The encoding.
   UnicodeEncoding^ unicode = gcnew UnicodeEncoding;
   
   // Create a String* that contains Unicode characters.
   String^ unicodeString = L"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*.
   array<Byte>^encodedBytes = unicode->GetBytes( unicodeString );
   Console::WriteLine();
   Console::WriteLine( "Encoded bytes:" );
   IEnumerator^ myEnum = encodedBytes->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Byte b = safe_cast<Byte>(myEnum->Current);
      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 );
}

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

class UnicodeEncodingExample
{
    public static void main(String[] args)
    {
        // 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.
        ubyte encodedBytes[] = unicode.GetBytes(unicodeString);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for(int iCtr = 0; iCtr < encodedBytes.length; iCtr++) {
            ubyte b = encodedBytes[iCtr];
            Console.Write("[{0}]", String.valueOf(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);
    } //main
} //UnicodeEncodingExample

Vererbungshierarchie

System.Object
   System.Text.Encoding
    System.Text.UnicodeEncoding

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

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

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

UnicodeEncoding-Member
System.Text-Namespace
Encoding-Klasse
Encoder-Klasse
Decoder-Klasse
UTF32Encoding
UTF8Encoding
UTF7Encoding
ASCIIEncoding-Klasse
System.Globalization.UnicodeCategory
System.Globalization.CharUnicodeInfo