UTF32Encoding 类

参考

定义

命名空间:: System.Text

程序集:: mscorlib.dll, System.Text.Encoding.Extensions.dll

程序集:: System.Text.Encoding.Extensions.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: UTF32Encoding.cs

Source:: UTF32Encoding.cs

Source:: UTF32Encoding.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

表示 Unicode 字符的 UTF-32 编码。

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

继承: Object

Encoding
UTF32Encoding

属性: SerializableAttribute

示例

以下示例演示了启用和未启用错误检测的对象的行为 UTF32Encoding 。它创建一个字节数组，其最后四个字节表示无效的代理项对;高代理项 U+D8FF 后跟 U+01FF，它超出了通过 0xDFFF) (0xDC00 低代理项的范围。在不进行错误检测的情况下，UTF32 解码器使用替换回退将无效代理项对替换为替换字符 (U+FFFD) 。

using namespace System;
using namespace System::Text;
void PrintDecodedString( array<Byte>^bytes, Encoding^ enc );
int main()
{
   
   // Create an instance of UTF32Encoding using little-endian byte order.
   // This will be used for encoding.
   UTF32Encoding^ u32LE = gcnew UTF32Encoding( false,true );
   
   // Create two instances of UTF32Encoding using big-endian byte order: one with error detection and one without.
   // These will be used for decoding.
   UTF32Encoding^ u32withED = gcnew UTF32Encoding( true,true,true );
   UTF32Encoding^ u32noED = gcnew UTF32Encoding( true,true,false );
   
   // Create byte arrays from the same string containing the following characters:
   //    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)
   String^ myStr = L"za\u0306\u01FD\u03B2\xD8FF\xDCFF";
   
   // Encode the string using little-endian byte order.
   array<Byte>^myBytes = gcnew array<Byte>(u32LE->GetByteCount( myStr ));
   u32LE->GetBytes( myStr, 0, myStr->Length, myBytes, 0 );
   
   // Decode the byte array with error detection.
   Console::WriteLine( "Decoding with error detection:" );
   PrintDecodedString( myBytes, u32withED );
   
   // Decode the byte array without error detection.
   Console::WriteLine( "Decoding without error detection:" );
   PrintDecodedString( myBytes, u32noED );
}


// Decode the bytes and display the string.
void PrintDecodedString( array<Byte>^bytes, Encoding^ enc )
{
   try
   {
      Console::WriteLine( "   Decoded string: {0}", enc->GetString( bytes, 0, bytes->Length ) );
   }
   catch ( System::ArgumentException^ e ) 
   {
      Console::WriteLine( e );
   }

   Console::WriteLine();
}

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̆ǽβ�

以下示例使用 UTF32Encoding 对象将 Unicode 字符的字符串编码为字节数组。然后将字节数组解码为字符串，以证明没有数据丢失。

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 (Σ).

以下示例使用与上一个示例相同的字符串，不同之处在于它将编码的字节写入文件，并在 BOM) (字节顺序标记为字节流添加前缀。它然后两个不同的方式读取文件：为通过使用文本文件StreamReader对象; 和二进制文件。如您所料，在两种情况下是 BOM 包括在新读取字符串。正如你所料，新读取的字符串均不包含 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 (Σ).

注解

编码是将一组 Unicode 字符转换为一个字节序列的过程。解码是将编码字节序列转换为一组 Unicode 字符的过程。

Unicode Standard 为每个受支持的脚本中的每个字符分配 (一个数字) 的码位。 Unicode 转换格式 (UTF) 是对该码位进行编码的一种方法。 Unicode 标准版使用以下 UTF：

UTF-8，将每个码位表示为 1 到 4 个字节的序列。
UTF-16，将每个码位表示为一到两个 16 位整数的序列。
UTF-32，将每个码位表示为 32 位整数。

有关支持的 UTF 和其他编码 System.Text的详细信息，请参阅 .NET 中的字符编码。

类 UTF32Encoding 表示 UTF-32 编码。编码器可以使用大字节字节顺序 (最大有效字节) 或小结束字节顺序 (最小有效字节第一) 。例如，拉丁文大写字母 A (码位 U+0041) 序列化为十六进制) (：

Big endian 字节顺序：00 00 00 41
Little endian 字节顺序：41 00 00 00

使用本机字节顺序存储 Unicode 字符通常更有效。例如，最好使用 little endian 平台（如 Intel 计算机）上的 little endian 字节顺序。 UTF32Encoding 对应于 Windows 代码页 12000 (小 endian 字节顺序) 和 12001 (big endian 字节顺序) 。可以通过调用 BitConverter.IsLittleEndian 方法来确定特定体系结构的“终止性”。

（可选） UTF32Encoding 对象 (BOM) 提供字节顺序标记，这是一个字节数组，可以作为编码过程生成的字节序列的前缀。如果前言包含 BOM) (字节顺序标记，则它可帮助解码器确定字节数组的字节顺序和转换格式或 UTF。

如果UTF32Encoding实例配置为提供 BOM，可以通过调用检索GetPreamble方法; 否则，该方法返回空数组。请注意，即使UTF32EncodingBOM 支持的配置对象时，必须包含 BOM 将编码的字节流作为相应; 开头的编码方法UTF32Encoding类执行未自动执行此操作。

注意

若要启用错误检测并使类实例更安全，应通过调用 UTF32Encoding(Boolean, Boolean, Boolean) 构造函数并将其参数设置为 throwOnInvalidBytes 来true实例化UTF32Encoding对象。使用错误检测时，检测无效字符或字节序列的方法会 ArgumentException 引发异常。如果不进行错误检测，则不会引发异常，并且通常忽略无效序列。

可以通过多种方式实例化 UTF32Encoding 对象，具体取决于是否希望它 (BOM) 提供字节顺序标记、是要使用 big-endian 编码还是小端编码，以及是否要启用错误检测。下表列出了UTF32Encoding返回 UnicodeEncoding 对象的构造函数和Encoding属性。

成员	字节排序方式	BOM	错误检测
Encoding.UTF32	Little-endian	是	无 (替换回退)
UTF32Encoding.UTF32Encoding()	Little-endian	是	无 (替换回退)
UTF32Encoding.UTF32Encoding(Boolean, Boolean)	可配置	可配置	无 (替换回退)
UTF32Encoding.UTF32Encoding(Boolean, Boolean, Boolean)	可配置	可配置	可配置

GetByteCount方法确定导致对一组 Unicode 字符进行编码的字节数， GetBytes 方法执行实际编码。

同样， GetCharCount 方法确定导致解码字节序列的字符数，和 GetChars GetString 方法执行实际解码。

对于编码或解码跨多个块 (数据（例如编码为 100，000 个字符的字符串（以 100，000 个字符段) 编码）时能够保存状态信息的编码器或解码器，请分别使用 GetEncoder 和 GetDecoder 属性。

构造函数

UTF32Encoding()	初始化 UTF32Encoding 类的新实例。
UTF32Encoding(Boolean, Boolean)	初始化 UTF32Encoding 类的新实例。参数指定是否使用 Big-Endian 字节顺序以及 GetPreamble() 方法是否返回 Unicode 字节顺序标记。
UTF32Encoding(Boolean, Boolean, Boolean)	初始化 UTF32Encoding 类的新实例。参数指定是否使用 Big-Endian 字节顺序、是否提供 Unicode 字节顺序标记以及当检测到无效编码时是否引发异常。

属性

BodyName	在派生类中重写时，获取可与邮件代理正文标记一起使用的当前编码的名称。 (继承自 Encoding)
CodePage	在派生类中重写时，获取当前 Encoding 的代码页标识符。 (继承自 Encoding)
DecoderFallback	获取或设置当前 DecoderFallback 对象的 Encoding 对象。 (继承自 Encoding)
EncoderFallback	获取或设置当前 EncoderFallback 对象的 Encoding 对象。 (继承自 Encoding)
EncodingName	在派生类中重写时，获取当前编码的用户可读说明。 (继承自 Encoding)
HeaderName	在派生类中重写时，获取可与邮件代理头标记一起使用的当前编码的名称。 (继承自 Encoding)
IsBrowserDisplay	在派生类中重写时，获取一个值，该值指示浏览器客户端是否可以使用当前的编码显示内容。 (继承自 Encoding)
IsBrowserSave	在派生类中重写时，获取一个值，该值指示浏览器客户端是否可以使用当前的编码保存内容。 (继承自 Encoding)
IsMailNewsDisplay	在派生类中重写时，获取一个值，该值指示邮件和新闻客户端是否可以使用当前的编码显示内容。 (继承自 Encoding)
IsMailNewsSave	在派生类中重写时，获取一个值，该值指示邮件和新闻客户端是否可以使用当前的编码保存内容。 (继承自 Encoding)
IsReadOnly	在派生类中重写时，获取一个值，该值指示当前的编码是否为只读。 (继承自 Encoding)
IsSingleByte	在派生类中重写时，获取一个值，该值指示当前的编码是否使用单字节码位。 (继承自 Encoding)
Preamble	获取采用 UTF-32 格式编码的 Unicode 字节顺序标记（如果此对象配置为提供一个这样的标记）。
Preamble	在派生类中重写时，返回包含指定所用编码的字节序列的范围。 (继承自 Encoding)
WebName	在派生类中重写时，获取在 Internet 编号分配管理机构 (IANA) 注册的当前编码的名称。 (继承自 Encoding)
WindowsCodePage	在派生类中重写时，获取与当前编码最紧密对应的 Windows 操作系统代码页。 (继承自 Encoding)

方法

Clone()	当在派生类中重写时，创建当前 Encoding 对象的一个卷影副本。 (继承自 Encoding)
Equals(Object)	确定指定的 Object 是否等于当前的 UTF32Encoding 对象。
GetByteCount(Char*, Int32)	计算对从指定的字符指针开始的一组字符进行编码时产生的字节数。
GetByteCount(Char[])	在派生类中重写时，计算对指定字符数组中的所有字符进行编码所产生的字节数。 (继承自 Encoding)
GetByteCount(Char[], Int32, Int32)	计算对指定字符数组中的一组字符进行编码时产生的字节数。
GetByteCount(ReadOnlySpan<Char>)	在派生类中重写时，计算对指定字符范围的字符进行编码所产生的字节数。 (继承自 Encoding)
GetByteCount(String)	计算对指定 String 中的字符进行编码时所产生的字节数。
GetByteCount(String, Int32, Int32)	在派生类中重写时，计算对指定字符串中的一组字符进行编码所产生的字节数。 (继承自 Encoding)
GetBytes(Char, Int32, Byte, Int32)	将从指定的字符指针开始的一组字符编码为一个字节序列，并从指定的字节指针开始存储该字节序列。
GetBytes(Char[])	在派生类中重写时，将指定字符数组中的所有字符编码为一个字节序列。 (继承自 Encoding)
GetBytes(Char[], Int32, Int32)	在派生类中重写时，将指定字符数组中的一组字符编码为一个字节序列。 (继承自 Encoding)
GetBytes(Char[], Int32, Int32, Byte[], Int32)	将指定字符数组中的一组字符编码到指定的字节数组中。
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	在派生类中重写时，将指定只读范围中的一组字符编码为字节范围。 (继承自 Encoding)
GetBytes(String)	在派生类中重写时，将指定字符串中的所有字符编码为一个字节序列。 (继承自 Encoding)
GetBytes(String, Int32, Int32)	在派生类中重写时，从指定的 `index` 开始，将指定字符串中由 `count` 指定的字符数编码为字节数组。 (继承自 Encoding)
GetBytes(String, Int32, Int32, Byte[], Int32)	将指定 String 中的一组字符编码到指定的字节数组中。
GetCharCount(Byte*, Int32)	计算对一个字节序列（从指定的字节指针开始）进行解码所产生的字符数。
GetCharCount(Byte[])	在派生类中重写时，计算对指定字节数组中的所有字节进行解码所产生的字符数。 (继承自 Encoding)
GetCharCount(Byte[], Int32, Int32)	计算对指定字节数组中的一个字节序列进行解码所产生的字符数。
GetCharCount(ReadOnlySpan<Byte>)	在派生类中重写时，计算对提供的只读字节范围进行解码所产生的字符数。 (继承自 Encoding)
GetChars(Byte, Int32, Char, Int32)	将从指定的字节指针开始的一个字节序列解码为一组字符，并从指定的字符指针开始存储这组字符。
GetChars(Byte[])	在派生类中重写时，将指定字节数组中的所有字节解码为一组字符。 (继承自 Encoding)
GetChars(Byte[], Int32, Int32)	在派生类中重写时，将指定字节数组中的一个字节序列解码为一组字符。 (继承自 Encoding)
GetChars(Byte[], Int32, Int32, Char[], Int32)	将指定字节数组中的一个字节序列解码为指定的字符数组。
GetChars(ReadOnlySpan<Byte>, Span<Char>)	在派生类中重写时，将指定只读字节范围中的所有字节解码为字符范围。 (继承自 Encoding)
GetDecoder()	获取可以将 UTF-32 编码的字节序列转换为 Unicode 字符序列的解码器。
GetEncoder()	获取可将 Unicode 字符序列转换为 UTF-32 编码的字节序列的编码器。
GetHashCode()	返回当前实例的哈希代码。
GetMaxByteCount(Int32)	计算对指定数目的字符进行编码时产生的最大字节数。
GetMaxCharCount(Int32)	计算对指定数目的字节进行解码时产生的最大字符数。
GetPreamble()	返回采用 UTF-32 格式编码的 Unicode 字节顺序标记（如果 UTF32Encoding 对象配置为提供一个这样的标记）。
GetString(Byte*, Int32)	在派生类中重写时，将在指定地址开始的指定字节数解码为字符串。 (继承自 Encoding)
GetString(Byte[])	在派生类中重写时，将指定字节数组中的所有字节解码为一个字符串。 (继承自 Encoding)
GetString(Byte[], Int32, Int32)	将字节数组中某个范围的字节解码为一个字符串。
GetString(ReadOnlySpan<Byte>)	在派生类中重写时，将指定字节范围中的所有字节解码为一个字符串。 (继承自 Encoding)
GetType()	获取当前实例的 Type。 (继承自 Object)
IsAlwaysNormalized()	使用默认范式获取一个值，该值指示当前编码是否始终被规范化。 (继承自 Encoding)
IsAlwaysNormalized(NormalizationForm)	在派生类中重写时，使用指定范式获取一个值，该值指示当前编码是否始终被规范化。 (继承自 Encoding)
MemberwiseClone()	创建当前 Object 的浅表副本。 (继承自 Object)
ToString()	返回表示当前对象的字符串。 (继承自 Object)
TryGetBytes(ReadOnlySpan<Char>, Span<Byte>, Int32)	如果目标足够大，则从指定的只读范围将一组字符编码为字节范围。 (继承自 Encoding)
TryGetChars(ReadOnlySpan<Byte>, Span<Char>, Int32)	如果目标足够大，则从指定的只读范围将一组字节解码为字符范围。 (继承自 Encoding)

扩展方法

GetBytes(Encoding, ReadOnlySequence<Char>)	使用指定的 Encoding 将指定的 ReadOnlySequence<T> 编码到 Byte 数组中。
GetBytes(Encoding, ReadOnlySequence<Char>, IBufferWriter<Byte>)	使用指定的 Encoding 将指定的 ReadOnlySequence<T> 解码为 `byte`，并将结果写入 `writer`。
GetBytes(Encoding, ReadOnlySequence<Char>, Span<Byte>)	使用指定的 Encoding 将指定的 ReadOnlySequence<T> 编码为 `byte`，并将结果输出到 `bytes`。
GetBytes(Encoding, ReadOnlySpan<Char>, IBufferWriter<Byte>)	使用指定的 Encoding 将指定的 ReadOnlySpan<T> 编码为 `byte`，并将结果写入 `writer`。
GetChars(Encoding, ReadOnlySequence<Byte>, IBufferWriter<Char>)	使用指定的 Encoding 将指定的 ReadOnlySequence<T> 解码为 `char`，并将结果写入 `writer`。
GetChars(Encoding, ReadOnlySequence<Byte>, Span<Char>)	使用指定的 Encoding 将指定的 ReadOnlySequence<T> 解码为 `char`，并将结果输出到 `chars`。
GetChars(Encoding, ReadOnlySpan<Byte>, IBufferWriter<Char>)	使用指定的 Encoding 将指定的 ReadOnlySpan<T> 解码为 `char`，并将结果写入 `writer`。
GetString(Encoding, ReadOnlySequence<Byte>)	使用指定的 Encoding 将指定的 ReadOnlySequence<T> 解码到 String。

适用于

通过

UTF32Encoding 类

定义

示例

注解

构造函数

属性

方法

扩展方法

适用于

另请参阅

其他资源