UnicodeEncoding 类

参考

定义

命名空间:: System.Text

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

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: UnicodeEncoding.cs

Source:: UnicodeEncoding.cs

Source:: UnicodeEncoding.cs

重要

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

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

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

public class UnicodeEncoding : System.Text.Encoding

[System.Serializable]
public class UnicodeEncoding : System.Text.Encoding

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class UnicodeEncoding : System.Text.Encoding

type UnicodeEncoding = class
    inherit Encoding

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

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type UnicodeEncoding = class
    inherit Encoding

Public Class UnicodeEncoding
Inherits Encoding

继承: Object

Encoding
UnicodeEncoding

属性: SerializableAttribute ComVisibleAttribute

示例

以下示例演示如何使用 UnicodeEncoding 对象将 Unicode 字符字符串编码为字节数组。字节数组被解码为字符串，以证明没有数据丢失。

using namespace System;
using namespace System::Text;
using namespace System::Collections;
int main()
{
   
   // The encoding.
   UnicodeEncoding^ unicode = gcnew UnicodeEncoding;
   
   // Create a String* that contains Unicode characters.
   String^ unicodeString = L"This Unicode string contains two characters with codes outside the traditional ASCII code range, Pi (\u03a0) and Sigma (\u03a3).";
   Console::WriteLine( "Original string:" );
   Console::WriteLine( unicodeString );
   
   // Encode the String*.
   array<Byte>^encodedBytes = unicode->GetBytes( unicodeString );
   Console::WriteLine();
   Console::WriteLine( "Encoded bytes:" );
   IEnumerator^ myEnum = encodedBytes->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Byte b = safe_cast<Byte>(myEnum->Current);
      Console::Write( "[{0}]", b );
   }

   Console::WriteLine();
   
   // Decode bytes back to String*.
   // Notice Pi and Sigma characters are still present.
   String^ decodedString = unicode->GetString( encodedBytes );
   Console::WriteLine();
   Console::WriteLine( "Decoded bytes:" );
   Console::WriteLine( decodedString );
}

using System;
using System.Text;

class UnicodeEncodingExample {
    public static void Main() {
        // The encoding.
        UnicodeEncoding unicode = new UnicodeEncoding();
        
        // Create a string that contains Unicode characters.
        String unicodeString =
            "This Unicode string contains two characters " +
            "with codes outside the traditional ASCII code range, " +
            "Pi (\u03a0) and Sigma (\u03a3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);

        // Encode the string.
        Byte[] encodedBytes = unicode.GetBytes(unicodeString);
        Console.WriteLine();
        Console.WriteLine("Encoded bytes:");
        foreach (Byte b in encodedBytes) {
            Console.Write("[{0}]", b);
        }
        Console.WriteLine();
        
        // Decode bytes back to string.
        // Notice Pi and Sigma characters are still present.
        String decodedString = unicode.GetString(encodedBytes);
        Console.WriteLine();
        Console.WriteLine("Decoded bytes:");
        Console.WriteLine(decodedString);
    }
}

Imports System.Text
Imports Microsoft.VisualBasic.Strings

Class UnicodeEncodingExample
    
    Public Shared Sub Main()
        ' The encoding.
        Dim uni As New UnicodeEncoding()
        
        ' Create a string that contains Unicode characters.
        Dim unicodeString As String = _
            "This Unicode string contains two characters " & _
            "with codes outside the traditional ASCII code range, " & _
            "Pi (" & ChrW(928) & ") and Sigma (" & ChrW(931) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine(unicodeString)
        
        ' Encode the string.
        Dim encodedBytes As Byte() = uni.GetBytes(unicodeString)
        Console.WriteLine()
        Console.WriteLine("Encoded bytes:")
        Dim b As Byte
        For Each b In  encodedBytes
            Console.Write("[{0}]", b)
        Next b
        Console.WriteLine()
        
        ' Decode bytes back to string.
        ' Notice Pi and Sigma characters are still present.
        Dim decodedString As String = uni.GetString(encodedBytes)
        Console.WriteLine()
        Console.WriteLine("Decoded bytes:")
        Console.WriteLine(decodedString)
    End Sub
End Class

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

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
        // Create a UTF-16 encoding that supports a BOM.
        Encoding unicode = new UnicodeEncoding();

        // A Unicode string with two characters outside an 8-bit code range.
        String unicodeString =
            "This Unicode string has 2 characters outside the " +
            "ASCII range: \n" +
            "Pi (\u03A0)), and Sigma (\u03A3).";
        Console.WriteLine("Original string:");
        Console.WriteLine(unicodeString);
        Console.WriteLine();

        // Encode the string.
        Byte[] encodedBytes = unicode.GetBytes(unicodeString);
        Console.WriteLine("The encoded string has {0} bytes.\n",
                          encodedBytes.Length);

        // Write the bytes to a file with a BOM.
        var fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Create);
        Byte[] bom = unicode.GetPreamble();
        fs.Write(bom, 0, bom.Length);
        fs.Write(encodedBytes, 0, encodedBytes.Length);
        Console.WriteLine("Wrote {0} bytes to the file.\n", fs.Length);
        fs.Close();

        // Open the file using StreamReader.
        var sr = new StreamReader(@".\UTF8Encoding.txt");
        String newString = sr.ReadToEnd();
        sr.Close();
        Console.WriteLine("String read using StreamReader:");
        Console.WriteLine(newString);
        Console.WriteLine();

        // Open the file as a binary file and decode the bytes back to a string.
        fs = new FileStream(@".\UTF8Encoding.txt", FileMode.Open);
        Byte[] bytes = new Byte[fs.Length];
        fs.Read(bytes, 0, (int)fs.Length);
        fs.Close();

        String decodedString = unicode.GetString(bytes);
        Console.WriteLine("Decoded bytes:");
        Console.WriteLine(decodedString);
   }
}
// The example displays the following output:
//    Original string:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    The encoded string has 172 bytes.
//
//    Wrote 174 bytes to the file.
//
//    String read using StreamReader:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).
//
//    Decoded bytes:
//    This Unicode string has 2 characters outside the ASCII range:
//    Pi (π), and Sigma (Σ).

Imports System.IO
Imports System.Text

Class Example
    Public Shared Sub Main()
        ' Create a UTF-16 encoding that supports a BOM.
        Dim unicode As New UnicodeEncoding()
        
        ' A Unicode string with two characters outside an 8-bit code range.
        Dim unicodeString As String = _
            "This Unicode string has 2 characters outside the " &
            "ASCII range: " & vbCrLf &
            "Pi (" & ChrW(&h03A0) & "), and Sigma (" & ChrW(&h03A3) & ")."
        Console.WriteLine("Original string:")
        Console.WriteLine(unicodeString)
        Console.WriteLine()
        
        ' Encode the string.
        Dim encodedBytes As Byte() = unicode.GetBytes(unicodeString)
        Console.WriteLine("The encoded string has {0} bytes.",
                          encodedBytes.Length)
        Console.WriteLine()
        
        ' Write the bytes to a file with a BOM.
        Dim fs As New FileStream(".\UnicodeEncoding.txt", FileMode.Create)
        Dim bom() As Byte = unicode.GetPreamble()
        fs.Write(bom, 0, bom.Length)
        fs.Write(encodedBytes, 0, encodedBytes.Length)
        Console.WriteLine("Wrote {0} bytes to the file.", fs.Length)
        fs.Close()
        Console.WriteLine()
        
        ' Open the file using StreamReader.
        Dim sr As New StreamReader(".\UnicodeEncoding.txt")
        Dim newString As String = sr.ReadToEnd()
        sr.Close()
        Console.WriteLine("String read using StreamReader:")
        Console.WriteLine(newString)
        Console.WriteLine()
        
        ' Open the file as a binary file and decode the bytes back to a string.
        fs = new FileStream(".\UnicodeEncoding.txt", FileMode.Open)
        Dim bytes(fs.Length - 1) As Byte
        fs.Read(bytes, 0, fs.Length)
        fs.Close()

        Dim decodedString As String = unicode.GetString(bytes)
        Console.WriteLine("Decoded bytes:")
        Console.WriteLine(decodedString)
    End Sub
End Class
' The example displays the following output:
'    Original string:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    The encoded string has 172 bytes.
'
'    Wrote 174 bytes to the file.
'
'    String read using StreamReader:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).
'
'    Decoded bytes:
'    This Unicode string has 2 characters outside the ASCII range:
'    Pi (π), and Sigma (Σ).

注解

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

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

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

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

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

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

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

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

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

注意

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

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

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

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

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

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

构造函数

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

字段

CharSize

表示 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-16 格式编码的 Unicode 字节顺序标记（如果此对象配置为提供一个这样的标记）。
Preamble	在派生类中重写时，返回包含指定所用编码的字节序列的范围。 (继承自 Encoding)
WebName	在派生类中重写时，获取在 Internet 编号分配管理机构 (IANA) 注册的当前编码的名称。 (继承自 Encoding)
WindowsCodePage	在派生类中重写时，获取与当前编码最紧密对应的 Windows 操作系统代码页。 (继承自 Encoding)

方法

Clone()	当在派生类中重写时，创建当前 Encoding 对象的一个卷影副本。 (继承自 Encoding)
Equals(Object)	确定指定的 Object 是否等于当前的 UnicodeEncoding 对象。
GetByteCount(Char*, Int32)	计算对从指定的字符指针开始的一组字符进行编码时产生的字节数。
GetByteCount(Char*, Int32)	在派生类中重写时，计算对一组字符（从指定的字符指针处开始）进行编码所产生的字节数。 (继承自 Encoding)
GetByteCount(Char[])	在派生类中重写时，计算对指定字符数组中的所有字符进行编码所产生的字节数。 (继承自 Encoding)
GetByteCount(Char[], Int32, Int32)	计算对指定字符数组中的一组字符进行编码时产生的字节数。
GetByteCount(ReadOnlySpan<Char>)	在派生类中重写时，计算对指定字符范围的字符进行编码所产生的字节数。 (继承自 Encoding)
GetByteCount(String)	计算对指定字符串中的字符进行编码时所产生的字节数。
GetByteCount(String, Int32, Int32)	在派生类中重写时，计算对指定字符串中的一组字符进行编码所产生的字节数。 (继承自 Encoding)
GetBytes(Char, Int32, Byte, Int32)	将从指定的字符指针开始的一组字符编码为一个字节序列，并从指定的字节指针开始存储该字节序列。
GetBytes(Char, Int32, Byte, Int32)	在派生类中重写时，将一组字符（从指定的字符指针开始）编码为一个字节序列，并从指定的字节指针开始存储该字节序列。 (继承自 Encoding)
GetBytes(Char[])	在派生类中重写时，将指定字符数组中的所有字符编码为一个字节序列。 (继承自 Encoding)
GetBytes(Char[], Int32, Int32)	在派生类中重写时，将指定字符数组中的一组字符编码为一个字节序列。 (继承自 Encoding)
GetBytes(Char[], Int32, Int32, Byte[], Int32)	将指定字符数组中的一组字符编码到指定的字节数组中。
GetBytes(ReadOnlySpan<Char>, Span<Byte>)	在派生类中重写时，将指定只读范围中的一组字符编码为字节范围。 (继承自 Encoding)
GetBytes(String)	将指定字符串中的一组字符编码为指定的字节数组。
GetBytes(String)	在派生类中重写时，将指定字符串中的所有字符编码为一个字节序列。 (继承自 Encoding)
GetBytes(String, Int32, Int32)	在派生类中重写时，从指定的 `index` 开始，将指定字符串中由 `count` 指定的字符数编码为字节数组。 (继承自 Encoding)
GetBytes(String, Int32, Int32, Byte[], Int32)	将指定 String 中的一组字符编码到指定的字节数组中。
GetCharCount(Byte*, Int32)	计算对一个字节序列（从指定的字节指针开始）进行解码所产生的字符数。
GetCharCount(Byte*, Int32)	在派生类中重写时，计算对字节序列（从指定的字节指针开始）进行解码所产生的字符数。 (继承自 Encoding)
GetCharCount(Byte[])	在派生类中重写时，计算对指定字节数组中的所有字节进行解码所产生的字符数。 (继承自 Encoding)
GetCharCount(Byte[], Int32, Int32)	计算对指定字节数组中的一个字节序列进行解码所产生的字符数。
GetCharCount(ReadOnlySpan<Byte>)	在派生类中重写时，计算对提供的只读字节范围进行解码所产生的字符数。 (继承自 Encoding)
GetChars(Byte, Int32, Char, Int32)	将从指定的字节指针开始的一个字节序列解码为一组字符，并从指定的字符指针开始存储这组字符。
GetChars(Byte, Int32, Char, Int32)	在派生类中重写时，将一个字节序列（从指定的字节指针开始）解码为一组字符，并从指定的字符指针开始存储该组字符。 (继承自 Encoding)
GetChars(Byte[])	在派生类中重写时，将指定字节数组中的所有字节解码为一组字符。 (继承自 Encoding)
GetChars(Byte[], Int32, Int32)	在派生类中重写时，将指定字节数组中的一个字节序列解码为一组字符。 (继承自 Encoding)
GetChars(Byte[], Int32, Int32, Char[], Int32)	将指定字节数组中的一个字节序列解码为指定的字符数组。
GetChars(ReadOnlySpan<Byte>, Span<Char>)	在派生类中重写时，将指定只读字节范围中的所有字节解码为字符范围。 (继承自 Encoding)
GetDecoder()	获取可以将 UTF-16 编码的字节序列转换为 Unicode 字符序列的解码器。
GetEncoder()	获取可将 Unicode 字符序列转换为 UTF-16 编码的字节序列的编码器。
GetEncoder()	在派生类中重写时，获取一个解码器，该解码器将 Unicode 字符序列转换为已编码的字节序列。 (继承自 Encoding)
GetHashCode()	返回当前实例的哈希代码。
GetMaxByteCount(Int32)	计算对指定数目的字符进行编码时产生的最大字节数。
GetMaxCharCount(Int32)	计算对指定数目的字节进行解码时产生的最大字符数。
GetPreamble()	如果此实例的构造函数请求一个字节顺序标记，则将返回用 UTF-16 格式编码的 Unicode 字节顺序标记。
GetString(Byte*, Int32)	在派生类中重写时，将在指定地址开始的指定字节数解码为字符串。 (继承自 Encoding)
GetString(Byte[])	在派生类中重写时，将指定字节数组中的所有字节解码为一个字符串。 (继承自 Encoding)
GetString(Byte[], Int32, Int32)	将字节数组中某个范围的字节解码为一个字符串。
GetString(Byte[], Int32, Int32)	在派生类中重写时，将指定字节数组中的一个字节序列解码为一个字符串。 (继承自 Encoding)
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。

适用于

另请参阅

反馈

此页面是否有帮助？