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 、 Char 、、 SByte Byte 、 Int64 UInt16 UInt64 UInt32 Single Double Int32 Int16 、、 Decimal DateTime 和。 String 此外，類別 Convert 也包含支援其他類型的轉換的方法。

本文包含下列各節：

從基底類型非十進位數轉換到基底類型文化特性特定格式資訊 Base64 編碼其他常見轉換的轉換

從基底類型轉換

轉換方法存在，可將每個基底類型轉換成所有其他基底類型。不過，特定轉換方法的實際呼叫可能會產生五個結果之一，視執行時間基底類型的值和目標基底類型而定。這五個結果如下：

沒有轉換。當嘗試從型別轉換成本身 (時，會藉由呼叫 Convert.ToInt32(Int32) 類型 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 值的字串是由多個字元所組成。
- 要轉換成任何數數值型別的字串無法辨識為有效的數位。
- 要轉換成的 DateTime 字串無法辨識為有效的日期和時間值。
成功轉換。針對先前結果中未列出的兩種不同基底類型之間的轉換，所有擴輾轉換以及所有不會導致資料遺失的縮小轉換都會成功，而且方法會傳回目標基底類型的值。
OverflowException。當縮小轉換導致資料遺失時，就會發生這種情況。例如，嘗試將值為 10000 Byte 的實例轉換成 Int32 類型會擲回， OverflowException 因為 10000 超出資料類型的範圍 Byte 。

如果數數值型別的轉換導致精確度遺失 (，則不會擲回例外狀況，也就是遺失某些最小有效位數) 。不過，如果結果大於可由特定轉換方法的傳回數值型別表示，則會擲回例外狀況。

例如，當轉換成 Single 時 Double ，可能會遺失有效位數，但不會擲回例外狀況。不過，如果的大小 Double 太大而無法由 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.ToDouble(Object, IFormatProvider) 方法 (， Convert.ToInt32(Object) 並傳遞自訂類型的實例做為其第一個參數時， Convert 方法接著會呼叫自訂類型的 IConvertible 實作來執行轉換。如需詳細資訊，請參閱 .NET 中的類型轉換。

Culture-Specific格式資訊

所有基底類型轉換方法和 ChangeType 方法都包含具有類型 IFormatProvider 參數的多載。例如， Convert.ToBoolean 方法有下列兩個多載：

參數 IFormatProvider 可以提供特定文化特性的格式資訊，以協助轉換程式。不過，大部分基底類型轉換方法都會忽略它。它只能由下列基底類型轉換方法使用。 null IFormatProvider 如果引數傳遞至這些方法， 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 字元陣列來回轉換。

ToBase64String，可將位元組陣列轉換成 base64 編碼字串。
ToBase64CharArray，可將位元組陣列轉換成 base64 編碼的字元陣列。
FromBase64String，會將 base64 編碼字串轉換成位元組陣列。
FromBase64CharArray，會將 base64 編碼的字元陣列轉換成位元組陣列。

其他常見轉換

您可以使用 NET Framework 中的其他類別來執行類別的靜態方法 Convert 不支援的一些轉換。它們包括：

轉換成位元組陣列類別 BitConverter 提供方法，可將基本數數值型別轉換成基本數數值型別， (包括 Boolean) 到位元組陣列，以及從位元組陣列轉換成基本資料類型。

字元編碼和解碼類別 Encoding 及其衍生類別 (，例如 UnicodeEncoding 和 UTF8Encoding) 提供方法來編碼字元陣列或字串 (，以在特定編碼) 將它們轉換成位元組陣列，以及解碼編碼的位元組陣列 (，也就是將位元組陣列轉換成 UTF16 編碼的 Unicode 字元。如需詳細資訊，請參閱 .NET 中的字元編碼。

欄位

DBNull

常數，表示缺少資料的資料庫資料行，也就是資料庫為 null。

方法

ChangeType(Object, Type)	傳回指定之類型的物件，此物件的值與指定的物件相等。
ChangeType(Object, Type, IFormatProvider)	傳回物件，該物件屬於指定的類型，且其值等於指定的物件。參數提供特定文化特性格式資訊。
ChangeType(Object, TypeCode)	傳回物件，該物件屬於指定的類型，且其值等於指定的物件。
ChangeType(Object, TypeCode, IFormatProvider)	傳回物件，該物件屬於指定的類型，且其值等於指定的物件。參數提供特定文化特性格式資訊。
FromBase64CharArray(Char[], Int32, Int32)	將 Unicode 字元陣列 (將二進位資料編碼為 Base-64 位數) 的子集轉換為相等的 8 位元不帶正負號的整數陣列。參數會指定輸入陣列中的子集，以及要轉換的項目個數。
FromBase64String(String)	將指定的字串 (將二進位資料編碼為 Base-64 位數) 轉換為相等的 8 位元不帶正負號的整數陣列。
FromHexString(ReadOnlySpan<Char>)	將範圍轉換為相等的 8 位元不帶正負號的整數陣列 (會將二進位資料編碼為十六進位字元)。
FromHexString(String)	將指定的字串轉換為相等的 8 位元不帶正負號的整數陣列 (會將二進位資料編碼為十六進位字元)。
GetTypeCode(Object)	傳回指定物件的 TypeCode。
IsDBNull(Object)	傳回指定物件是否屬於類型 DBNull 的指示。
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32)	將 8 位元不帶正負號的整數陣列的子集，轉換為相等的 Base-64 位數編碼的 Unicode 字元陣列子集。參數會將子集指定為輸入和輸出陣列中的位移，以及轉換輸入陣列中的項目數目。
ToBase64CharArray(Byte[], Int32, Int32, Char[], Int32, Base64FormattingOptions)	將 8 位元不帶正負號的整數陣列的子集，轉換為相等的 Base-64 位數編碼的 Unicode 字元陣列子集。參數會指定可在輸入和輸出陣列中當成位移 (Offset) 的子集、輸入陣列中要轉換的項目個數，以及是否要在輸出陣列中插入分行符號。
ToBase64String(Byte[])	將 8 位元不帶正負號的整數陣列，轉換為使用 Base-64 位數編碼的相等字串表示。
ToBase64String(Byte[], Base64FormattingOptions)	將 8 位元不帶正負號的整數陣列，轉換為使用 Base-64 位數編碼的相等字串表示。您可以指定是否要在傳回值中插入分行符號。
ToBase64String(Byte[], Int32, Int32)	將 8 位元不帶正負號的整數陣列子集，轉換為使用 Base-64 位數編碼的相等字串表示。參數會將子集指定為輸入陣列中的位移 (Offset)，以及所要轉換陣列中項目的個數。
ToBase64String(Byte[], Int32, Int32, Base64FormattingOptions)	將 8 位元不帶正負號的整數陣列子集，轉換為使用 Base-64 位數編碼的相等字串表示。參數會指定可在輸入陣列中當成位移 (Offset) 的子集、輸入陣列中要轉換的項目個數，以及是否要在傳回值中插入分行符號。
ToBase64String(ReadOnlySpan<Byte>, Base64FormattingOptions)	將指定唯讀範圍內 8 位元不帶正負號的整數轉換為使用 Base-64 位數編碼的對等字串表示。您可以選擇性地指定是否要在傳回值中插入分行符號。
ToBoolean(Boolean)	傳回指定的布林值 (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 位數編碼的對等字串表示。您可以選擇性地指定是否要在傳回值中插入分行符號。

適用於