UnicodeEncoding Klasse

Definition

Namespace:

System.Text

Assembly:

System.Text.Encoding.Extensions.dll

Quelle:

UnicodeEncoding.cs

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

public ref class UnicodeEncoding : System::Text::Encoding

public class UnicodeEncoding : System.Text.Encoding

type UnicodeEncoding = class
    inherit Encoding

Public Class UnicodeEncoding
Inherits Encoding

Vererbung

Object

Encoding

UnicodeEncoding

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.

Achtung

Um die Fehlererkennung zu aktivieren und die Klasse instance sicherer zu machen, sollten Sie ein UnicodeEncoding Objekt instanziieren, indem Sie den Konstruktor aufrufen und sein throwOnInvalidBytesUnicodeEncoding(Boolean, Boolean, Boolean) Argument auf truefestlegen. Bei der Fehlererkennung löst eine Methode, die eine ungültige Sequenz von Zeichen oder Bytes erkennt, einen aus ArgumentException. Ohne Fehlererkennung wird keine Ausnahme ausgelöst, und die ungültige Sequenz wird im Allgemeinen ignoriert.

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.

Mitglied	Endianness	BOM	Fehlererkennung
BigEndianUnicode	Big-Endian	Ja	Nein (Ersatzfallback)
Encoding.Unicode	Little-Endian	Ja	Nein (Ersatzfallback)
UnicodeEncoding.UnicodeEncoding()	Little-Endian	Ja	Nein (Ersatzfallback)
UnicodeEncoding(Boolean, Boolean)	Konfigurierbar	Konfigurierbar	Nein (Ersatzfallback)
UnicodeEncoding.UnicodeEncoding(Boolean, Boolean, Boolean)	Konfigurierbar	Konfigurierbar	Konfigurierbar

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

UnicodeEncoding()	Initialisiert eine neue Instanz der UnicodeEncoding-Klasse.
UnicodeEncoding(Boolean, Boolean)	Initialisiert eine neue Instanz der UnicodeEncoding-Klasse. Parameter geben an, ob die Big-Endian-Bytereihenfolge verwendet werden soll und die GetPreamble()-Methode eine Unicode-Bytereihenfolgemarkierung zurückgibt.
UnicodeEncoding(Boolean, Boolean, Boolean)	Initialisiert eine neue Instanz der UnicodeEncoding-Klasse. Parameter geben an, ob die Big-Endian-Bytereihenfolge verwendet, eine Unicode-Bytereihenfolgemarkierung bereitgestellt und beim Erkennen einer ungültigen Codierung eine Ausnahme ausgelöst werden soll.

Felder

CharSize

Stellt die Unicode-Zeichengröße in Bytes dar. Dieses Feld ist konstant.

Eigenschaften

BodyName	Beim Überschreiben in einer abgeleiteten Klasse wird ein Name für die aktuelle Codierung abgerufen, die mit den Body-Tags des E-Mail-Agenten verwendet werden kann. (Geerbt von Encoding)
CodePage	Ruft den Codepagebezeichner der aktuellen Encoding-Klasse beim Überschreiben in einer abgeleiteten Klasse ab. (Geerbt von Encoding)
DecoderFallback	Ruft das DecoderFallback-Objekt für das aktuelle Encoding-Objekt ab. (Geerbt von Encoding)
EncoderFallback	Ruft das EncoderFallback-Objekt für das aktuelle Encoding-Objekt ab. (Geerbt von Encoding)
EncodingName	Beim Überschreiben in einer abgeleiteten Klasse wird die Klartextbeschreibung der aktuellen Codierung abgerufen. (Geerbt von Encoding)
HeaderName	Beim Überschreiben in einer abgeleiteten Klasse wird ein Name für die aktuelle Codierung abgerufen, die mit den Header-Tags des E-Mail-Agenten verwendet werden kann. (Geerbt von Encoding)
IsBrowserDisplay	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Browserclients zum Anzeigen des Inhalts verwendet werden kann. (Geerbt von Encoding)
IsBrowserSave	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Browserclients zum Speichern von Inhalt verwendet werden kann. (Geerbt von Encoding)
IsMailNewsDisplay	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Mail- und Newsclients zum Anzeigen von Inhalt verwendet werden kann. (Geerbt von Encoding)
IsMailNewsSave	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Mail- und Newsclients zum Speichern von Inhalt verwendet werden kann. (Geerbt von Encoding)
IsReadOnly	Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob die aktuelle Codierung schreibgeschützt ist. (Geerbt von Encoding)
IsSingleByte	Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob die aktuelle Codierung Einzelbyte-Codepunkte verwendet. (Geerbt von Encoding)
Preamble	Ruft eine Unicode-Bytereihenfolgemarkierung im UTF-16-Format ab, wenn dieses Objekt entsprechend konfiguriert ist.
WebName	Beim Überschreiben in einer abgeleiteten Klasse wird der Name für die aktuelle Codierung bei der Internet Assigned Numbers Authority (IANA) registriert. (Geerbt von Encoding)
WindowsCodePage	Beim Überschreiben in einer abgeleiteten Klasse wird die Codepage des Betriebssystems Windows abgerufen, die der aktuellen Codierung am ehesten entspricht. (Geerbt von Encoding)

Methoden

Clone()	Erstellt beim Überschreiben in einer abgeleiteten Klasse eine flache Kopie des aktuellen Encoding-Objekts. (Geerbt von Encoding)
Equals(Object)	Bestimmt, ob das angegebene Object und das aktuelle UnicodeEncoding-Objekt gleich sind.
GetByteCount(Char*, Int32)	Berechnet die Anzahl der Bytes, die beim Codieren der Zeichen ab dem angegebenen Zeichenzeiger erzeugt werden.
GetByteCount(Char[])	Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren aller Zeichen im angegebenen Zeichenarray erzeugt werden. (Geerbt von Encoding)
GetByteCount(Char[], Int32, Int32)	Berechnet die Anzahl der Bytes, die beim Codieren der Zeichen aus dem angegebenen Zeichenarray erzeugt werden.
GetByteCount(ReadOnlySpan<Char>)	Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen in der angegebenen Zeichenspanne erzeugt werden. (Geerbt von Encoding)
GetByteCount(String)	Berechnet die Anzahl der Bytes, die beim Codieren der Zeichen in der angegebenen Zeichenfolge erzeugt werden.
GetByteCount(String, Int32, Int32)	Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl an Bytes, die beim Codieren der Zeichen aus der angegebenen Zeichenspanne erzeugt werden. (Geerbt von Encoding)
GetBytes(Char*, Int32, Byte*, Int32)	Codiert Zeichen beginnend am angegebenen Zeichenzeiger in eine Bytefolge, die beginnend am angegebenen Bytezeiger gespeichert wird.
GetBytes(Char[])	Beim Überschreiben in einer abgeleiteten Klasse werden alle Zeichen im angegebenen Zeichenarray in eine Bytefolge codiert. (Geerbt von Encoding)
GetBytes(Char[], Int32, Int32)	Beim Überschreiben in einer abgeleiteten Klasse werden die Zeichen im angegebenen Zeichenarray in eine Bytefolge codiert. (Geerbt von Encoding)
GetBytes(Char[], Int32, Int32, Byte[], Int32)	Codiert Zeichen aus dem angegebenen Zeichenarray in das angegebene Bytearray.
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	Codiert beim Überschreiben in einer abgeleiteten Klasse eine Gruppe von Zeichen aus der angegebenen schreibgeschützten Spanne in eine Bytespanne. (Geerbt von Encoding)
GetBytes(String)	Beim Überschreiben in einer abgeleiteten Klasse werden alle Zeichen in der angegebenen Zeichenfolge in eine Bytefolge codiert. (Geerbt von Encoding)
GetBytes(String, Int32, Int32)	Codiert beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die durch count in der angegebenen Zeichenfolge angegeben werden, ab dem angegebenen index in ein Bytearray. (Geerbt von Encoding)
GetBytes(String, Int32, Int32, Byte[], Int32)	Codiert Zeichen aus der angegebenen String-Klasse in das angegebene Bytearray.
GetCharCount(Byte*, Int32)	Berechnet die Anzahl der Zeichen, die beim Decodieren einer Bytefolge ab dem angegebenen Bytezeiger erzeugt werden.
GetCharCount(Byte[])	Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die beim Decodieren aller Bytes in dem angegebenen Bytearray erzeugt werden. (Geerbt von Encoding)
GetCharCount(Byte[], Int32, Int32)	Berechnet die Anzahl der Zeichen, die beim Decodieren einer Bytefolge aus dem angegebenen Bytearray erzeugt werden.
GetCharCount(ReadOnlySpan<Byte>)	Berechnet beim Überschreiben in einer abgeleiteten Klasse die Anzahl der Zeichen, die beim Decodieren der angegebenen schreibgeschützten Bytespanne erzeugt werden. (Geerbt von Encoding)
GetChars(Byte*, Int32, Char*, Int32)	Decodiert eine Bytefolge beginnend am angegebenen Bytezeiger in Zeichen, die beginnend am angegebenen Zeichenzeiger gespeichert werden.
GetChars(Byte[])	Beim Überschreiben in einer abgeleiteten Klasse werden alle Bytes im angegebenen Bytearray in Zeichen decodiert. (Geerbt von Encoding)
GetChars(Byte[], Int32, Int32)	Beim Überschreiben in einer abgeleiteten Klasse wird eine Bytefolge aus dem angegebenen Bytearray in Zeichen decodiert. (Geerbt von Encoding)
GetChars(Byte[], Int32, Int32, Char[], Int32)	Decodiert eine Bytefolge aus dem angegebenen Bytearray in das angegebene Zeichenarray.
GetChars(ReadOnlySpan<Byte>, Span<Char>)	Decodiert beim Überschreiben in einer abgeleiteten Klasse alle Bytes in der angegebenen schreibgeschützten Bytespanne in eine Zeichenspanne. (Geerbt von Encoding)
GetDecoder()	Ruft einen Decoder ab, der eine UTF-16-codierte Bytefolge in eine Unicode-Zeichenfolge konvertiert.
GetEncoder()	Ruft einen Encoder ab, der eine Unicode-Zeichenfolge in eine UTF-16-codierte Bytefolge konvertiert.
GetHashCode()	Gibt den Hashcode für die aktuelle Instanz zurück.
GetMaxByteCount(Int32)	Berechnet die maximale Anzahl der Bytes, die beim Codieren der angegebenen Anzahl von Zeichen erzeugt wird.
GetMaxCharCount(Int32)	Berechnet die maximale Anzahl der Zeichen, die beim Decodieren der angegebenen Anzahl von Bytes erzeugt werden.
GetPreamble()	Gibt eine im UTF-16-Format codierte Unicode-Bytereihenfolgemarkierung zurück, wenn der Konstruktor für diese Instanz die Bereitstellung einer Bytereihenfolgemarkierung anfordert.
GetString(Byte*, Int32)	Beim Überschreiben in einer abgeleiteten Klasse wird eine angegebene Anzahl von Bytes ab einer angegebenen Adresse in eine Zeichenfolge decodiert. (Geerbt von Encoding)
GetString(Byte[])	Beim Überschreiben in einer abgeleiteten Klasse werden alle Bytes im angegebenen Bytearray in eine Zeichenfolge decodiert. (Geerbt von Encoding)
GetString(Byte[], Int32, Int32)	Decodiert einen Bytebereich aus einem Bytearray in eine Zeichenfolge.
GetString(ReadOnlySpan<Byte>)	Decodiert beim Überschreiben in einer abgeleiteten Klasse alle Bytes in der angegebenen Bytespanne in eine Zeichenfolge. (Geerbt von Encoding)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
IsAlwaysNormalized()	Ruft einen Wert ab, der angibt, ob die aktuelle Codierung immer normalisiert ist. Es wird die Standardnormalisierungsform verwendet. (Geerbt von Encoding)
IsAlwaysNormalized(NormalizationForm)	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung immer normalisiert ist. Hierzu wird die angegebene Normalisierungsform verwendet. (Geerbt von Encoding)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TryGetBytes(ReadOnlySpan<Char>, Span<Byte>, Int32)	Codiert einen Satz von Zeichen aus der angegebenen schreibgeschützten Spanne in eine Bytespanne, wenn das Ziel groß genug ist. (Geerbt von Encoding)
TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32)	Decodiert einen Satz von Bytes aus der angegebenen schreibgeschützten Spanne in eine Spanne von Zeichen, wenn das Ziel groß genug ist. (Geerbt von Encoding)

Erweiterungsmethoden

GetBytes(Encoding, ReadOnlySequence<Char>)	Codiert die angegebene ReadOnlySequence<T> unter Verwendung der angegebenen Encoding in ein Byte-Array.
GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)	Decodiert die angegebene ReadOnlySequence<T> in bytes unter Verwendung der angegebenen Encoding und schreibt das Ergebnis in writer.
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	Codiert die angegebene ReadOnlySequence<T> in bytes unter Verwendung der angegebenen Encoding und gibt das Ergebnis in bytes aus.
GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)	Codiert die angegebene ReadOnlySpan<T> in bytes unter Verwendung der angegebenen Encoding und schreibt das Ergebnis in writer.
GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)	Decodiert die angegebene ReadOnlySequence<T> in chars unter Verwendung der angegebenen Encoding und schreibt das Ergebnis in writer.
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	Decodiert die angegebene ReadOnlySequence<T> in chars unter Verwendung der angegebenen Encoding und gibt das Ergebnis in chars aus.
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	Decodiert die angegebene ReadOnlySpan<T> in chars unter Verwendung der angegebenen Encoding und schreibt das Ergebnis in writer.
GetString(Encoding, ReadOnlySequence<Byte>)	Decodiert die angegebene ReadOnlySequence<T> unter Verwendung der angegebenen Encoding in einen String.

Weitere Informationen

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