UnicodeEncoding Klasse

Definition

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

Vererbung

Object

Encoding

UnicodeEncoding

Attribute

SerializableAttribute ComVisibleAttribute

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie eine Zeichenfolge von Unicode-Zeichen mithilfe eines -Objekts in ein UnicodeEncoding Bytearray codiert wird. Das Bytearray wird in eine Zeichenfolge decodiert, um zu demonstrieren, dass es keinen Datenverlust gibt.

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

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

Im folgenden Beispiel wird dieselbe Zeichenfolge wie die vorherige Zeichenfolge verwendet, mit der Ausnahme, dass die codierten Bytes in eine Datei geschrieben und dem Bytedatenstrom eine Bytereihenfolgemarkierung (BOM) vorangestellt wird. Anschließend wird die Datei auf zwei verschiedene Arten gelesen: als Textdatei mithilfe eines StreamReader -Objekts und als Binärdatei. Wie zu erwarten, enthält keine neu gelesene Zeichenfolge die 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 (Σ).

Hinweise

Beim Kodieren werden Unicode-Zeichen in eine Bytefolge transformiert. Die Decodierung ist der Prozess der Transformation einer Sequenz codierter Bytes in einen Satz von Unicode-Zeichen.

Gemäß Unicode-Standard werden jedem Zeichen aller unterstützten Skripts ein Codepunkt (eine Zahl) und ein Name zugewiesen. Ein Unicode Transformation Format (UTF) ist eine Möglichkeit, diesen Codepunkt zu codieren. Der Unicode-Standard verwendet die folgenden UTFs:

• UTF-8, das jeden Codepunkt als Sequenz von ein bis vier Bytes darstellt.

• UTF-16, das jeden Codepunkt als Sequenz von ein bis zwei ganzzahligen 16-Bit-Zahlen darstellt.

• UTF-32, das jeden Codepunkt als ganze 32-Bit-Zahl darstellt.

Weitere Informationen zu den UTFs und anderen von System.Textunterstützten Codierungen finden Sie unter Zeichencodierung im .NET Framework.

Die UnicodeEncoding -Klasse stellt eine UTF-16-Codierung dar. Der Encoder kann entweder big endian byte order (most significant byte first) oder little endian byte order (least significant byte first) verwenden. Beispielsweise wird der lateinische Großbuchstaben A (Codepunkt U+0041) wie folgt serialisiert (hexadezimal):

• Big Endian Byte Order: 00 00 00 41

• Little Endian Byte Order: 41 00 00 00

Es ist im Allgemeinen effizienter, Unicode-Zeichen mithilfe der nativen Bytereihenfolge einer bestimmten Plattform zu speichern. Beispielsweise ist es besser, die Little-Endian-Byte Reihenfolge auf kleinen Endian-Plattformen wie z. b. Intel-Computern zu verwenden. Die UnicodeEncoding -Klasse entspricht den Windows-Codepages 1200 (Little-Endian-Bytereihenfolge) und 1201 (Big Endian-Bytereihenfolge). Sie können die Endianität einer bestimmten Architektur bestimmen, indem Sie die BitConverter.IsLittleEndian -Methode aufrufen.

Optional stellt das UnicodeEncoding -Objekt eine Bytereihenfolgemarkierung (BOM) bereit, bei der es sich um ein Bytearray handelt, das der Bytesequenz, die sich aus dem Codierungsprozess ergibt, vorangestellt werden kann. Wenn die Präambel eine Bytereihenfolgemarke (BOM) enthält, hilft sie dem Decoder dabei, die Bytereihenfolge und das Transformationsformat oder UTF zu bestimmen.

Wenn die UnicodeEncoding instance so konfiguriert ist, dass sie eine Stückliste bereitstellt, können Sie sie abrufen, indem Sie die GetPreamble -Methode aufrufen. Andernfalls gibt die Methode ein leeres Array zurück. Beachten Sie, dass Sie auch dann, wenn ein UnicodeEncoding Objekt für die BoM-Unterstützung konfiguriert ist, die BoM nach Bedarf am Anfang des codierten Bytestroms einschließen müssen. Die Codierungsmethoden der Klasse tun dies UnicodeEncoding nicht automatisch.

Sie können ein UnicodeEncoding Objekt auf verschiedene Arten instanziieren, je nachdem, ob Sie eine Bytereihenfolgemarkierung (BOM) bereitstellen möchten, ob Sie eine Big-Endian- oder Little-Endian-Codierung wünschen und ob Sie die Fehlererkennung aktivieren möchten. In der folgenden Tabelle sind die UnicodeEncoding Konstruktoren und die Eigenschaften aufgeführt, die Encoding ein UnicodeEncoding Objekt zurückgeben.

Die GetByteCount -Methode bestimmt, wie viele Bytes zum Codieren eines Satzes von Unicode-Zeichen führen, und die- GetBytes Methode führt die eigentliche Codierung aus.

Ebenso bestimmt die GetCharCount Methode, wie viele Zeichen zum Decodieren einer Bytesequenz führen, und die GetChars Methoden und GetString führen die tatsächliche Decodierung aus.

Für einen Encoder oder Decoder, der zum Speichern von Zustandsinformationen, die beim Codieren oder Decodieren von Daten, die umfasst mehrere Blöcke (z. B. String von 1 Mio. Zeichen, die in Segmenten von 100.000 Zeichen codiert wird) verwenden, können die GetEncoder und GetDecoder Eigenschaften bzw.

Konstruktoren

Felder

Eigenschaften

Methoden

Erweiterungsmethoden

Gilt für:

Weitere Informationen

• Encoding
• Encoder
• Decoder
• UTF32Encoding
• UTF8Encoding
• UTF7Encoding
• ASCIIEncoding
• UnicodeCategory
• CharUnicodeInfo
• Grundlegendes zu Codierungen