UTF8Encoding Klasse

Definition

Namespace:

System.Text

Assemblys:

netstandard.dll, System.Text.Encoding.Extensions.dll

Quelle:

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 zu einer Zeichenfolge decodiert wird, sind die Pi- und Sigma-Zeichen weiterhin vorhanden.

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 der Ausnahme, dass sie die codierten Bytes in eine Datei schreibt und dem Bytedatenstrom eine Bytereihenfolgemarke (BYM) vorangestellt. Anschließend liest sie die Datei auf zwei verschiedene Arten: als Textdatei mithilfe eines StreamReader Objekts und als Binärdatei. Wie Sie erwarten würden, 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

Die Codierung ist der Prozess der Transformation einer Reihe von Unicode-Zeichen in eine Folge von Bytes. Die Decodierung ist der Prozess der Transformation einer Sequenz codierter Bytes in eine Reihe 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 "Endianität"; Das Codierungsschema ist identisch, unabhängig davon, ob der Prozessor big-endian oder little-endian ist. UTF8Encoding entspricht der Windows-Codepage 65001. Weitere Informationen zu den von .NET Framework unterstützten System.TextUTFs und anderen Codierungen finden Sie unter "Character Encoding" in .NET Framework.

Sie können ein UTF8Encoding Objekt auf verschiedene Arten instanziieren, je nachdem, ob sie eine Bytereihenfolgemarke (Byte order mark, BOM) bereitstellen 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	STÜCKLISTE	Fehlererkennung
Encoding.UTF8	Ja	Nein (Ersatzfallback)
UTF8Encoding.UTF8Encoding()	No	Nein (Ersatzfallback)
UTF8Encoding.UTF8Encoding(Boolean)	Konfigurierbar	Nein (Ersatzfallback)
UTF8Encoding.UTF8Encoding(Boolean, Boolean)	Konfigurierbar	Konfigurierbar

Die GetByteCount Methode bestimmt, wie viele Byte eine Reihe von Unicode-Zeichen codieren, und die GetBytes Methode führt die tatsächliche Codierung aus.

Ebenso bestimmt die GetCharCount Methode, wie viele Zeichen dazu führen, eine Bytesequenz zu decodieren, und die GetChars methoden GetString führen die eigentliche Decodierung aus.

Verwenden Sie für einen Encoder oder Decoder, der Zustandsinformationen speichern kann, wenn Daten codiert oder decodiert werden, die mehrere Blöcke umfassen (z. B. Zeichenfolge von 1 Millionen Zeichen, die in Segmenten mit 100.000 Zeichen codiert sind), die bzwGetDecoder. die GetEncoder Eigenschaften.

Optional stellt das UTF8Encoding Objekt eine Bytereihenfolgemarke (BYM) bereit, bei der es sich um ein Bytearray handelt, das dem Anfang des Bytedatenstroms vorangestellt werden kann, der aus dem Codierungsprozess resultiert. Wenn ein UTF-8-codierter Bytedatenstrom mit einem Bytereihenfolgezeichen (BYM) vorangestellt ist, hilft es dem Decoder, die Bytereihenfolge und das Transformationsformat oder UTF zu bestimmen. Beachten Sie jedoch, dass der Unicode-Standard weder einen BOM in UTF-8-codierten Datenströmen erfordert noch empfiehlt. Weitere Informationen zur Bytereihenfolge und zum Bytereihenfolgezeichen finden Sie im Unicode-Standard auf der Unicode-Startseite.

Wenn der Encoder für die Bereitstellung einer BOM konfiguriert ist, können Sie ihn abrufen, indem Sie die GetPreamble Methode aufrufen. 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 am Anfang des codierten Bytestroms entsprechend einschließen müssen. Die Codierungsmethoden der UTF8Encoding Klasse tun dies nicht automatisch.

Vorsicht

Um die Fehlererkennung zu aktivieren und die Klasseninstanz 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 Abfolge von Zeichen oder Byte erkennt, eine ArgumentException Ausnahme aus. Ohne Fehlererkennung wird keine Ausnahme ausgelöst, und die ungültige Sequenz wird im Allgemeinen ignoriert.

Note

Der Status eines UTF-8-codierten Objekts wird nicht beibehalten, wenn das Objekt serialisiert und mithilfe verschiedener .NET Framework-Versionen deserialisiert wird.

Konstruktoren

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

Eigenschaften

Name	Beschreibung
BodyName	Wenn sie in einer abgeleiteten Klasse überschrieben werden, ruft sie einen Namen für die aktuelle Codierung ab, die mit Nachrichten-Agent-Texttags verwendet werden kann. (Geerbt von Encoding)
CodePage	Wenn sie in einer abgeleiteten Klasse überschrieben wird, ruft der Codeseitenbezeichner des aktuellen Encodingab. (Geerbt von Encoding)
DecoderFallback	Dient zum Abrufen oder Festlegen des DecoderFallback Objekts für das aktuelle Encoding Objekt. (Geerbt von Encoding)
EncoderFallback	Dient zum Abrufen oder Festlegen des EncoderFallback Objekts für das aktuelle Encoding Objekt. (Geerbt von Encoding)
EncodingName	Wenn sie in einer abgeleiteten Klasse überschrieben wird, ruft die lesbare Beschreibung der aktuellen Codierung ab. (Geerbt von Encoding)
HeaderName	Wenn sie in einer abgeleiteten Klasse überschrieben werden, wird ein Name für die aktuelle Codierung angezeigt, die mit E-Mail-Agent-Headertags verwendet werden kann. (Geerbt von Encoding)
IsBrowserDisplay	Wenn eine abgeleitete Klasse überschrieben wird, wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Browserclients zum Anzeigen von Inhalten verwendet werden kann. (Geerbt von Encoding)
IsBrowserSave	Wenn eine abgeleitete Klasse überschrieben wird, wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von Browserclients zum Speichern von Inhalten verwendet werden kann. (Geerbt von Encoding)
IsMailNewsDisplay	Wenn eine abgeleitete Klasse überschrieben wird, wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von E-Mail- und Nachrichtenclients zum Anzeigen von Inhalten verwendet werden kann. (Geerbt von Encoding)
IsMailNewsSave	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung von E-Mail- und Nachrichtenclients zum Speichern von Inhalten verwendet werden kann. (Geerbt von Encoding)
IsReadOnly	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung schreibgeschützt ist. (Geerbt von Encoding)
IsSingleByte	Wenn eine abgeleitete Klasse überschrieben wird, wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung Single-Byte-Codepunkte verwendet. (Geerbt von Encoding)
Preamble	Ruft ein Unicode-Bytereihenfolgenzeichen ab, das im UTF-8-Format codiert ist, wenn dieses Objekt so konfiguriert ist, dass eins angegeben wird.
WebName	Wenn sie in einer abgeleiteten Klasse überschrieben wird, ruft der Name ab, der bei der Internet Assigned Numbers Authority (IANA) für die aktuelle Codierung registriert ist. (Geerbt von Encoding)
WindowsCodePage	Beim Überschreiben in einer abgeleiteten Klasse ruft die Windows-Betriebssystemcodeseite ab, die der aktuellen Codierung am ehesten entspricht. (Geerbt von Encoding)

Methoden

Name	Beschreibung
Clone()	Wenn eine abgeleitete Klasse überschrieben wird, wird eine flache Kopie des aktuellen Encoding Objekts erstellt. (Geerbt von Encoding)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen UTF8Encoding Objekt entspricht.
GetByteCount(Char[], Int32, Int32)	Berechnet die Anzahl der Bytes, die durch Codieren einer Reihe von Zeichen aus dem angegebenen Zeichenarray erzeugt werden.
GetByteCount(Char[])	Wenn eine abgeleitete Klasse überschrieben wird, wird die Anzahl der Byte berechnet, die durch codieren aller Zeichen im angegebenen Zeichenarray erzeugt werden. (Geerbt von Encoding)
GetByteCount(Char*, Int32)	Berechnet die Anzahl der Bytes, die durch Codieren einer Reihe von Zeichen erstellt werden, beginnend mit dem angegebenen Zeichenzeiger.
GetByteCount(ReadOnlySpan<Char>)	Berechnet die Anzahl der Bytes, die durch codieren der angegebenen Zeichenspanne erzeugt werden.
GetByteCount(String, Int32, Int32)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird die Anzahl der Bytes berechnet, die durch codieren einer Reihe von Zeichen aus der angegebenen Zeichenfolge erzeugt werden. (Geerbt von Encoding)
GetByteCount(String)	Berechnet die Anzahl der Byte, die durch codieren die Zeichen in der angegebenen String.
GetBytes(Char[], Int32, Int32, Byte[], Int32)	Codiert eine Reihe von Zeichen aus dem angegebenen Zeichenarray in das angegebene Bytearray.
GetBytes(Char[], Int32, Int32)	Wenn eine abgeleitete Klasse überschrieben wird, codiert eine Reihe von Zeichen aus dem angegebenen Zeichenarray in eine Folge von Bytes. (Geerbt von Encoding)
GetBytes(Char[])	Wenn sie in einer abgeleiteten Klasse überschrieben wird, werden alle Zeichen im angegebenen Zeichenarray in eine Folge von Bytes codiert. (Geerbt von Encoding)
GetBytes(Char*, Int32, Byte*, Int32)	Codiert eine Reihe von Zeichen, die mit dem angegebenen Zeichenzeiger beginnen, in eine Abfolge von Bytes, die ab dem angegebenen Bytezeiger gespeichert werden.
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	Codiert den angegebenen Zeichenbereich in die angegebene Bytespanne.
GetBytes(String, Int32, Int32, Byte[], Int32)	Codiert eine Reihe von Zeichen aus dem angegebenen String Bytearray.
GetBytes(String, Int32, Int32)	Wenn sie in einer abgeleiteten Klasse überschrieben werden, codiert sie in ein Bytearray, das von der angegebenen Zeichenfolge ausgehend von count der angegebenen Zeichenfolge angegeben indexwird. (Geerbt von Encoding)
GetBytes(String)	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, codiert sie alle Zeichen in der angegebenen Zeichenfolge in eine Folge von Bytes. (Geerbt von Encoding)
GetCharCount(Byte[], Int32, Int32)	Berechnet die Anzahl der Zeichen, die durch Decodieren einer Bytesequenz aus dem angegebenen Bytearray erzeugt werden.
GetCharCount(Byte[])	Wenn eine abgeleitete Klasse überschrieben wird, wird die Anzahl der Zeichen berechnet, die durch Decodieren aller Bytes im angegebenen Bytearray erzeugt werden. (Geerbt von Encoding)
GetCharCount(Byte*, Int32)	Berechnet die Anzahl der Zeichen, die durch Decodieren einer Bytesequenz erzeugt werden, beginnend mit dem angegebenen Bytezeiger.
GetCharCount(ReadOnlySpan<Byte>)	Berechnet die Anzahl der Zeichen, die durch Decodieren des angegebenen Bytebereichs erzeugt werden.
GetChars(Byte[], Int32, Int32, Char[], Int32)	Decodiert eine Abfolge von Bytes aus dem angegebenen Bytearray in das angegebene Zeichenarray.
GetChars(Byte[], Int32, Int32)	Wenn eine abgeleitete Klasse überschrieben wird, decodiert eine Bytesequenz aus dem angegebenen Bytearray in eine Reihe von Zeichen. (Geerbt von Encoding)
GetChars(Byte[])	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, decodieren Sie alle Bytes im angegebenen Bytearray in eine Reihe von Zeichen. (Geerbt von Encoding)
GetChars(Byte*, Int32, Char*, Int32)	Decodiert eine Abfolge von Bytes ab dem angegebenen Bytezeiger in eine Reihe von Zeichen, die beginnend mit dem angegebenen Zeichenzeiger gespeichert werden.
GetChars(ReadOnlySpan<Byte>, Span<Char>)	Decodiert den angegebenen Bytebereich in den angegebenen Zeichenbereich.
GetDecoder()	Ruft einen Decoder ab, der eine UTF-8-codierte Bytesequenz in eine Sequenz von Unicode-Zeichen konvertiert.
GetEncoder()	Ruft einen Encoder ab, der eine Sequenz von Unicode-Zeichen in eine UTF-8-codierte Sequenz von Bytes konvertiert.
GetHashCode()	Gibt den Hashcode für die aktuelle Instanz zurück.
GetMaxByteCount(Int32)	Berechnet die maximale Anzahl von Byte, die durch die Codierung der angegebenen Anzahl von Zeichen erzeugt werden.
GetMaxCharCount(Int32)	Berechnet die maximale Anzahl von Zeichen, die durch Decodieren der angegebenen Anzahl von Bytes erzeugt werden.
GetPreamble()	Gibt ein Unicode-Bytereihenfolgezeichen zurück, das im UTF-8-Format codiert ist, wenn das UTF8Encoding Codierungsobjekt so konfiguriert ist, dass eins bereitgestellt wird.
GetString(Byte[], Int32, Int32)	Decodiert einen Bytebereich von einem Bytearray in eine Zeichenfolge.
GetString(Byte[])	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, decodieren Sie alle Bytes im angegebenen Bytearray in eine Zeichenfolge. (Geerbt von Encoding)
GetString(Byte*, Int32)	Wenn sie in einer abgeleiteten Klasse außer Kraft gesetzt wird, decodieren Sie eine angegebene Anzahl von Bytes beginnend mit einer angegebenen Adresse in eine Zeichenfolge. (Geerbt von Encoding)
GetString(ReadOnlySpan<Byte>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, decodieren Sie alle Bytes im angegebenen Bytebereich in eine Zeichenfolge. (Geerbt von Encoding)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
IsAlwaysNormalized()	Ruft einen Wert ab, der angibt, ob die aktuelle Codierung immer normalisiert ist, mithilfe des Standardnormalisierungsformulars. (Geerbt von Encoding)
IsAlwaysNormalized(NormalizationForm)	Wenn eine abgeleitete Klasse überschrieben wird, wird ein Wert abgerufen, der angibt, ob die aktuelle Codierung immer normalisiert ist, mithilfe des angegebenen Normalisierungsformulars. (Geerbt von Encoding)
MemberwiseClone()	Erstellt eine flache Kopie der 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 in eine Spanne von Bytes, die eine Reihe von Zeichen aus der angegebenen schreibgeschützten Spanne umfasst, wenn das Ziel groß genug ist.
TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32)	Decodiert eine Reihe von Zeichen, die eine Gruppe von Bytes aus der angegebenen schreibgeschützten Spanne umfassen, wenn das Ziel groß genug ist.

Erweiterungsmethoden

Name	Beschreibung
GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)	Decodiert den angegebenen ReadOnlySequence<T> wert mit dem angegebenen byte Wert und schreibt das Ergebnis in Encodingwriter.
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	Codiert den angegebenen ReadOnlySequence<T> wert bytemit dem angegebenen Encoding Wert und gibt das Ergebnis in bytes.
GetBytes(Encoding, ReadOnlySequence<Char>)	Codiert den angegebenen ReadOnlySequence<T> Wert mithilfe des angegebenen ByteArrays in ein Encoding Array.
GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)	Codiert den angegebenen ReadOnlySpan<T> wert bytemit dem angegebenen Encoding Wert und schreibt das Ergebnis in writer.
GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)	Decodiert den angegebenen ReadOnlySequence<T> wert mit dem angegebenen char Wert und schreibt das Ergebnis in Encodingwriter.
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	Decodiert die angegebenen ReadOnlySequence<T> zu s angegebenen Daten, char und gibt das Ergebnis in Encodingchars.
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	Decodiert den angegebenen ReadOnlySpan<T> wert mit dem angegebenen char Wert und schreibt das Ergebnis in Encodingwriter.
GetString(Encoding, ReadOnlySequence<Byte>)	Decodiert den angegebenen ReadOnlySequence<T> Wert mit dem String angegebenen Encoding.

Weitere Informationen

• Decoder
• Encoder
• Grundlegendes zu Codierungen