Encoding-Klasse

Stellt eine Zeichencodierung dar.

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

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Encoding
    Implements ICloneable
'Usage
Dim instance As Encoding

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public abstract class Encoding : ICloneable

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

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public abstract class Encoding implements ICloneable

SerializableAttribute 
ComVisibleAttribute(true) 
public abstract class Encoding implements ICloneable

Hinweise

Beim Codieren werden Unicode-Zeichen in eine Bytefolge transformiert. Beim Decodieren wird dieser Vorgang umgekehrt: Eine Folge codierter Bytes wird dabei 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 ein bis vier Bytes dargestellt wird.

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

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

.NET-Framework stellt folgende Implementierungen der Encoding-Klasse zur Unterstützung der aktuellen Unicode-Codierungen und anderer Codierungen bereit:

• ASCIIEncoding codiert Unicode-Zeichen als einzelne 7-Bit-ASCII-Zeichen. Diese Codierung unterstützt nur Zeichenwerte zwischen U+0000 und U+007F. Codepage 20127. Auch verfügbar durch die ASCII-Eigenschaft.

• UTF7Encoding codiert Unicode-Zeichen mit der UTF-7-Codierung. Diese Codierung unterstützt alle Unicode-Zeichenwerte. Codepage 65000. Auch verfügbar durch die UTF7-Eigenschaft.

• UTF8Encoding codiert Unicode-Zeichen mit der UTF-8-Codierung. Diese Codierung unterstützt alle Unicode-Zeichenwerte. Codepage 65001. Auch verfügbar durch die UTF8-Eigenschaft.

• UnicodeEncoding codiert Unicode-Zeichen mit der UTF-16-Codierung. Dabei werden die Bytereihenfolgen Little-Endian (Codepage 1200) und Big-Endian (Codepage 1201) unterstützt. Auch verfügbar durch die Unicode-Eigenschaft und die BigEndianUnicode-Eigenschaft.

• UTF32Encoding codiert Unicode-Zeichen mit der UTF-32-Codierung. Dabei werden die Bytereihenfolgen Little-Endian (Codepage 65005) und Big-Endian (Codepage 65006) unterstützt. Auch verfügbar durch die UTF32-Eigenschaft.

Verwenden Sie die GetEncoding-Methode, um andere Codierungen zu erhalten. Verwenden Sie die GetEncodings-Methode, um eine Liste mit allen Codierungen abzurufen.

In der folgenden Tabelle sind die Codierungen und ihre zugeordneten Codepages aufgeführt. Ein Sternchen in der letzten Spalte zeigt an, dass die Codepage unabhängig von der zugrunde liegenden Plattform von .NET Framework unterstützt 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 führt die tatsächliche Decodierung aus.

Wenn die zu konvertierenden Daten nur als sequenzielle Blöcke verfügbar sind (z. B. aus einem Stream gelesene Daten) oder wenn die Datenmenge so groß ist, dass sie in kleinere Blöcke aufgeteilt werden muss, verwenden Sie Decoder oder Encoder, die von der GetDecoder-Methode bzw. der GetEncoder-Methode einer abgeleiteten Klasse bereitgestellt werden.

Die UTF-16- und UTF-32-Encoder können 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 (U+0041) wie folgt serialisiert (Hexadezimalwert):

• UTF-16-Big-Endian-Bytereihenfolge: 00 41

• UTF-16-Little-Endian-Bytereihenfolge: 41 00

• UTF-32-Big-Endian-Bytereihenfolge: 00 00 00 41

• UTF-32-Little-Endian-Bytereihenfolge: 41 00 00 00

Optional stellt Encoding 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 (in Unicode: Codepunkt U+FEFF) enthält, kann der Decoder daraus die Bytereihenfolge und das Transformationsformat bzw. UTF ermitteln. Die Unicode-Bytereihenfolgemarkierung wird wie folgt serialisiert (hexadezimal):

• UTF-8: EF BB BF

• UTF-16-Big-Endian-Bytereihenfolge: FE FF

• UTF-16-Little-Endian-Bytereihenfolge: FF FE

• UTF-32-Big-Endian-Bytereihenfolge: 00 00 FE FF

• UTF-32-Little-Endian-Bytereihenfolge: FF FE 00 00

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

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

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

Beispiel

Im folgenden Codebeispiel wird eine Zeichenfolge von einer Codierung in eine andere konvertiert.

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 

Vererbungshierarchie

System.Object
  System.Text.Encoding
     Abgeleitete Klassen

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

Encoding-Member
System.Text-Namespace