Convert 类

参考

定义

命名空间:: System

程序集:: System.Runtime.Extensions.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

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

将一个基本数据类型转换为另一个基本数据类型。

public ref class Convert abstract sealed

public ref class Convert sealed

public static class Convert

public sealed class Convert

type Convert = class

Public Class Convert

Public NotInheritable Class Convert

继承: Object
Convert

示例

以下示例演示类中的 Convert 一些转换方法，包括 ToInt32， ToBoolean和 ToString。

Double dNumber = 23.15;

try
{
   // Returns 23
   Int32 iNumber = Convert::ToInt32( dNumber );
}
catch ( OverflowException^ ) 
{
   Console::WriteLine(
      "Overflow in Double to Int32 conversion" );
}
// Returns True
Boolean bNumber = Convert::ToBoolean( dNumber );

// Returns "23.15"
String^ strNumber = Convert::ToString( dNumber );

try
{
   // Returns '2'
   Char chrNumber = Convert::ToChar( strNumber->Substring( 0, 1 ) );
}
catch ( ArgumentNullException^ ) 
{
   Console::WriteLine(  "String is null" );
}
catch ( FormatException^ ) 
{
   Console::WriteLine(  "String length is greater than 1" );
}

// System::Console::ReadLine() returns a string and it
// must be converted.
Int32 newInteger = 0;
try
{
   Console::WriteLine(  "Enter an integer:" );
   newInteger = Convert::ToInt32( System::Console::ReadLine() );
}
catch ( ArgumentNullException^ ) 
{
   Console::WriteLine(  "String is null" );
}
catch ( FormatException^ ) 
{
   Console::WriteLine(  "String does not consist of an " +
      "optional sign followed by a series of digits" );
}
catch ( OverflowException^ ) 
{
   Console::WriteLine(  "Overflow in string to Int32 conversion" );
}

Console::WriteLine( "Your integer as a Double is {0}",
   Convert::ToDouble( newInteger ) );

double dNumber = 23.15;

try {
    // Returns 23
    int    iNumber = System.Convert.ToInt32(dNumber);
}
catch (System.OverflowException) {
    System.Console.WriteLine(
                "Overflow in double to int conversion.");
}
// Returns True
bool   bNumber = System.Convert.ToBoolean(dNumber);

// Returns "23.15"
string strNumber = System.Convert.ToString(dNumber);

try {
    // Returns '2'
    char chrNumber = System.Convert.ToChar(strNumber[0]);
}
catch (System.ArgumentNullException) {
    System.Console.WriteLine("String is null");
}
catch (System.FormatException) {
    System.Console.WriteLine("String length is greater than 1.");
}

// System.Console.ReadLine() returns a string and it
// must be converted.
int newInteger = 0;
try {
    System.Console.WriteLine("Enter an integer:");
    newInteger = System.Convert.ToInt32(
                        System.Console.ReadLine());
}
catch (System.ArgumentNullException) {
    System.Console.WriteLine("String is null.");
}
catch (System.FormatException) {
    System.Console.WriteLine("String does not consist of an " +
                    "optional sign followed by a series of digits.");
}
catch (System.OverflowException) {
    System.Console.WriteLine(
    "Overflow in string to int conversion.");
}

System.Console.WriteLine("Your integer as a double is {0}",
                         System.Convert.ToDouble(newInteger));

let dNumber = 23.15

try
    // Returns 23
    Convert.ToInt32 dNumber
    |> ignore
with :? OverflowException ->
    printfn "Overflow in double to int conversion."
// Returns True
let bNumber = System.Convert.ToBoolean dNumber

// Returns "23.15"
let strNumber = System.Convert.ToString dNumber

try
    // Returns '2'
    System.Convert.ToChar strNumber[0]
    |> ignore
with
| :? ArgumentNullException ->
    printfn "String is null"
| :? FormatException ->
    printfn "String length is greater than 1."

// System.Console.ReadLine() returns a string and it
// must be converted.
let newInteger =
    try
        printfn "Enter an integer:"
        System.Convert.ToInt32(Console.ReadLine())
    with
    | :? ArgumentNullException ->
        printfn "String is null."
        0
    | :? FormatException ->
        printfn "String does not consist of an optional sign followed by a series of digits."
        0
    | :? OverflowException ->
        printfn "Overflow in string to int conversion."
        0

printfn $"Your integer as a double is {System.Convert.ToDouble newInteger}"

Dim dNumber As Double
dNumber = 23.15

Try
   ' Returns 23
   Dim iNumber As Integer
   iNumber = System.Convert.ToInt32(dNumber)
Catch exp As System.OverflowException
   System.Console.WriteLine("Overflow in double to int conversion.")
End Try

' Returns True
Dim bNumber As Boolean
bNumber = System.Convert.ToBoolean(dNumber)

' Returns "23.15"
Dim strNumber As String
strNumber = System.Convert.ToString(dNumber)

Try
   ' Returns '2'
   Dim chrNumber As Char
   chrNumber = System.Convert.ToChar(strNumber.Chars(1))
Catch exp As System.ArgumentNullException
   System.Console.WriteLine("String is null.")
Catch exp As System.FormatException
   System.Console.WriteLine("String length is greater than 1.")
End Try

' System.Console.ReadLine() returns a string and it
' must be converted.
Dim newInteger As Integer
newInteger = 0
Try
   System.Console.WriteLine("Enter an integer:")
   newInteger = System.Convert.ToInt32(System.Console.ReadLine())
Catch exp As System.ArgumentNullException
   System.Console.WriteLine("String is null.")
Catch exp As System.FormatException
   System.Console.WriteLine("String does not consist of an " + _
       "optional sign followed by a series of digits.")
Catch exp As System.OverflowException
   System.Console.WriteLine("Overflow in string to int conversion.")
End Try

System.Console.WriteLine("Your integer as a double is {0}", _
                         System.Convert.ToDouble(newInteger))

注解

类的 Convert 静态方法主要用于支持在 .NET 中转换到基本数据类型和从基数据类型转换。支持的基类型包括Boolean、、、SByte Byte、UInt64 Int64 UInt32 Int32 UInt16 Int16、Single、、Double、和。 Decimal DateTime String Char 此外，该 Convert 类还包含用于支持其他类型的转换的方法。

本文包含以下部分：

从基类型非十进制数转换到基类型区域性特定格式设置信息 Base64 编码其他常见转换

从基类型转换

存在一种转换方法，用于将每个基类型转换为所有其他基类型。但是，对特定转换方法的实际调用可能会产生五个结果之一，具体取决于运行时基类型的值和目标基类型。这五个结果包括：

无转换。当尝试从类型转换为自身 (（例如，通过使用类型) 的参数Int32进行调用Convert.ToInt32(Int32)）时，将发生这种情况。在这种情况下，该方法只返回原始类型的实例。
InvalidCastException。不支持特定转换时会出现这种情况。引发以下转换的一个 InvalidCastException 值：
- 从 Char Boolean、 Single、 Double、 Decimal或 DateTime.
- 从 Boolean、 Single、 Double、 Decimal或 DateTime 到的 Char转换。
- 从 DateTime 其他任何类型 String转换。
- 从除其他任何类型（除外 String）到 DateTime的转换。
FormatException。当尝试将字符串值转换为任何其他基类型失败时，将发生这种情况，因为字符串的格式不正确。以下转换将引发异常：
- 要转换为 Boolean 值的字符串不等于 Boolean.TrueString 或 Boolean.FalseString。
- 要转换为 Char 值的字符串由多个字符组成。
- 要转换为任何数值类型的字符串无法识别为有效数字。
- 要转换为 a DateTime 的字符串无法识别为有效的日期和时间值。
成功转换。对于上述结果中未列出的两种不同基类型之间的转换，所有扩大的转换以及不会导致数据丢失的所有缩小转换都将成功，并且该方法将返回目标基类型的值。
OverflowException。当缩小转换会导致数据丢失时，会出现这种情况。例如，尝试将值为 10000 Byte 的实例转换为Int32类型会引发一个OverflowException，因为 10000 超出了数据类型的范围Byte。

如果数值类型的转换导致精度 (丢失，则不会引发异常，即丢失一些最小有效数字) 。但是，如果结果大于特定转换方法的返回值类型可以表示，则会引发异常。

例如，当 a Double 转换为 a Single时，可能会丢失精度，但不会引发异常。但是，如果大小 Double 太大，无法由 a Single表示，则会引发溢出异常。

非十进制数

该 Convert 类包含静态方法，可以调用这些方法将整型值转换为非十进制字符串表示形式，并将表示非十进制数的字符串转换为整型值。每个转换方法都包含一个 base 参数，用于指定数字系统;二进制 (基 2) 、八进制 (基 8) ，以及十六进制 (基 16) ，以及十六进制 (基 10) 。有一组方法可将每个符合 CLS 的基元整型类型转换为字符串，一个方法将字符串转换为每个基元整型类型：

ToString(Byte, Int32) 以及 ToByte(String, Int32)，将字节值转换为指定基数中的字符串和从字符串转换。
ToString(Int16, Int32) 以及 ToInt16(String, Int32)，将 16 位带符号整数转换为指定基数中的字符串和从字符串转换。
ToString(Int32, Int32) 以及 ToInt32(String, Int32)，将 32 位带符号整数转换为指定基数中的字符串和从字符串转换。
ToString(Int64, Int32) 以及 ToInt64(String, Int32)，将 64 位带符号整数转换为指定基数中的字符串和从字符串转换。
ToSByte(String, Int32)，以指定格式将字节值的字符串表示形式转换为带符号字节。
ToUInt16(String, Int32)，以指定格式将整数的字符串表示形式转换为无符号 16 位整数。
ToUInt32(String, Int32)，以指定格式将整数的字符串表示形式转换为无符号 32 位整数。
ToUInt64(String, Int32)，以指定格式将整数的字符串表示形式转换为无符号 64 位整数。

以下示例将所有支持的数值格式转换为字符串的值 Int16.MaxValue 。然后，它将字符串值转换回值 Int16 。

using namespace System;

void main()
{
   array<int>^ baseValues = { 2, 8, 10, 16 };
   Int16 value = Int16::MaxValue;
   for each (Int16 baseValue in baseValues) {
      String^ s = Convert::ToString(value, baseValue);
      Int16 value2 = Convert::ToInt16(s, baseValue);

      Console::WriteLine("{0} --> {1} (base {2}) --> {3}", 
                        value, s, baseValue, value2);
   }                     
}
// The example displays the following output:
//     32767 --> 111111111111111 (base 2) --> 32767
//     32767 --> 77777 (base 8) --> 32767
//     32767 --> 32767 (base 10) --> 32767
//     32767 --> 7fff (base 16) --> 32767

using System;

public class Example
{
   public static void Main()
   {
      int[] baseValues = { 2, 8, 10, 16 };
      short value = Int16.MaxValue;
      foreach (var baseValue in baseValues) {
         String s = Convert.ToString(value, baseValue);
         short value2 = Convert.ToInt16(s, baseValue);

         Console.WriteLine("{0} --> {1} (base {2}) --> {3}",
                           value, s, baseValue, value2);
      }
   }
}
// The example displays the following output:
//     32767 --> 111111111111111 (base 2) --> 32767
//     32767 --> 77777 (base 8) --> 32767
//     32767 --> 32767 (base 10) --> 32767
//     32767 --> 7fff (base 16) --> 32767

open System

let baseValues = [ 2; 8; 10; 16 ]
let value = Int16.MaxValue
for baseValue in baseValues do
    let s = Convert.ToString(value, baseValue)
    let value2 = Convert.ToInt16(s, baseValue)
    printfn $"{value} --> {s} (base {baseValue}) --> {value2}"

// The example displays the following output:
//     32767 --> 111111111111111 (base 2) --> 32767
//     32767 --> 77777 (base 8) --> 32767
//     32767 --> 32767 (base 10) --> 32767
//     32767 --> 7fff (base 16) --> 32767

Module Example
   Public Sub Main()
      Dim baseValues() As Integer = { 2, 8, 10, 16 }
      Dim value As Short = Int16.MaxValue
      For Each baseValue in baseValues
         Dim s As String = Convert.ToString(value, baseValue)
         Dim value2 As Short = Convert.ToInt16(s, baseValue)

         Console.WriteLine("{0} --> {1} (base {2}) --> {3}", 
                           value, s, baseValue, value2)
      Next
   End Sub
End Module
' The example displays the following output:
'     32767 --> 111111111111111 (base 2) --> 32767
'     32767 --> 77777 (base 8) --> 32767
'     32767 --> 32767 (base 10) --> 32767
'     32767 --> 7fff (base 16) --> 32767

从自定义对象转换为基类型

除了支持基类型之间的转换外，该方法 Convert 还支持将任何自定义类型转换为任何基类型。为此，自定义类型必须实现 IConvertible 接口，该接口定义将实现类型转换为每个基类型的方法。特定类型不支持的转换应引发一个 InvalidCastException。

ChangeType当方法作为第一个参数传递自定义类型时，或者Convert.To当 Type 方法 (（例如Convert.ToInt32(Object)或Convert.ToDouble(Object, IFormatProvider)被调用）并传递自定义类型的实例作为其第一个参数时，该方法Convert又调用自定义类型的IConvertible实现来执行转换。有关详细信息，请参阅 .NET 中的类型转换。

Culture-Specific格式设置信息

所有基类型转换方法和 ChangeType 方法都包含具有类型 IFormatProvider参数的重载。例如，该方法 Convert.ToBoolean 具有以下两个重载：

该 IFormatProvider 参数可以提供区域性特定的格式设置信息，以帮助转换过程。但是，大多数基类型转换方法都会忽略它。它仅由以下基类型转换方法使用。如果参数nullIFormatProvider传递给这些方法，CultureInfo则使用表示当前区域性的对象。

通过将值转换为数值类型的方法。该 IFormatProvider 参数由具有类型 String 参数和 IFormatProvider. 它还由具有类型Object IFormatProvider参数的重载以及对象的运行时类型是一个 String。
通过将值转换为日期和时间的方法。该 IFormatProvider 参数由具有类型 String 参数和 IFormatProvider. 它还由具有类型Object IFormatProvider参数的重载以及对象的运行时类型是一个 String。
Convert.ToString由包含IFormatProvider参数的重载，并将数值转换为字符串或DateTime将值转换为字符串。

但是，任何实现 IConvertible 的用户定义类型都可以使用 IFormatProvider 参数。

Base64 编码

Base64 编码将二进制数据转换为字符串。可以通过仅传输 7 位字符的数据通道轻松传输以 base-64 位数字表示的数据。该 Convert 类包括以下支持 base64 编码的方法：一组方法支持将字节数组转换为或从 String 包含 base-64 数字字符的 Unicode 字符数组和从一组 Unicode 字符进行转换。

ToBase64String，它将字节数组转换为 base64 编码的字符串。
ToBase64CharArray，它将字节数组转换为 base64 编码的字符数组。
FromBase64String，它将 base64 编码的字符串转换为字节数组。
FromBase64CharArray，它将 base64 编码的字符数组转换为字节数组。

其他常见转换

可以使用 NET Framework 中的其他类来执行类的静态方法 Convert 不支持的某些转换。这些方法包括：

转换为字节数组 BitConverter 的类提供了将基元数值类型转换为 (的方法，包括 Boolean) 字节数组，以及从字节数组转换回基元数据类型的方法。

字符编码和解码类 Encoding 及其派生类 (（如 UnicodeEncoding 和 UTF8Encoding) ）提供对字符数组或字符串 (进行编码的方法，以特定编码) 将它们转换为字节数组，并解码编码的字节数组 (即将字节数组转换为 UTF16 编码的 Unicode 字符。有关详细信息，请参阅 .NET 中的字符编码。

字段

DBNull

一个常数，用于表示没有数据的数据库列；即数据库为空。

方法

ChangeType(Object, Type)	返回一个指定类型的对象，该对象的值等效于指定的对象。
ChangeType(Object, Type, IFormatProvider)	返回指定类型的对象，其值等效于指定对象。参数提供区域性特定的格式设置信息。
ChangeType(Object, TypeCode)	返回指定类型的对象，其值等效于指定对象。
ChangeType(Object, TypeCode, IFormatProvider)	返回指定类型的对象，其值等效于指定对象。参数提供区域性特定的格式设置信息。
FromBase64CharArray(Char[], Int32, Int32)	将 Unicode 字符数组（它将二进制数据编码为 Base64 数字）的子集转换为等效的 8 位无符号整数数组。参数指定输入数组的子集以及要转换的元素数。
FromBase64String(String)	将指定的字符串（它将二进制数据编码为 Base64 数字）转换为等效的 8 位无符号整数数组。
FromHexString(ReadOnlySpan<Char>)	将跨度（它将二进制数据编码为十六进制字符）转换为等效的 8 位无符号整数数组。
FromHexString(String)	将指定的字符串（它将二进制数据编码为十六进制字符）转换为等效的 8 位无符号整数数组。
GetTypeCode(Object)	返回指定对象的 TypeCode。
IsDBNull(Object)	返回有关指定对象是否为 DBNull 类型的指示。
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)	将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。参数将子集指定为输入和输出数组中的偏移量和输入数组中要转换的元素数。
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)	将 8 位无符号整数数组的子集转换为用 Base64 数字编码的 Unicode 字符数组的等价子集。参数指定作为输入和输出数组中偏移量的子集、输入数组中要转换的元素数以及是否在输出数组中插入分行符。
ToBase64String(Byte[])	将 8 位无符号整数的数组转换为其用 Base64 数字编码的等效字符串表示形式。
ToBase64String(Byte[], Base64FormattingOptions)	将 8 位无符号整数的数组转换为其用 Base64 数字编码的等效字符串表示形式。你可以指定是否在返回值中插入换行符。
ToBase64String(Byte[], Int32, Int32)	将 8 位无符号整数数组的子集转换为其用 Base64 数字编码的等效字符串表示形式。参数将子集指定为输入数组中的偏移量和数组中要转换的元素数。
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)	将 8 位无符号整数数组的子集转换为其用 Base64 数字编码的等效字符串表示形式。参数指定作为输入数组中偏移量的子集、数组中要转换的元素数以及是否在返回值中插入分行符。
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)	将指定的只读范围内的 8 位无符号整数转换为其用 base-64 数字编码的等效字符串表示形式。你可以选择指定是否在返回值中插入换行符。
ToBoolean(Boolean)	返回指定的布尔值；不执行任何实际的转换。
ToBoolean(Byte)	将指定的 8 位无符号整数的值转换为等效的布尔值。
ToBoolean(Char)	调用此方法始终引发 InvalidCastException。
ToBoolean(DateTime)	调用此方法始终引发 InvalidCastException。
ToBoolean(Decimal)	将指定的十进制数字的值转换为等效的布尔值。
ToBoolean(Double)	将指定的双精度浮点数的值转换为等效的布尔值。
ToBoolean(Int16)	将指定的 16 位有符号整数的值转换为等效的布尔值。
ToBoolean(Int32)	将指定的 32 位有符号整数的值转换为等效的布尔值。
ToBoolean(Int64)	将指定的 64 位有符号整数的值转换为等效的布尔值。
ToBoolean(Object)	将指定对象的值转换为等效的布尔值。
ToBoolean(Object, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定对象的值转换为等效的布尔值。
ToBoolean(SByte)	将指定的 8 位有符号整数的值转换为等效的布尔值。
ToBoolean(Single)	将指定的单精度浮点数的值转换为等效的布尔值。
ToBoolean(String)	将逻辑值的指定字符串表示形式转换为其等效的布尔值。
ToBoolean(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将逻辑值的指定字符串表示形式转换为其等效的布尔值。
ToBoolean(UInt16)	将指定的 16 位无符号整数的值转换为等效的布尔值。
ToBoolean(UInt32)	将指定的 32 位无符号整数的值转换为等效的布尔值。
ToBoolean(UInt64)	将指定的 64 位无符号整数的值转换为等效的布尔值。
ToByte(Boolean)	将指定的布尔值转换为等效的 8 位无符号整数。
ToByte(Byte)	返回指定的 8 位无符号整数；不执行任何实际的转换。
ToByte(Char)	将指定 Unicode 字符的值转换为等效的 8 位无符号整数。
ToByte(DateTime)	调用此方法始终引发 InvalidCastException。
ToByte(Decimal)	将指定的十进制数的值转换为等效的 8 位无符号整数。
ToByte(Double)	将指定的双精度浮点数的值转换为等效的 8 位无符号整数。
ToByte(Int16)	将指定的 16 位有符号整数的值转换为等效的 8 位无符号整数。
ToByte(Int32)	将指定的 32 位有符号整数的值转换为等效的 8 位无符号整数。
ToByte(Int64)	将指定的 64 位有符号整数的值转换为等效的 8 位无符号整数。
ToByte(Object)	将指定对象的值转换为 8 位无符号整数。
ToByte(Object, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定对象的值转换为 8 位无符号整数。
ToByte(SByte)	将指定的 8 位有符号整数的值转换为等效的 8 位无符号整数。
ToByte(Single)	将指定的单精度浮点数的值转换为等效的 8 位无符号整数。
ToByte(String)	将数字的指定字符串表示形式转换为等效的 8 位无符号整数。
ToByte(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 8 位无符号整数。
ToByte(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 8 位无符号整数。
ToByte(UInt16)	将指定的 16 位无符号整数的值转换为等效的 8 位无符号整数。
ToByte(UInt32)	将指定的 32 位无符号整数的值转换为等效的 8 位无符号整数。
ToByte(UInt64)	将指定的 64 位无符号整数的值转换为等效的 8 位无符号整数。
ToChar(Boolean)	调用此方法始终引发 InvalidCastException。
ToChar(Byte)	将指定的 8 位无符号整数的值转换为其等效的 Unicode 字符。
ToChar(Char)	返回指定的 Unicode 字符值；不执行任何实际的转换。
ToChar(DateTime)	调用此方法始终引发 InvalidCastException。
ToChar(Decimal)	调用此方法始终引发 InvalidCastException。
ToChar(Double)	调用此方法始终引发 InvalidCastException。
ToChar(Int16)	将指定的 16 位有符号整数的值转换为它的等效 Unicode 字符。
ToChar(Int32)	将指定的 32 位有符号整数的值转换为它的等效 Unicode 字符。
ToChar(Int64)	将指定的 64 位有符号整数的值转换为它的等效 Unicode 字符。
ToChar(Object)	将指定对象的值转换为 Unicode 字符。
ToChar(Object, IFormatProvider)	使用指定的区域性特定格式设置信息将指定对象的值转换为其等效的 Unicode 字符。
ToChar(SByte)	将指定的 8 位有符号整数的值转换为它的等效 Unicode 字符。
ToChar(Single)	调用此方法始终引发 InvalidCastException。
ToChar(String)	将指定字符串的第一个字符转换为 Unicode 字符。
ToChar(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定字符串的第一个字符转换为 Unicode 字符。
ToChar(UInt16)	将指定的 16 位无符号整数的值转换为其等效的 Unicode 字符。
ToChar(UInt32)	将指定的 32 位无符号整数的值转换为其等效的 Unicode 字符。
ToChar(UInt64)	将指定的 64 位无符号整数的值转换为其等效的 Unicode 字符。
ToDateTime(Boolean)	调用此方法始终引发 InvalidCastException。
ToDateTime(Byte)	调用此方法始终引发 InvalidCastException。
ToDateTime(Char)	调用此方法始终引发 InvalidCastException。
ToDateTime(DateTime)	返回指定的 DateTime 对象；不执行任何实际的转换。
ToDateTime(Decimal)	调用此方法始终引发 InvalidCastException。
ToDateTime(Double)	调用此方法始终引发 InvalidCastException。
ToDateTime(Int16)	调用此方法始终引发 InvalidCastException。
ToDateTime(Int32)	调用此方法始终引发 InvalidCastException。
ToDateTime(Int64)	调用此方法始终引发 InvalidCastException。
ToDateTime(Object)	将指定对象的值转换为 DateTime 对象。
ToDateTime(Object, IFormatProvider)	使用指定的区域性特定格式设置信息将指定对象的值转换为 DateTime 对象。
ToDateTime(SByte)	调用此方法始终引发 InvalidCastException。
ToDateTime(Single)	调用此方法始终引发 InvalidCastException。
ToDateTime(String)	将日期和时间的指定字符串表示形式转换为等效的日期和时间值。
ToDateTime(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的日期和时间。
ToDateTime(UInt16)	调用此方法始终引发 InvalidCastException。
ToDateTime(UInt32)	调用此方法始终引发 InvalidCastException。
ToDateTime(UInt64)	调用此方法始终引发 InvalidCastException。
ToDecimal(Boolean)	将指定的布尔值转换为等效的十进制数。
ToDecimal(Byte)	将指定的 8 位无符号整数的值转换为等效的十进制数。
ToDecimal(Char)	调用此方法始终引发 InvalidCastException。
ToDecimal(DateTime)	调用此方法始终引发 InvalidCastException。
ToDecimal(Decimal)	返回指定的十进制数；不执行任何实际的转换。
ToDecimal(Double)	将指定的双精度浮点数的值转换为等效的十进制数。
ToDecimal(Int16)	将指定的 16 位带符号整数的值转换为等效的十进制数。
ToDecimal(Int32)	将指定的 32 位带符号整数的值转换为等效的十进制数。
ToDecimal(Int64)	将指定的 64 位带符号整数的值转换为等效的十进制数。
ToDecimal(Object)	将指定对象的值转换为等效的十进制数。
ToDecimal(Object, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定对象的值转换为等效的十进制数。
ToDecimal(SByte)	将指定的 8 位带符号整数的值转换为等效的十进制数。
ToDecimal(Single)	将指定的单精度浮点数的值转换为等效的十进制数。
ToDecimal(String)	将数字的指定字符串表示形式转换为等效的十进制数。
ToDecimal(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的十进制数。
ToDecimal(UInt16)	将指定的 16 位无符号整数的值转换为等效的十进制数。
ToDecimal(UInt32)	将指定的 32 位无符号整数的值转换为等效的十进制数。
ToDecimal(UInt64)	将指定的 64 位无符号整数的值转换为等效的十进制数。
ToDouble(Boolean)	将指定的布尔值转换为等效的双精度浮点数。
ToDouble(Byte)	将指定的 8 位无符号整数的值转换为等效的双精度浮点数。
ToDouble(Char)	调用此方法始终引发 InvalidCastException。
ToDouble(DateTime)	调用此方法始终引发 InvalidCastException。
ToDouble(Decimal)	将指定的十进制数的值转换为等效的双精度浮点数。
ToDouble(Double)	返回指定的双精度浮点数；不执行任何实际的转换。
ToDouble(Int16)	将指定的 16 位带符号整数的值转换为等效的双精度浮点数。
ToDouble(Int32)	将指定的 32 位带符号整数的值转换为等效的双精度浮点数。
ToDouble(Int64)	将指定的 64 位带符号整数的值转换为等效的双精度浮点数。
ToDouble(Object)	将指定对象的值转换为双精度浮点数。
ToDouble(Object, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定对象的值转换为双精度浮点数。
ToDouble(SByte)	将指定的 8 位带符号整数的值转换为等效的双精度浮点数。
ToDouble(Single)	将指定的单精度浮点数的值转换为等效的双精度浮点数。
ToDouble(String)	将数字的指定字符串表示形式转换为等效的双精度浮点数。
ToDouble(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的双精度浮点数。
ToDouble(UInt16)	将指定的 16 位无符号整数的值转换为等效的双精度浮点数。
ToDouble(UInt32)	将指定的 32 位无符号整数的值转换为等效的双精度浮点数。
ToDouble(UInt64)	将指定的 64 位无符号整数的值转换为等效的双精度浮点数。
ToHexString(Byte[])	将 8 位无符号整数的数组转换为其用大写十六进制字符编码的等效字符串表示形式。
ToHexString(Byte[], Int32, Int32)	将 8 位无符号整数的子集转换为其用大写十六进制字符编码的等效字符串表示形式。参数将子集指定为输入数组中的偏移量和数组中要转换的元素数。
ToHexString(ReadOnlySpan<Byte>)	将 8 位无符号整数范围转换为其用大写十六进制字符编码的等效字符串表示形式。
ToInt16(Boolean)	将指定的布尔值转换为等效的 16 位带符号整数。
ToInt16(Byte)	将指定的 8 位无符号整数的值转换为等效的 16 位有符号整数。
ToInt16(Char)	将指定的 Unicode 字符的值转换为等效的 16 位有符号整数。
ToInt16(DateTime)	调用此方法始终引发 InvalidCastException。
ToInt16(Decimal)	将指定的十进制数的值转换为等效的 16 位带符号整数。
ToInt16(Double)	将指定的双精度浮点数的值转换为等效的 16 位带符号整数。
ToInt16(Int16)	返回指定的 16 位有符号整数；不执行实际的转换。
ToInt16(Int32)	将指定的 32 位有符号整数的值转换为等效的 16 位有符号整数。
ToInt16(Int64)	将指定的 64 位有符号整数的值转换为等效的 16 位有符号整数。
ToInt16(Object)	将指定对象的值转换为 16 位带符号整数。
ToInt16(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 16 位带符号整数。
ToInt16(SByte)	将指定的 8 位带符号整数的值转换为等效的 16 位带符号整数。
ToInt16(Single)	将指定的单精度浮点数的值转换为等效的 16 位带符号整数。
ToInt16(String)	将数字的指定字符串表示形式转换为等效的 16 位带符号整数。
ToInt16(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 16 位带符号整数。
ToInt16(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 16 位有符号整数。
ToInt16(UInt16)	将指定的 16 位无符号整数的值转换为等效的 16 位有符号整数。
ToInt16(UInt32)	将指定的 32 位无符号整数的值转换为等效的 16 位有符号整数。
ToInt16(UInt64)	将指定的 64 位无符号整数的值转换为等效的 16 位有符号整数。
ToInt32(Boolean)	将指定的布尔值转换为等效的 32 位带符号整数。
ToInt32(Byte)	将指定的 8 位无符号整数的值转换为等效的 32 位有符号整数。
ToInt32(Char)	将指定的 Unicode 字符的值转换为等效的 32 位有符号整数。
ToInt32(DateTime)	调用此方法始终引发 InvalidCastException。
ToInt32(Decimal)	将指定的十进制数的值转换为等效的 32 位带符号整数。
ToInt32(Double)	将指定的双精度浮点数的值转换为等效的 32 位带符号整数。
ToInt32(Int16)	将指定的 16 位有符号整数的值转换为等效的 32 位有符号整数。
ToInt32(Int32)	返回指定的 32 位有符号整数；不执行实际的转换。
ToInt32(Int64)	将指定的 64 位有符号整数的值转换为等效的 32 位有符号整数。
ToInt32(Object)	将指定对象的值转换为 32 位带符号整数。
ToInt32(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 32 位带符号整数。
ToInt32(SByte)	将指定的 8 位带符号整数的值转换为等效的 32 位带符号整数。
ToInt32(Single)	将指定的单精度浮点数的值转换为等效的 32 位带符号整数。
ToInt32(String)	将数字的指定字符串表示形式转换为等效的 32 位带符号整数。
ToInt32(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 32 位带符号整数。
ToInt32(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 32 位有符号整数。
ToInt32(UInt16)	将指定的 16 位无符号整数的值转换为等效的 32 位有符号整数。
ToInt32(UInt32)	将指定的 32 位无符号整数的值转换为等效的 32 位有符号整数。
ToInt32(UInt64)	将指定的 64 位无符号整数的值转换为等效的 32 位有符号整数。
ToInt64(Boolean)	将指定的布尔值转换为等效的 64 位带符号整数。
ToInt64(Byte)	将指定的 8 位无符号整数的值转换为等效的 64 位有符号整数。
ToInt64(Char)	将指定的 Unicode 字符的值转换为等效的 64 位有符号整数。
ToInt64(DateTime)	调用此方法始终引发 InvalidCastException。
ToInt64(Decimal)	将指定的十进制数的值转换为等效的 64 位带符号整数。
ToInt64(Double)	将指定的双精度浮点数的值转换为等效的 64 位带符号整数。
ToInt64(Int16)	将指定的 16 位有符号整数的值转换为等效的 64 位有符号整数。
ToInt64(Int32)	将指定的 32 位有符号整数的值转换为等效的 64 位有符号整数。
ToInt64(Int64)	返回指定的 64 位有符号整数；不执行实际的转换。
ToInt64(Object)	将指定对象的值转换为 64 位带符号整数。
ToInt64(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 64 位带符号整数。
ToInt64(SByte)	将指定的 8 位带符号整数的值转换为等效的 64 位带符号整数。
ToInt64(Single)	将指定的单精度浮点数的值转换为等效的 64 位带符号整数。
ToInt64(String)	将数字的指定字符串表示形式转换为等效的 64 位带符号整数。
ToInt64(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 64 位带符号整数。
ToInt64(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 64 位有符号整数。
ToInt64(UInt16)	将指定的 16 位无符号整数的值转换为等效的 64 位有符号整数。
ToInt64(UInt32)	将指定的 32 位无符号整数的值转换为等效的 64 位有符号整数。
ToInt64(UInt64)	将指定的 64 位无符号整数的值转换为等效的 64 位有符号整数。
ToSByte(Boolean)	将指定的布尔值转换为等效的 8 位带符号整数。
ToSByte(Byte)	将指定的 8 位无符号整数的值转换为等效的 8 位有符号整数。
ToSByte(Char)	将指定的 Unicode 字符的值转换为等效的 8 位有符号整数。
ToSByte(DateTime)	调用此方法始终引发 InvalidCastException。
ToSByte(Decimal)	将指定的十进制数的值转换为等效的 8 位带符号整数。
ToSByte(Double)	将指定的双精度浮点数的值转换为等效的 8 位带符号整数。
ToSByte(Int16)	将指定的 16 位带符号整数的值转换为等效的 8 位带符号整数。
ToSByte(Int32)	将指定的 32 位有符号整数的值转换为等效的 8 位有符号整数。
ToSByte(Int64)	将指定的 64 位有符号整数的值转换为等效的 8 位有符号整数。
ToSByte(Object)	将指定对象的值转换为 8 位带符号整数。
ToSByte(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 8 位带符号整数。
ToSByte(SByte)	返回指定的 8 位有符号整数；不执行实际的转换。
ToSByte(Single)	将指定的单精度浮点数的值转换为等效的 8 位带符号整数。
ToSByte(String)	将数字的指定字符串表示形式转换为等效的 8 位带符号整数。
ToSByte(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 8 位带符号整数。
ToSByte(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 8 位有符号整数。
ToSByte(UInt16)	将指定的 16 位无符号整数的值转换为等效的 8 位有符号整数。
ToSByte(UInt32)	将指定的 32 位无符号整数的值转换为等效的 8 位有符号整数。
ToSByte(UInt64)	将指定的 64 位无符号整数的值转换为等效的 8 位有符号整数。
ToSingle(Boolean)	将指定的布尔值转换为等效的单精度浮点数。
ToSingle(Byte)	将指定的 8 位无符号整数的值转换为等效的单精度浮点数。
ToSingle(Char)	调用此方法始终引发 InvalidCastException。
ToSingle(DateTime)	调用此方法始终引发 InvalidCastException。
ToSingle(Decimal)	将指定的十进制数的值转换为等效的单精度浮点数。
ToSingle(Double)	将指定的双精度浮点数的值转换为等效的单精度浮点数。
ToSingle(Int16)	将指定的 16 位带符号整数的值转换为等效的单精度浮点数。
ToSingle(Int32)	将指定的 32 位带符号整数的值转换为等效的单精度浮点数。
ToSingle(Int64)	将指定的 64 位带符号整数的值转换为等效的单精度浮点数。
ToSingle(Object)	将指定对象的值转换为单精度浮点数。
ToSingle(Object, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定对象的值转换为单精度浮点数。
ToSingle(SByte)	将指定的 8 位带符号整数的值转换为等效的单精度浮点数。
ToSingle(Single)	返回指定的单精度浮点数；不执行任何实际的转换。
ToSingle(String)	将数字的指定字符串表示形式转换为等效的单精度浮点数。
ToSingle(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的单精度浮点数。
ToSingle(UInt16)	将指定的 16 位无符号整数的值转换为等效的单精度浮点数。
ToSingle(UInt32)	将指定的 32 位无符号整数的值转换为等效的单精度浮点数。
ToSingle(UInt64)	将指定的 64 位无符号整数的值转换为等效的单精度浮点数。
ToString(Boolean)	将指定的布尔值转换为其等效的字符串表示形式。
ToString(Boolean, IFormatProvider)	将指定的布尔值转换为其等效的字符串表示形式。
ToString(Byte)	将指定的 8 位无符号整数的值转换为其等效的字符串表示形式。
ToString(Byte, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 8 位无符号整数的值转换为其等效的字符串表示形式。
ToString(Byte, Int32)	将 8 位无符号整数的值转换为其等效的指定基数的字符串表示形式。
ToString(Char)	将指定的 Unicode 字符的值转换为其等效的字符串表示形式。
ToString(Char, IFormatProvider)	使用指定的区域性特定格式设置信息将指定的 Unicode 字符的值转换为其等效的字符串表示形式。
ToString(DateTime)	将指定的 DateTime 的值转换为其等效的字符串表示形式。
ToString(DateTime, IFormatProvider)	使用指定的区域性特定格式设置信息将指定的 DateTime 的值转换为其等效的字符串表示形式。
ToString(Decimal)	将指定的十进制数的值转换为其等效的字符串表示形式。
ToString(Decimal, IFormatProvider)	使用指定的区域性特定格式设置信息将指定的十进制数的值转换为其等效的字符串表示形式。
ToString(Double)	将指定的双精度浮点数的值转换其等效的字符串表示形式。
ToString(Double, IFormatProvider)	将指定的双精度浮点数的值转换其等效的字符串表示形式。
ToString(Int16)	将指定的 16 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Int16, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 16 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Int16, Int32)	将 16 位带符号整数的值转换为其指定基的等效字符串表示形式。
ToString(Int32)	将指定的 32 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Int32, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 32 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Int32, Int32)	将 32 位带符号整数的值转换为其指定基的等效字符串表示形式。
ToString(Int64)	将指定的 64 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Int64, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 64 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Int64, Int32)	将 64 位带符号整数的值转换为其指定基的等效字符串表示形式。
ToString(Object)	将指定对象的值转换为其等效的字符串表示形式。
ToString(Object, IFormatProvider)	使用指定的区域性特定格式设置信息将指定对象的值转换为其等效的字符串表示形式。
ToString(SByte)	将指定的 8 位带符号整数的值转换为其等效的字符串表示形式。
ToString(SByte, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 8 位带符号整数的值转换为其等效的字符串表示形式。
ToString(Single)	将指定的单精度浮点数的值转换其等效的字符串表示形式。
ToString(Single, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的单精度浮点数的值转换为其等效的字符串表示形式。
ToString(String)	返回指定的字符串实例；不执行任何实际转换。
ToString(String, IFormatProvider)	返回指定的字符串实例；不执行任何实际转换。
ToString(UInt16)	将指定的 16 位无符号整数的值转换为其等效的字符串表示形式。
ToString(UInt16, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 16 位无符号整数的值转换为其等效的字符串表示形式。
ToString(UInt32)	将指定的 32 位无符号整数的值转换为其等效的字符串表示形式。
ToString(UInt32, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 32 位无符号整数的值转换为其等效的字符串表示形式。
ToString(UInt64)	将指定的 64 位无符号整数的值转换为其等效的字符串表示形式。
ToString(UInt64, IFormatProvider)	使用指定的区域性特定格式设置信息，将指定的 64 位无符号整数的值转换为其等效的字符串表示形式。
ToUInt16(Boolean)	将指定的布尔值转换为等效的 16 位无符号整数。
ToUInt16(Byte)	将指定的 8 位无符号整数的值转换为等效的 16 位无符号整数。
ToUInt16(Char)	将指定 Unicode 字符的值转换为等效的 16 位无符号整数。
ToUInt16(DateTime)	调用此方法始终引发 InvalidCastException。
ToUInt16(Decimal)	将指定的十进制数的值转换为等效的 16 位无符号整数。
ToUInt16(Double)	将指定的双精度浮点数的值转换为等效的 16 位无符号整数。
ToUInt16(Int16)	将指定的 16 位有符号整数的值转换为等效的 16 位无符号整数。
ToUInt16(Int32)	将指定的 32 位有符号整数的值转换为等效的 16 位无符号整数。
ToUInt16(Int64)	将指定的 64 位有符号整数的值转换为等效的 16 位无符号整数。
ToUInt16(Object)	将指定对象的值转换为 16 位无符号整数。
ToUInt16(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 16 位无符号整数。
ToUInt16(SByte)	将指定的 8 位有符号整数的值转换为等效的 16 位无符号整数。
ToUInt16(Single)	将指定的单精度浮点数的值转换为等效的 16 位无符号整数。
ToUInt16(String)	将数字的指定字符串表示形式转换为等效的 16 位无符号整数。
ToUInt16(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 16 位无符号整数。
ToUInt16(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 16 位无符号整数。
ToUInt16(UInt16)	返回指定的 16 位无符号整数；不执行任何实际的转换。
ToUInt16(UInt32)	将指定的 32 位无符号整数的值转换为等效的 16 位无符号整数。
ToUInt16(UInt64)	将指定的 64 位无符号整数的值转换为等效的 16 位无符号整数。
ToUInt32(Boolean)	将指定的布尔值转换为等效的 32 位无符号整数。
ToUInt32(Byte)	将指定的 8 位无符号整数的值转换为等效的 32 位无符号整数。
ToUInt32(Char)	将指定 Unicode 字符的值转换为等效的 32 位无符号整数。
ToUInt32(DateTime)	调用此方法始终引发 InvalidCastException。
ToUInt32(Decimal)	将指定的十进制数的值转换为等效的 32 位无符号整数。
ToUInt32(Double)	将指定的双精度浮点数的值转换为等效的 32 位无符号整数。
ToUInt32(Int16)	将指定的 16 位有符号整数的值转换为等效的 32 位无符号整数。
ToUInt32(Int32)	将指定的 32 位有符号整数的值转换为等效的 32 位无符号整数。
ToUInt32(Int64)	将指定的 64 位有符号整数的值转换为等效的 32 位无符号整数。
ToUInt32(Object)	将指定对象的值转换为 32 位无符号整数。
ToUInt32(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 32 位无符号整数。
ToUInt32(SByte)	将指定的 8 位有符号整数的值转换为等效的 32 位无符号整数。
ToUInt32(Single)	将指定的单精度浮点数的值转换为等效的 32 位无符号整数。
ToUInt32(String)	将数字的指定字符串表示形式转换为等效的 32 位无符号整数。
ToUInt32(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 32 位无符号整数。
ToUInt32(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 32 位无符号整数。
ToUInt32(UInt16)	将指定的 16 位无符号整数的值转换为等效的 32 位无符号整数。
ToUInt32(UInt32)	返回指定的 32 位无符号整数；不执行任何实际的转换。
ToUInt32(UInt64)	将指定的 64 位无符号整数的值转换为等效的 32 位无符号整数。
ToUInt64(Boolean)	将指定的布尔值转换为等效的 64 位无符号整数。
ToUInt64(Byte)	将指定的 8 位无符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(Char)	将指定 Unicode 字符的值转换为等效的 64 位无符号整数。
ToUInt64(DateTime)	调用此方法始终引发 InvalidCastException。
ToUInt64(Decimal)	将指定的十进制数的值转换为等效的 64 位无符号整数。
ToUInt64(Double)	将指定的双精度浮点数的值转换为等效的 64 位无符号整数。
ToUInt64(Int16)	将指定的 16 位有符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(Int32)	将指定的 32 位有符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(Int64)	将指定的 64 位有符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(Object)	将指定对象的值转换为 64 位无符号整数。
ToUInt64(Object, IFormatProvider)	使用指定的区域性特定格式信息，将指定对象的值转换为 64 位无符号整数。
ToUInt64(SByte)	将指定的 8 位有符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(Single)	将指定的单精度浮点数的值转换为等效的 64 位无符号整数。
ToUInt64(String)	将数字的指定字符串表示形式转换为等效的 64 位无符号整数。
ToUInt64(String, IFormatProvider)	使用指定的区域性特定格式设置信息，将数字的指定字符串表示形式转换为等效的 64 位无符号整数。
ToUInt64(String, Int32)	将指定基数的数字的字符串表示形式转换为等效的 64 位无符号整数。
ToUInt64(UInt16)	将指定的 16 位无符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(UInt32)	将指定的 32 位无符号整数的值转换为等效的 64 位无符号整数。
ToUInt64(UInt64)	返回指定的 64 位无符号整数；不执行任何实际的转换。
TryFromBase64Chars(ReadOnlySpan<Char>, Span<Byte>, Int32)	尝试将包含用 base-64 数字编码的字符串表示形式的指定范围转换为 8 位无符号整数的范围。
TryFromBase64String(String, Span<Byte>, Int32)	尝试将用 base-64 数字编码的指定字符串表示形式转换为 8 位无符号整数的范围。
TryToBase64Chars(ReadOnlySpan<Byte>, Span<Char>, Int32, Base64FormattingOptions)	尝试将指定的只读范围内的 8 位无符号整数转换为其用 base-64 数字编码的等效字符串表示形式。你可以选择指定是否在返回值中插入换行符。

适用于