Convert 類別

定義

將基底資料類型轉換為其他基底資料類型。

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
繼承
Convert

備註

如需此 API 的詳細資訊,請參閱 轉換的補充 API 備註

欄位

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(ReadOnlySpan<Char>, Span<Byte>, Int32, Int32)

將基底資料類型轉換為其他基底資料類型。

FromHexString(String)

將指定的字串轉換為相等的 8 位元不帶正負號的整數陣列 (會將二進位資料編碼為十六進位字元)。

FromHexString(String, Span<Byte>, Int32, Int32)

將基底資料類型轉換為其他基底資料類型。

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 位元不帶正負號的整數範圍,轉換為使用大寫十六進位字元編碼的相等字串表示法。

ToHexStringLower(Byte[])

將基底資料類型轉換為其他基底資料類型。

ToHexStringLower(Byte[], Int32, Int32)

將基底資料類型轉換為其他基底資料類型。

ToHexStringLower(ReadOnlySpan<Byte>)

將基底資料類型轉換為其他基底資料類型。

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 位數編碼的對等字串表示。 您可以選擇性地指定是否要在傳回值中插入分行符號。

TryToHexString(ReadOnlySpan<Byte>, Span<Char>, Int32)

將基底資料類型轉換為其他基底資料類型。

TryToHexStringLower(ReadOnlySpan<Byte>, Span<Char>, Int32)

將基底資料類型轉換為其他基底資料類型。

適用於

另請參閱