UTF8Encoding Klasse

Definition

Namespace:

System.Text

Assembly:

System.Text.Encoding.Extensions.dll

Source:

UTF8Encoding.cs

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

public ref class UTF8Encoding : System::Text::Encoding

public class UTF8Encoding : System.Text.Encoding

type UTF8Encoding = class
    inherit Encoding

Public Class UTF8Encoding
Inherits Encoding

Vererbung

Object

Encoding

UTF8Encoding

Beispiele

Im folgenden Beispiel wird ein UTF8Encoding -Objekt verwendet, um eine Zeichenfolge von Unicode-Zeichen zu codieren und in einem Bytearray zu speichern. Die Unicode-Zeichenfolge enthält zwei Zeichen, Pi (U+03A0) und Sigma (U+03A3), die sich außerhalb des ASCII-Zeichenbereichs befinden. Wenn das codierte Bytearray wieder in eine Zeichenfolge decodiert wird, sind die Zeichen Pi und Sigma weiterhin vorhanden.

using namespace System;
using namespace System::Text;
//using namespace System::Collections;

int main()
{
   // Create a UTF-8 encoding.
   UTF8Encoding^ utf8 = gcnew UTF8Encoding;
   
   // A Unicode string with two characters outside an 8-bit code range.
   String^ unicodeString = L"This Unicode string has 2 characters " +
                           L"outside the ASCII range:\n" +
                           L"Pi (\u03a0), and Sigma (\u03a3).";
   Console::WriteLine("Original string:");
   Console::WriteLine(unicodeString);
   
   // Encode the string.
   array<Byte>^ encodedBytes = utf8->GetBytes(unicodeString );
   Console::WriteLine();
   Console::WriteLine("Encoded bytes:");
   for (int ctr = 0; ctr < encodedBytes->Length; ctr++) {
      Console::Write( "{0:X2} ", encodedBytes[ctr]);
      if ((ctr + 1) % 25 == 0)
         Console::WriteLine();
   }

   Console::WriteLine();
   
   // Decode bytes back to string.
   String^ decodedString = utf8->GetString(encodedBytes);
   Console::WriteLine();
   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 (Σ).
//
//    Encoded bytes:
//    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
//    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
//    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
//    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).

using System;
using System.Text;

class Example
{
    public static void Main()
    {
        // Create a UTF-8 encoding.
        UTF8Encoding utf8 = new UTF8Encoding();
        
        // 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);

        // Encode the string.
        Byte[] encodedBytes = utf8.GetBytes(unicodeString);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for (int ctr = 0; ctr < encodedBytes.Length; ctr++) {
            Console.Write("{0:X2} ", encodedBytes[ctr]);
            if ((ctr + 1) %  25 == 0)
               Console.WriteLine();
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        String decodedString = utf8.GetString(encodedBytes);
        Console.WriteLine();
        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 (Σ).
//
//    Encoded bytes:
//    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
//    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
//    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
//    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).

Imports System.Text

Class Example
    Public Shared Sub Main()
        ' Create a UTF-8 encoding.
        Dim utf8 As New UTF8Encoding()
        
        ' 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)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = utf8.GetBytes(unicodeString)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        For ctr As Integer = 0 To encodedBytes.Length - 1
            Console.Write("{0:X2} ", encodedBytes(ctr))
            If (ctr + 1) Mod 25 = 0 Then Console.WriteLine
        Next
        Console.WriteLine()
        
        ' Decode bytes back to string.
        Dim decodedString As String = utf8.GetString(encodedBytes)
        Console.WriteLine()
        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 (Σ).
'
'    Encoded bytes:
'    54 68 69 73 20 55 6E 69 63 6F 64 65 20 73 74 72 69 6E 67 20 68 61 73 20 32
'    20 63 68 61 72 61 63 74 65 72 73 20 6F 75 74 73 69 64 65 20 74 68 65 20 41
'    53 43 49 49 20 72 61 6E 67 65 3A 20 0D 0A 50 69 20 28 CE A0 29 2C 20 61 6E
'    64 20 53 69 67 6D 61 20 28 CE A3 29 2E
'
'    Decoded bytes:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

Im folgenden Beispiel wird dieselbe Zeichenfolge wie im vorherigen Beispiel verwendet, mit dem Unterschied, 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-8 encoding that supports a BOM.
        Encoding utf8 = new UTF8Encoding(true);

        // 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 = utf8.GetBytes(unicodeString);
        Console.WriteLine("The encoded string has {0} bytes.",
                          encodedBytes.Length);
        Console.WriteLine();

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Create);
        Byte[] bom = utf8.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.
        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 = utf8.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 88 bytes.
//
//    Wrote 91 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-8 encoding that supports a BOM.
        Dim utf8 As New UTF8Encoding(True)
        
        ' 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() = utf8.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(".\UTF8Encoding.txt", FileMode.Create)
        Dim bom() As Byte = utf8.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(".\UTF8Encoding.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(".\UTF8Encoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = utf8.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 88 bytes.
'
'    Wrote 91 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.

UTF-8 ist eine Unicode-Codierung, die jeden Codepunkt als Sequenz von 1 bis vier Bytes darstellt. Im Gegensatz zu den UTF-16- und UTF-32-Codierungen erfordert die UTF-8-Codierung keine "Endianness"; das Codierungsschema ist dasselbe, unabhängig davon, ob der Prozessor big-endian oder Little-Endian ist. UTF8Encoding entspricht der Windows-Codepage 65001. Weitere Informationen zu den UTFs und anderen von System.Textunterstützten Codierungen finden Sie unter Zeichencodierung im .NET Framework.

Sie können ein UTF8Encoding Objekt auf verschiedene Arten instanziieren, je nachdem, ob Sie eine Bytereihenfolgenmarkierung (BOM) angeben möchten und ob Sie die Fehlererkennung aktivieren möchten. In der folgenden Tabelle sind die Konstruktoren und die Eigenschaft aufgeführt, die Encoding ein UTF8Encoding -Objekt zurückgeben.

Mitglied	BOM	Fehlererkennung
Encoding.UTF8	Ja	Nein (Ersatzfallback)
UTF8Encoding.UTF8Encoding()	Nein	Nein (Ersatzfallback)
UTF8Encoding.UTF8Encoding(Boolean)	Konfigurierbar	Nein (Ersatzfallback)
UTF8Encoding.UTF8Encoding(Boolean, Boolean)	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 zur Decodierung einer Bytesequenz führen, und die GetChars Methoden und GetString führen die eigentliche Decodierung durch.

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.

Optional stellt das UTF8Encoding -Objekt eine Bytereihenfolgemarkierung (BOM) bereit, bei der es sich um ein Bytearray handelt, das dem Anfang des Bytedatenstroms vorangestellt werden kann, der sich aus dem Codierungsprozess ergibt. Wenn einem UTF-8-codierten Bytestream eine Bytereihenfolgenmarkierung (Byte Order Mark, BOM) vorangestellt ist, hilft dies dem Decoder, die Bytereihenfolge und das Transformationsformat oder UTF zu bestimmen. Beachten Sie jedoch, dass der Unicode-Standard weder eine BOM in UTF-8-codierten Streams erfordert noch empfiehlt. Weitere Informationen zur Byte Reihenfolge und zur Byte Reihenfolge-Markierung finden Sie im Unicode-Standard auf der Unicode-Homepage.

Wenn der Encoder für die Bereitstellung einer BOM konfiguriert ist, können Sie sie durch Aufrufen der GetPreamble -Methode abrufen. Andernfalls gibt die Methode ein leeres Array zurück. Beachten Sie, dass Sie auch dann, wenn ein UTF8Encoding Objekt für die BoM-Unterstützung konfiguriert ist, die BoM nach Bedarf am Anfang des codierten Bytedatenstroms einschließen müssen. Die Codierungsmethoden der -Klasse tun dies UTF8Encoding nicht automatisch.

Achtung

Um die Fehlererkennung zu aktivieren und die Klasse instance sicherer zu machen, sollten Sie den UTF8Encoding(Boolean, Boolean) Konstruktor aufrufen und den throwOnInvalidBytes Parameter auf truefestlegen. Wenn die Fehlererkennung aktiviert ist, löst eine Methode, die eine ungültige Sequenz von Zeichen oder Bytes erkennt, eine Ausnahme aus ArgumentException . Ohne Fehlererkennung wird keine Ausnahme ausgelöst, und die ungültige Sequenz wird im Allgemeinen ignoriert.

Hinweis

Der Zustand eines UTF-8-codierten Objekts wird nicht beibehalten, wenn das Objekt mit verschiedenen .NET Framework Versionen serialisiert und deserialisiert wird.

Konstruktoren

UTF8Encoding()	Initialisiert eine neue Instanz der UTF8Encoding-Klasse.
UTF8Encoding(Boolean)	Initialisiert eine neue Instanz der UTF8Encoding-Klasse. Ein Parameter gibt an, ob eine Unicode-Bytereihenfolgemarkierung bereitgestellt werden soll.
UTF8Encoding(Boolean, Boolean)	Initialisiert eine neue Instanz der UTF8Encoding-Klasse. Parameter geben an, ob eine Unicode-Bytereihenfolgemarkierung bereitgestellt werden soll und ob eine Ausnahme ausgelöst werden soll, wenn eine ungültige Codierung gefunden wird.

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-8-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 Objekt und das aktuelle UTF8Encoding-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 die Anzahl von Bytes, die durch das Codieren des angegebenen Zeichenbereichs erzeugt werden.
GetByteCount(String)	Berechnet die Anzahl der Bytes, die durch das Codieren der Zeichen in der angegebenen String-Klasse 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 den angegebenen Zeichenbereich in den angegebenen Bytebereich.
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 die Anzahl von Zeichen, die beim Decodieren des angegebenen Bytebereichs erzeugt werden.
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 den angegebenen Bytebereich in den angegebenen Zeichenbereich.
GetDecoder()	Ruft einen Decoder ab, der eine UTF-8-codierte Bytefolge in eine Unicode-Zeichenfolge konvertiert.
GetEncoder()	Ruft einen Encoder ab, der eine Unicode-Zeichenfolge in eine UTF-8-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 Unicode-Bytereihenfolgemarkierung im UTF-8-Format zurück, wenn das UTF8Encoding-Codierungsobjekt dafür konfiguriert ist, eine bereitzustellen.
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.
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.

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

• Decoder
• Encoder
• Grundlegendes zu Codierungen