UTF32Encoding Klasse

Definition

Namespace:: System.Text

Assemblys:: mscorlib.dll, System.Text.Encoding.Extensions.dll

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

Assembly:: System.Text.Encoding.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: UTF32Encoding.cs

Quelle:: UTF32Encoding.cs

Quelle:: UTF32Encoding.cs

Quelle:: UTF32Encoding.cs

Quelle:: UTF32Encoding.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

public ref class UTF32Encoding sealed : System::Text::Encoding

public sealed class UTF32Encoding : System.Text.Encoding

[System.Serializable]
public sealed class UTF32Encoding : System.Text.Encoding

type UTF32Encoding = class
    inherit Encoding

[<System.Serializable>]
type UTF32Encoding = class
    inherit Encoding

Public NotInheritable Class UTF32Encoding
Inherits Encoding

Vererbung: Object

Encoding
UTF32Encoding

Attribute: SerializableAttribute

Beispiele

Im folgenden Beispiel wird das Verhalten von UTF32Encoding Objekten mit und ohne Fehlererkennung veranschaulicht. Es erstellt ein Bytearray, dessen letzte vier Bytes ein ungültiges Ersatzpaar darstellen; Der hohe Ersatz U+D8FF folgt einem U+01FF, das sich außerhalb des Bereichs von niedrigen Surrogaten befindet (0xDC00 bis 0xDFFF). Ohne Fehlererkennung verwendet der UTF32-Decoder Ersatzfallback, um das ungültige Ersatzpaar durch REPLACEMENT CHARACTER (U+FFFD) zu ersetzen.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
     // Create a UTF32Encoding object with error detection enabled.
      var encExc = new UTF32Encoding(! BitConverter.IsLittleEndian, true, true);
      // Create a UTF32Encoding object with error detection disabled.
      var encRepl = new UTF32Encoding(! BitConverter.IsLittleEndian, true, false);

      // Create a byte arrays from a string, and add an invalid surrogate pair, as follows.
      //    Latin Small Letter Z (U+007A)
      //    Latin Small Letter A (U+0061)
      //    Combining Breve (U+0306)
      //    Latin Small Letter AE With Acute (U+01FD)
      //    Greek Small Letter Beta (U+03B2)
      //    a high-surrogate value (U+D8FF)
      //    an invalid low surrogate (U+01FF)
      String s = "za\u0306\u01FD\u03B2";

      // Encode the string using little-endian byte order.
      int index = encExc.GetByteCount(s);
      Byte[] bytes = new Byte[index + 4];
      encExc.GetBytes(s, 0, s.Length, bytes, 0);
      bytes[index] = 0xFF;
      bytes[index + 1] = 0xD8;
      bytes[index + 2] = 0xFF;
      bytes[index + 3] = 0x01;

      // Decode the byte array with error detection.
      Console.WriteLine("Decoding with error detection:");
      PrintDecodedString(bytes, encExc);

      // Decode the byte array without error detection.
      Console.WriteLine("Decoding without error detection:");
      PrintDecodedString(bytes, encRepl);
   }

   // Decode the bytes and display the string.
   public static void PrintDecodedString(Byte[] bytes, Encoding enc)
   {
      try {
         Console.WriteLine("   Decoded string: {0}", enc.GetString(bytes, 0, bytes.Length));
      }
      catch (DecoderFallbackException e) {
         Console.WriteLine(e.ToString());
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Decoding with error detection:
//    System.Text.DecoderFallbackException: Unable to translate bytes [FF][D8][FF][01] at index
//    20 from specified code page to Unicode.
//       at System.Text.DecoderExceptionFallbackBuffer.Throw(Byte[] bytesUnknown, Int32 index)
//       at System.Text.DecoderExceptionFallbackBuffer.Fallback(Byte[] bytesUnknown, Int32 index
//    )
//       at System.Text.DecoderFallbackBuffer.InternalFallback(Byte[] bytes, Byte* pBytes)
//       at System.Text.UTF32Encoding.GetCharCount(Byte* bytes, Int32 count, DecoderNLS baseDeco
//    der)
//       at System.Text.UTF32Encoding.GetString(Byte[] bytes, Int32 index, Int32 count)
//       at Example.PrintDecodedString(Byte[] bytes, Encoding enc)
//
//    Decoding without error detection:
//       Decoded string: zăǽβ�

Imports System.Text

Public Module Example
   Public Sub Main()
      ' Create a UTF32Encoding object with error detection enabled.
      Dim encExc As New UTF32Encoding(Not BitConverter.IsLittleEndian, True, True)
      ' Create a UTF32Encoding object with error detection disabled.
      Dim encRepl As New UTF32Encoding(Not BitConverter.IsLittleEndian, True, False)

      ' Create a byte arrays from a string, and add an invalid surrogate pair, as follows.
      '    Latin Small Letter Z (U+007A)
      '    Latin Small Letter A (U+0061)
      '    Combining Breve (U+0306)
      '    Latin Small Letter AE With Acute (U+01FD)
      '    Greek Small Letter Beta (U+03B2)
      '    a high-surrogate value (U+D8FF)
      '    an invalid low surrogate (U+01FF)
      Dim s As String = "za" & ChrW(&H0306) & ChrW(&H01FD) & ChrW(&H03B2)

      ' Encode the string using little-endian byte order.
      Dim index As Integer = encExc.GetBytecount(s)
      Dim bytes(index + 3) As Byte
      encExc.GetBytes(s, 0, s.Length, bytes, 0)
      bytes(index) = &hFF
      bytes(index + 1) = &hD8
      bytes(index + 2) = &hFF
      bytes(index + 3) = &h01

      ' Decode the byte array with error detection.
      Console.WriteLine("Decoding with error detection:")
      PrintDecodedString(bytes, encExc)

      ' Decode the byte array without error detection.
      Console.WriteLine("Decoding without error detection:")
      PrintDecodedString(bytes, encRepl)
   End Sub

   ' Decode the bytes and display the string.
   Public Sub PrintDecodedString(bytes() As Byte, enc As Encoding)
      Try
         Console.WriteLine("   Decoded string: {0}", enc.GetString(bytes, 0, bytes.Length))
      Catch e As DecoderFallbackException
         Console.WriteLine(e.ToString())
      End Try
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    Decoding with error detection:
'    System.Text.DecoderFallbackException: Unable to translate bytes [FF][D8][FF][01] at index
'    20 from specified code page to Unicode.
'       at System.Text.DecoderExceptionFallbackBuffer.Throw(Byte[] bytesUnknown, Int32 index)
'       at System.Text.DecoderExceptionFallbackBuffer.Fallback(Byte[] bytesUnknown, Int32 index
'    )
'       at System.Text.DecoderFallbackBuffer.InternalFallback(Byte[] bytes, Byte* pBytes)
'       at System.Text.UTF32Encoding.GetCharCount(Byte* bytes, Int32 count, DecoderNLS baseDeco
'    der)
'       at System.Text.UTF32Encoding.GetString(Byte[] bytes, Int32 index, Int32 count)
'       at Example.PrintDecodedString(Byte[] bytes, Encoding enc)
'
'    Decoding without error detection:
'       Decoded string: zăǽβ�

Im folgenden Beispiel wird eine Zeichenfolge von Unicode-Zeichen mithilfe eines UTF32Encoding Objekts in ein Bytearray codiert. Das Bytearray wird dann in eine Zeichenfolge decodiert, um zu veranschaulichen, dass keine Daten verloren gehen.

using System;
using System.Text;

public class Example
{
    public static void Main()
    {
        // The encoding.
        var enc = new UTF32Encoding();
        
        // Create a string.
        String s = "This string contains two characters " +
                   "with codes outside the ASCII code range: " +
                   "Pi (\u03A0) and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine("   {0}", s);
        
        // Encode the string.
        Byte[] encodedBytes = enc.GetBytes(s);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        for (int ctr = 0; ctr < encodedBytes.Length; ctr++) {
            Console.Write("[{0:X2}]{1}", encodedBytes[ctr],
                                         (ctr + 1) % 4 == 0 ? " " : "" );
            if ((ctr + 1) % 16 == 0) Console.WriteLine();
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        // Notice Pi and Sigma characters are still present.
        String decodedString = enc.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded string:");
        Console.WriteLine("   {0}", decodedString);
    }
}
// The example displays the following output:
//    Original string:
//       This string contains two characters with codes outside the ASCII code range:
//    Pi (π) and Sigma (Σ).
//
//    Encoded bytes:
//    [54][00][00][00] [68][00][00][00] [69][00][00][00] [73][00][00][00]
//    [20][00][00][00] [73][00][00][00] [74][00][00][00] [72][00][00][00]
//    [69][00][00][00] [6E][00][00][00] [67][00][00][00] [20][00][00][00]
//    [63][00][00][00] [6F][00][00][00] [6E][00][00][00] [74][00][00][00]
//    [61][00][00][00] [69][00][00][00] [6E][00][00][00] [73][00][00][00]
//    [20][00][00][00] [74][00][00][00] [77][00][00][00] [6F][00][00][00]
//    [20][00][00][00] [63][00][00][00] [68][00][00][00] [61][00][00][00]
//    [72][00][00][00] [61][00][00][00] [63][00][00][00] [74][00][00][00]
//    [65][00][00][00] [72][00][00][00] [73][00][00][00] [20][00][00][00]
//    [77][00][00][00] [69][00][00][00] [74][00][00][00] [68][00][00][00]
//    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
//    [65][00][00][00] [73][00][00][00] [20][00][00][00] [6F][00][00][00]
//    [75][00][00][00] [74][00][00][00] [73][00][00][00] [69][00][00][00]
//    [64][00][00][00] [65][00][00][00] [20][00][00][00] [74][00][00][00]
//    [68][00][00][00] [65][00][00][00] [20][00][00][00] [41][00][00][00]
//    [53][00][00][00] [43][00][00][00] [49][00][00][00] [49][00][00][00]
//    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
//    [65][00][00][00] [20][00][00][00] [72][00][00][00] [61][00][00][00]
//    [6E][00][00][00] [67][00][00][00] [65][00][00][00] [3A][00][00][00]
//    [20][00][00][00] [50][00][00][00] [69][00][00][00] [20][00][00][00]
//    [28][00][00][00] [A0][03][00][00] [29][00][00][00] [20][00][00][00]
//    [61][00][00][00] [6E][00][00][00] [64][00][00][00] [20][00][00][00]
//    [53][00][00][00] [69][00][00][00] [67][00][00][00] [6D][00][00][00]
//    [61][00][00][00] [20][00][00][00] [28][00][00][00] [A3][03][00][00]
//    [29][00][00][00] [2E][00][00][00]
//
//    Decoded string:
//       This string contains two characters with codes outside the ASCII code range:
//    Pi (π) and Sigma (Σ).

Imports System.Text

Class Example
    Public Shared Sub Main()
        ' The encoding.
        Dim enc As New UTF32Encoding()
        
        ' Create a string.
        Dim s As String =
            "This string contains two characters " &
            "with codes outside the ASCII code range: " &
            "Pi (" & ChrW(&h03A0) & ") and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine("   {0}", s)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = enc.GetBytes(s)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        For ctr As Integer = 0 To encodedBytes.Length - 1
            Console.Write("[{0:X2}]{1}", encodedBytes(ctr),
                                         If((ctr + 1) Mod 4 = 0, " ", "" ))
            If (ctr + 1) Mod 16 = 0 Then Console.WriteLine()
        Next
        Console.WriteLine()
        
        ' Decode bytes back to string.
        ' Notice Pi and Sigma characters are still present.
        Dim decodedString As String = enc.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded string:")
        Console.WriteLine("   {0}", decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'       This string contains two characters with codes outside the ASCII code range:
'    Pi (π) and Sigma (Σ).
'
'    Encoded bytes:
'    [54][00][00][00] [68][00][00][00] [69][00][00][00] [73][00][00][00]
'    [20][00][00][00] [73][00][00][00] [74][00][00][00] [72][00][00][00]
'    [69][00][00][00] [6E][00][00][00] [67][00][00][00] [20][00][00][00]
'    [63][00][00][00] [6F][00][00][00] [6E][00][00][00] [74][00][00][00]
'    [61][00][00][00] [69][00][00][00] [6E][00][00][00] [73][00][00][00]
'    [20][00][00][00] [74][00][00][00] [77][00][00][00] [6F][00][00][00]
'    [20][00][00][00] [63][00][00][00] [68][00][00][00] [61][00][00][00]
'    [72][00][00][00] [61][00][00][00] [63][00][00][00] [74][00][00][00]
'    [65][00][00][00] [72][00][00][00] [73][00][00][00] [20][00][00][00]
'    [77][00][00][00] [69][00][00][00] [74][00][00][00] [68][00][00][00]
'    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
'    [65][00][00][00] [73][00][00][00] [20][00][00][00] [6F][00][00][00]
'    [75][00][00][00] [74][00][00][00] [73][00][00][00] [69][00][00][00]
'    [64][00][00][00] [65][00][00][00] [20][00][00][00] [74][00][00][00]
'    [68][00][00][00] [65][00][00][00] [20][00][00][00] [41][00][00][00]
'    [53][00][00][00] [43][00][00][00] [49][00][00][00] [49][00][00][00]
'    [20][00][00][00] [63][00][00][00] [6F][00][00][00] [64][00][00][00]
'    [65][00][00][00] [20][00][00][00] [72][00][00][00] [61][00][00][00]
'    [6E][00][00][00] [67][00][00][00] [65][00][00][00] [3A][00][00][00]
'    [20][00][00][00] [50][00][00][00] [69][00][00][00] [20][00][00][00]
'    [28][00][00][00] [A0][03][00][00] [29][00][00][00] [20][00][00][00]
'    [61][00][00][00] [6E][00][00][00] [64][00][00][00] [20][00][00][00]
'    [53][00][00][00] [69][00][00][00] [67][00][00][00] [6D][00][00][00]
'    [61][00][00][00] [20][00][00][00] [28][00][00][00] [A3][03][00][00]
'    [29][00][00][00] [2E][00][00][00]
'
'    Decoded string:
'       This string contains two characters with codes outside the ASCII code range:
'    Pi (π) and Sigma (Σ).

Im folgenden Beispiel wird die gleiche Zeichenfolge wie die vorherige 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-32 encoding that supports a BOM.
        var enc = new UTF32Encoding();
        
        // A Unicode string with two characters outside an 8-bit code range.
        String s = "This Unicode string has 2 characters " +
                   "outside the ASCII range: \n" +
                   "Pi (\u03A0), and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(s);
        Console.WriteLine();
        
        // Encode the string.
        Byte[] encodedBytes = enc.GetBytes(s);
        Console.WriteLine("The encoded string has {0} bytes.\n",
                          encodedBytes.Length);

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF32Encoding.txt", FileMode.Create);
        Byte[] bom = enc.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(@".\UTF32Encoding.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(@".\Utf32Encoding.txt", FileMode.Open);
        Byte[] bytes = new Byte[fs.Length];
        fs.Read(bytes, 0, (int)fs.Length);
        fs.Close();

        String decodedString = enc.GetString(bytes);
        Console.WriteLine("Decoded bytes from binary file:");
        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 340 bytes.
//
//    Wrote 344 bytes to the file.
//
//    String read using StreamReader:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Decoded bytes from binary file:
//    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-32 encoding that supports a BOM.
        Dim enc As New UTF32Encoding()
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim s 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(s)
        Console.WriteLine()
        
        ' Encode the string.
        Dim encodedBytes As Byte() = enc.GetBytes(s)
        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(".\UTF32Encoding.txt", FileMode.Create)
        Dim bom() As Byte = enc.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(".\UTF32Encoding.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(".\Utf32Encoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = enc.GetString(bytes)
        Console.WriteLine("Decoded bytes from binary file:")
        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 344 bytes.
'
'    Wrote 348 bytes to the file.
'
'    String read using StreamReader:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Decoded bytes from binary file:
'    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.

Der Unicode-Standard weist jedem Zeichen in jedem unterstützten Skript einen Codepunkt (eine Zahl) zu. Ein Unicode-Transformationsformat (UTF) ist eine Möglichkeit, diesen Codepunkt zu codieren. Der Unicode-Standard verwendet die folgenden UTFs:

UTF-8, das jeden Codepunkt als Sequenz von 1 bis vier Bytes darstellt.
UTF-16, das jeden Codepunkt als Sequenz von 1 bis zwei 16-Bit-Ganzzahlen darstellt.
UTF-32, das jeden Codepunkt als 32-Bit-Ganzzahl darstellt.

Weitere Informationen zu den UTFs und anderen von .NET unterstützten System.TextCodierungen finden Sie unter Zeichencodierung in .NET.

Die UTF32Encoding Klasse stellt eine UTF-32-Codierung dar. Der Encoder kann die Groß-End-Byte-Reihenfolge (das wichtigste Byte zuerst) oder die kleine Endian byte-Reihenfolge (am wenigsten signifikantes Byte zuerst) verwenden. Beispielsweise wird der lateinische Großbuchstabe A (Codepunkt U+0041) wie folgt serialisiert (hexadezimal):

Big Endian Byte Order: 00 00 00 41
Kleine endische Bytereihenfolge: 41 00 00 00

Im Allgemeinen ist es effizienter, Unicode-Zeichen mithilfe der systemeigenen Bytereihenfolge zu speichern. Beispielsweise ist es besser, die Little-Endian-Bytereihenfolge auf Little-Endian-Plattformen wie Intel-Computern zu verwenden. UTF32Encoding entspricht den Windows-Codeseiten 12000 (little endian byte order) und 12001 (big endian byte order). Sie können die "Endianität" einer bestimmten Architektur ermitteln, indem Sie die BitConverter.IsLittleEndian Methode aufrufen.

Optional stellt das UTF32Encoding Objekt eine Bytereihenfolgemarke (Byte order mark, BOM) bereit, bei der es sich um ein Bytearray handelt, das der Sequenz von Bytes vorangestellt werden kann, die sich aus dem Codierungsprozess ergibt. Wenn die Präambel ein Bytereihenfolgezeichen (BYM) enthält, hilft es dem Decoder, die Bytereihenfolge und das Transformationsformat oder UTF eines Bytearrays zu bestimmen.

Wenn die Instanz für die UTF32Encoding Bereitstellung einer BOM konfiguriert ist, 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 UTF32Encoding Objekt für die BOM-Unterstützung konfiguriert ist, die BOM am Anfang des codierten Bytestroms entsprechend einschließen müssen. Die Codierungsmethoden der UTF32Encoding Klasse tun dies nicht automatisch.

Vorsicht

Um die Fehlererkennung zu aktivieren und die Klasseninstanz sicherer zu machen, sollten Sie ein UTF32Encoding Objekt instanziieren, indem Sie den UTF32Encoding(Boolean, Boolean, Boolean) Konstruktor aufrufen und dessen throwOnInvalidBytes Argument auf truefestlegen. Bei der Fehlererkennung 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.

Sie können ein UTF32Encoding Objekt auf verschiedene Arten instanziieren, je nachdem, ob sie eine Bytereihenfolgemarke (Byte Order Mark, BOM) bereitstellen möchten, ganz gleich, ob Sie big-endian- oder little-endian-Codierung verwenden möchten und ob Sie die Fehlererkennung aktivieren möchten. In der folgenden Tabelle sind die UTF32Encoding Konstruktoren und die Eigenschaften aufgeführt, die Encoding ein UnicodeEncoding Objekt zurückgeben.

Mitglied	Endianität	STÜCKLISTE	Fehlererkennung
Encoding.UTF32	Little-Endian	Ja	Nein (Ersatzfallback)
UTF32Encoding.UTF32Encoding()	Little-Endian	Ja	Nein (Ersatzfallback)
UTF32Encoding.UTF32Encoding(Boolean, Boolean)	Konfigurierbar	Konfigurierbar	Nein (Ersatzfallback)
UTF32Encoding.UTF32Encoding(Boolean, Boolean, Boolean)	Konfigurierbar	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.

Konstruktoren

Name	Beschreibung
UTF32Encoding()	Initialisiert eine neue Instanz der UTF32Encoding-Klasse.
UTF32Encoding(Boolean, Boolean, Boolean)	Initialisiert eine neue Instanz der UTF32Encoding-Klasse. Parameter geben an, ob die Big Endian Byte-Reihenfolge verwendet werden soll, ob ein Unicode-Bytereihenfolgezeichen angegeben wird und ob eine Ausnahme ausgelöst werden soll, wenn eine ungültige Codierung erkannt wird.
UTF32Encoding(Boolean, Boolean)	Initialisiert eine neue Instanz der UTF32Encoding-Klasse. Parameter geben an, ob die Groß-End-Bytereihenfolge verwendet werden soll und ob die GetPreamble() Methode ein Unicode-Bytereihenfolgezeichen zurückgibt.

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-32-Format codiert ist, wenn dieses Objekt so konfiguriert ist, dass eins bereitgestellt wird.
Preamble	Wenn eine abgeleitete Klasse überschrieben wird, wird eine Spanne zurückgegeben, die die Sequenz von Bytes enthält, die die verwendete Codierung angibt. (Geerbt von Encoding)
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 der angegebene Object Wert dem aktuellen UTF32Encoding 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>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird die Anzahl der Bytes berechnet, die von der Codierung der Zeichen in der angegebenen Zeichenspanne erzeugt werden. (Geerbt von Encoding)
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>)	Wenn sie in einer abgeleiteten Klasse überschrieben werden, codiert sie in einer Reihe von Bytes, die aus der angegebenen schreibgeschützten Spanne stammen. (Geerbt von Encoding)
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 `index`wird. (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>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, wird die Anzahl der Zeichen berechnet, die durch Decodieren der bereitgestellten schreibgeschützten Bytespanne erzeugt werden. (Geerbt von Encoding)
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>)	Wenn sie in einer abgeleiteten Klasse überschrieben wird, decodieren Sie alle Bytes im angegebenen schreibgeschützten Bytebereich in eine Zeichenspanne. (Geerbt von Encoding)
GetDecoder()	Ruft einen Decoder ab, der eine UTF-32-codierte Bytesequenz in eine Sequenz von Unicode-Zeichen konvertiert.
GetEncoder()	Ruft einen Encoder ab, der eine Sequenz von Unicode-Zeichen in eine UTF-32-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-32-Format codiert ist, wenn das UTF32Encoding Objekt 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. (Geerbt von Encoding)
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. (Geerbt von Encoding)

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 Encoding`writer`.
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	Codiert den angegebenen ReadOnlySequence<T> wert `byte`mit 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 `byte`mit 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 Encoding`writer`.
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	Decodiert die angegebenen ReadOnlySequence<T> zu s angegebenen Daten, `char` und gibt das Ergebnis in Encoding`chars`.
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	Decodiert den angegebenen ReadOnlySpan<T> wert mit dem angegebenen `char` Wert und schreibt das Ergebnis in Encoding`writer`.
GetString(Encoding, ReadOnlySequence<Byte>)	Decodiert den angegebenen ReadOnlySequence<T> Wert mit dem String angegebenen Encoding.

Gilt für:

Weitere Informationen

Feedback

War diese Seite hilfreich?