BigInteger.Explicit 操作员

参考

定义

命名空间:: System.Numerics

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

程序集:: System.Numerics.dll

程序集:: netstandard.dll

重要

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

定义 BigInteger 对象与其他类型之间的显式转换。

重载

Explicit(BigInteger to SByte)	定义从 BigInteger 对象到 8 位带符号值的显式转换。此 API 不兼容 CLS。符合的替代方法是 Int16。
Explicit(Single to BigInteger)	定义从 Single 值到 BigInteger 值的显式转换。
Explicit(Complex to BigInteger)	将值显式转换为 Complex 大整数。
Explicit(BigInteger to UIntPtr)	将大整数显式转换为 UIntPtr 值。
Explicit(BigInteger to UInt64)	定义从 BigInteger 对象到 64 位无符号整数值的显式转换。此 API 不兼容 CLS。符合的替代方法是 Double。
Explicit(BigInteger to UInt32)	定义从 BigInteger 对象到 32 位无符号整数值的显式转换。此 API 不兼容 CLS。符合的替代方法是 Int64。
Explicit(BigInteger to UInt16)	定义从 BigInteger 对象到 16 位无符号整数值的显式转换。此 API 不兼容 CLS。符合的替代方法是 Int32。
Explicit(BigInteger to UInt128)	将大整数显式转换为 UInt128 值。
Explicit(BigInteger to Single)	定义从 BigInteger 对象到单精度浮点值的显式转换。
Explicit(BigInteger to IntPtr)	将大整数显式转换为 IntPtr 值。
Explicit(BigInteger to Int64)	定义从 BigInteger 对象到 64 位带符号整数值的显式转换。
Explicit(BigInteger to Int16)	定义从 BigInteger 对象到 16 位带符号整数值的显式转换。
Explicit(BigInteger to Int128)	将大整数显式转换为 Int128 值。
Explicit(BigInteger to Half)	将大整数显式转换为 Half 值。
Explicit(BigInteger to Double)	定义从 BigInteger 对象到 Double 值的显式转换。
Explicit(BigInteger to Decimal)	定义从 BigInteger 对象到 Decimal 值的显式转换。
Explicit(BigInteger to Char)	将大整数显式转换为 Char 值。
Explicit(BigInteger to Byte)	定义从 BigInteger 对象到无符号字节值的显式转换。
Explicit(Half to BigInteger)	将值显式转换为 Half 大整数。
Explicit(Double to BigInteger)	定义从 Double 值到 BigInteger 值的显式转换。
Explicit(Decimal to BigInteger)	定义从 Decimal 对象到 BigInteger 值的显式转换。
Explicit(BigInteger to Int32)	定义从 BigInteger 对象到 32 位带符号整数值的显式转换。

Explicit(BigInteger to SByte)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Int16

定义从 BigInteger 对象到 8 位带符号值的显式转换。

此 API 不兼容 CLS。符合的替代方法是 Int16。

public:
 static explicit operator System::SByte(System::Numerics::BigInteger value);

[System.CLSCompliant(false)]
public static explicit operator sbyte (System.Numerics.BigInteger value);

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> sbyte

Public Shared Narrowing Operator CType (value As BigInteger) As SByte

参数

value: BigInteger

要转换为 8 位带符号值的值。

SByte

包含 value 参数值的对象。

属性: CLSCompliantAttribute

例外

OverflowException

value 小于 SByte.MinValue 或大于 SByte.MaxValue。

示例

以下示例演示了如何 BigInteger 转换为 SByte 值。它还处理 OverflowException 由于 BigInteger 值超出数据类型范围而引发的 SByte 。

// BigInteger to SByte conversion.
BigInteger goodSByte = BigInteger.MinusOne;
BigInteger badSByte = -130;

sbyte sByteFromBigInteger;

// Successful conversion using cast operator.
sByteFromBigInteger = (sbyte) goodSByte;
Console.WriteLine(sByteFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   sByteFromBigInteger = (sbyte) badSByte;
   Console.WriteLine(sByteFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badSByte, e.Message);
}
Console.WriteLine();

// BigInteger to SByte conversion.
let goodSByte = BigInteger.MinusOne
let badSByte = bigint -130

// Successful conversion using cast operator.
let sByteFromBigInteger = sbyte goodSByte
printfn $"{sByteFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let sByteFromBigInteger = sbyte badSByte
    printfn $"{sByteFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badSByte}:\n   {e.Message}"

' BigInteger to SByte conversion.
Dim goodSByte As BigInteger = BigInteger.MinusOne
Dim badSByte As BigInteger = -130

Dim sByteFromBigInteger As SByte

' Convert using CType function.
sByteFromBigInteger = CType(goodSByte, SByte)
Console.WriteLine(sByteFromBigInteger)
' Convert using CSByte function.
sByteFromBigInteger = CSByte(goodSByte)
Console.WriteLine(sByteFromBigInteger)

' Handle conversion that should result in overflow.
Try
   sByteFromBigInteger = CType(badSByte, SByte)
   Console.WriteLine(sByteFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badSByte, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (，或使用 visual Basic) 中的或 CSByte (CType转换函数时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围SByte，则在运行时可能会引发 OverflowException 。如果转换成功，则生成的 SByte 值不会丢失精度。

适用于

Explicit(Single to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 Single 值到 BigInteger 值的显式转换。

public:
 static explicit operator System::Numerics::BigInteger(float value);

public static explicit operator System.Numerics.BigInteger (float value);

static member op_Explicit : single -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Single) As BigInteger

参数

value: Single

要转换为 BigInteger 的值。

BigInteger

包含 value 参数值的对象。

例外

OverflowException

value 为 NaN、PositiveInfinity 或 NegativeInfinity。

示例

以下示例将值数组 Single 中的单个元素转换为 BigInteger 对象，然后显示每次转换的结果。请注意，在转换期间，值的任何小数部分 Single 将被截断。

float[] singles = { Single.MinValue, -1.430955172e03f, 2.410970032e05f,
                    Single.MaxValue, Single.PositiveInfinity,
                     Single.NegativeInfinity, Single.NaN };
BigInteger number;

Console.WriteLine("{0,37} {1,37}\n", "Single", "BigInteger");

foreach (float value in singles)
{
   try {
      number = (BigInteger) value;
      Console.WriteLine("{0,37} {1,37}", value, number);
   }
   catch (OverflowException) {
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException");
   }
}
// The example displays the following output:
//           Single                            BigInteger
//
//    -3.402823E+38   -3.4028234663852885981170418348E+38
//        -1430.955                                 -1430
//           241097                                241097
//     3.402823E+38    3.4028234663852885981170418348E+38
//         Infinity                     OverflowException
//        -Infinity                     OverflowException
//              NaN                     OverflowException

let singles =
    [| Single.MinValue
       -1.430955172e03f
       2.410970032e05f
       Single.MaxValue
       Single.PositiveInfinity
       Single.NegativeInfinity
       Single.NaN |]

printfn "%37s %37s\n" "Single" "BigInteger"

for value in singles do
    try
        let number = BigInteger(value)
        printfn "%37O %37O" value number
    with :? OverflowException ->
        printfn "%37O %37s" value "OverflowException"
// The example displays the following output:
//           Single                            BigInteger
//
//    -3.402823E+38   -3.4028234663852885981170418348E+38
//        -1430.955                                 -1430
//           241097                                241097
//     3.402823E+38    3.4028234663852885981170418348E+38
//         Infinity                     OverflowException
//        -Infinity                     OverflowException
//              NaN                     OverflowException

Dim singles() As Single = { Single.MinValue, -1.430955172e03, 2.410970032e05, 
                            Single.MaxValue, Single.PositiveInfinity, 
                            Single.NegativeInfinity, Single.NaN }
Dim number As BigInteger

Console.WriteLine("{0,37} {1,37}", "Single", "BigInteger")
Console.WriteLine()
For Each value As Single In singles
   Try
      number = CType(value, BigInteger)
      Console.WriteLine("{0,37} {1,37}", value, number)
   Catch e As OverflowException
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException")
   End Try
Next     
' The example displays the following output:
'           Single                            BigInteger
' 
'    -3.402823E+38   -3.4028234663852885981170418348E+38
'        -1430.955                                 -1430
'           241097                                241097
'     3.402823E+38    3.4028234663852885981170418348E+38
'         Infinity                     OverflowException
'        -Infinity                     OverflowException
'              NaN                     OverflowException

注解

参数的任何小数部分 value 在转换前被截断。

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 由于从 Single 到 BigInteger 的转换可能涉及截断的任何小数部分 value，因此语言编译器不会自动执行此转换。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（例如 CType 在 Visual Basic) 中）时才执行转换。否则，它们会显示编译器错误。

对于不支持自定义运算符的语言，替代方法是 BigInteger.BigInteger(Single)。

适用于

Explicit(Complex to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将值显式转换为 Complex 大整数。

public:
 static explicit operator System::Numerics::BigInteger(System::Numerics::Complex value);

public static explicit operator System.Numerics.BigInteger (System.Numerics.Complex value);

static member op_Explicit : System.Numerics.Complex -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Complex) As BigInteger

参数

value: Complex

要转换的值。

BigInteger

value 转换为大整数。

适用于

Explicit(BigInteger to UIntPtr)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

将大整数显式转换为 UIntPtr 值。

public:
 static explicit operator UIntPtr(System::Numerics::BigInteger value);

[System.CLSCompliant(false)]
public static explicit operator UIntPtr (System.Numerics.BigInteger value);

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> unativeint

Public Shared Narrowing Operator CType (value As BigInteger) As UIntPtr

参数

value: BigInteger

要转换的值。

UIntPtr

unativeint

value 转换为 UIntPtr 值。

属性: CLSCompliantAttribute

适用于

Explicit(BigInteger to UInt64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Double

定义从 BigInteger 对象到 64 位无符号整数值的显式转换。

此 API 不兼容 CLS。符合的替代方法是 Double。

public:
 static explicit operator System::UInt64(System::Numerics::BigInteger value);

[System.CLSCompliant(false)]
public static explicit operator ulong (System.Numerics.BigInteger value);

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> uint64

Public Shared Narrowing Operator CType (value As BigInteger) As ULong

参数

value: BigInteger

要转换为 64 位无符号整数的值。

UInt64

包含 value 参数值的对象。

属性: CLSCompliantAttribute

例外

OverflowException

value 小于 UInt64.MinValue 或大于 UInt64.MaxValue。

示例

下面的示例演示了到值的转换BigInteger UInt64。它还处理 OverflowException 由于值超出数据类型范围而引发 BigInteger 的 UInt64 。

// BigInteger to UInt64 conversion.
BigInteger goodULong = 2000000000;
BigInteger badULong = BigInteger.Pow(goodULong, 3);

ulong uLongFromBigInteger;

// Successful conversion using cast operator.
uLongFromBigInteger = (ulong) goodULong;
Console.WriteLine(uLongFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   uLongFromBigInteger = (ulong) badULong;
   Console.WriteLine(uLongFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badULong, e.Message);
}
Console.WriteLine();

// BigInteger to UInt64 conversion.
let goodULong = bigint 2000000000
let badULong = BigInteger.Pow(goodULong, 3)

// Successful conversion using cast operator.
let uLongFromBigInteger = uint64 goodULong
printfn $"{uLongFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let uLongFromBigInteger = uint64 badULong
    printfn $"{uLongFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badULong}:\n   {e.Message}"

' BigInteger to UInt64 conversion.
Dim goodULong As BigInteger = 2000000000
Dim badULong As BigInteger = BigInteger.Pow(goodULong, 3)

Dim uLongFromBigInteger As ULong

' Convert using CType function.
uLongFromBigInteger = CType(goodULong, ULong)
Console.WriteLine(uLongFromBigInteger)
' Convert using CULng function.
uLongFromBigInteger = CULng(goodULong)
Console.WriteLine(uLongFromBigInteger)

' Handle conversion that should result in overflow.
Try
   uLongFromBigInteger = CType(badULong, ULong)
   Console.WriteLine(uLongFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badULong, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（如 CType visual Basic) 中的或 CULng ）时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围UInt64，则在运行时可能会引发 OverflowException 。如果转换成功，则结果 UInt64 值中不会丢失精度。

适用于

Explicit(BigInteger to UInt32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Int64

定义从 BigInteger 对象到 32 位无符号整数值的显式转换。

此 API 不兼容 CLS。符合的替代方法是 Int64。

public:
 static explicit operator System::UInt32(System::Numerics::BigInteger value);

[System.CLSCompliant(false)]
public static explicit operator uint (System.Numerics.BigInteger value);

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> uint32

Public Shared Narrowing Operator CType (value As BigInteger) As UInteger

参数

value: BigInteger

要转换为 32 位无符号整数的值。

UInt32

包含 value 参数值的对象。

属性: CLSCompliantAttribute

例外

OverflowException

value 小于 UInt32.MinValue 或大于 UInt32.MaxValue。

示例

下面的示例演示了到值的转换BigInteger UInt32。它还处理 OverflowException 由于值超出数据类型范围而引发 BigInteger 的 UInt32 。

// BigInteger to UInt32 conversion.
BigInteger goodUInteger = 200000;
BigInteger badUInteger = 65000000000;

uint uIntegerFromBigInteger;

// Successful conversion using cast operator.
uIntegerFromBigInteger = (uint) goodInteger;
Console.WriteLine(uIntegerFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   uIntegerFromBigInteger = (uint) badUInteger;
   Console.WriteLine(uIntegerFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badUInteger, e.Message);
}
Console.WriteLine();

// BigInteger to UInt32 conversion.
let goodUInteger = bigint 200000
let badUInteger = bigint 65000000000L

// Successful conversion using cast operator.
let uIntegerFromBigInteger = uint goodInteger
printfn $"{uIntegerFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let uIntegerFromBigInteger = uint badUInteger
    printfn $"{uIntegerFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badUInteger}:\n   {e.Message}"

' BigInteger to UInt32 conversion.
Dim goodUInteger As BigInteger = 200000
Dim badUInteger As BigInteger = 65000000000

Dim uIntegerFromBigInteger As UInteger

' Convert using CType function.
uIntegerFromBigInteger = CType(goodInteger, UInteger)
Console.WriteLine(uIntegerFromBigInteger)
' Convert using CUInt function.
uIntegerFromBigInteger = CUInt(goodInteger)
Console.WriteLine(uIntegerFromBigInteger)

' Handle conversion that should result in overflow.
Try
   uIntegerFromBigInteger = CType(badUInteger, UInteger)
   Console.WriteLine(uIntegerFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badUInteger, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（如 CType visual Basic) 中的或 CUInt ）时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围UInt32，则在运行时可能会引发 OverflowException 。如果转换成功，则结果 UInt32 值中不会丢失精度。

适用于

Explicit(BigInteger to UInt16)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

符合 CLS 的替代方案: System.Int32

定义从 BigInteger 对象到 16 位无符号整数值的显式转换。

此 API 不兼容 CLS。符合的替代方法是 Int32。

public:
 static explicit operator System::UInt16(System::Numerics::BigInteger value);

[System.CLSCompliant(false)]
public static explicit operator ushort (System.Numerics.BigInteger value);

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> uint16

Public Shared Narrowing Operator CType (value As BigInteger) As UShort

参数

value: BigInteger

要转换为 16 位无符号整数的值。

UInt16

包含 value 参数值的对象。

属性: CLSCompliantAttribute

例外

OverflowException

value 小于 UInt16.MinValue 或大于 UInt16.MaxValue。

示例

下面的示例演示了到值的转换BigInteger UInt16。它还处理 OverflowException 由于值超出数据类型范围而引发 BigInteger 的 UInt16 。

// BigInteger to UInt16 conversion.
BigInteger goodUShort = 20000;
BigInteger badUShort = 66000;

ushort uShortFromBigInteger;

// Successful conversion using cast operator.
uShortFromBigInteger = (ushort) goodUShort;
Console.WriteLine(uShortFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   uShortFromBigInteger = (ushort) badUShort;
   Console.WriteLine(uShortFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badUShort, e.Message);
}
Console.WriteLine();

// BigInteger to UInt16 conversion.
let goodUShort = bigint 20000
let badUShort = bigint 66000

// Successful conversion using cast operator.
let uShortFromBigInteger = uint16 goodUShort
printfn $"{uShortFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let uShortFromBigInteger = uint16 badUShort
    printfn $"{uShortFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badSByte}:\n   {e.Message}"

' BigInteger to UInt16 conversion.
Dim goodUShort As BigInteger = 20000
Dim badUShort As BigInteger = 66000

Dim uShortFromBigInteger As UShort

' Convert using CType function.
uShortFromBigInteger = CType(goodUShort, UShort)
Console.WriteLine(uShortFromBigInteger)
' Convert using CUShort function.
uShortFromBigInteger = CUShort(goodUShort)
Console.WriteLine(uShortFromBigInteger)

' Handle conversion that should result in overflow.
Try
   uShortFromBigInteger = CType(badUShort, UShort)
   Console.WriteLine(uShortFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badUShort, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（如 CType visual Basic) 中的或 CUShort ）时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围UInt16，则在运行时可能会引发 OverflowException 。如果转换成功，则结果 UInt16 值中不会丢失精度。

适用于

Explicit(BigInteger to UInt128)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

重要

此 API 不符合 CLS。

将大整数显式转换为 UInt128 值。

public:
 static explicit operator UInt128(System::Numerics::BigInteger value);

[System.CLSCompliant(false)]
public static explicit operator UInt128 (System.Numerics.BigInteger value);

[<System.CLSCompliant(false)>]
static member op_Explicit : System.Numerics.BigInteger -> UInt128

Public Shared Narrowing Operator CType (value As BigInteger) As UInt128

参数

value: BigInteger

要转换的值。

UInt128

value 转换为 UInt128 值。

属性: CLSCompliantAttribute

适用于

Explicit(BigInteger to Single)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到单精度浮点值的显式转换。

public:
 static explicit operator float(System::Numerics::BigInteger value);

public static explicit operator float (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> single

Public Shared Narrowing Operator CType (value As BigInteger) As Single

参数

value: BigInteger

要转换为单精度浮点值的值。

Single

一个对象，包含 value 参数的尽可能精确的表示形式。

示例

下面的示例演示了到值的转换BigInteger Single。

// BigInteger to Single conversion.
BigInteger goodSingle = (BigInteger) 102.43e22F;
BigInteger badSingle = (BigInteger) float.MaxValue;
badSingle = badSingle * 2;

float singleFromBigInteger;

// Successful conversion using cast operator.
singleFromBigInteger = (float) goodSingle;
Console.WriteLine(singleFromBigInteger);

// Convert an out-of-bounds BigInteger value to a Single.
singleFromBigInteger = (float) badSingle;
Console.WriteLine(singleFromBigInteger);

// BigInteger to Single conversion.
let goodSingle = bigint 102.43e22F
let badSingle = bigint Single.MaxValue * bigint 2

// Successful conversion using cast operator.
let singleFromBigInteger = float32 goodSingle
printfn $"{singleFromBigInteger}"

// Convert an out-of-bounds BigInteger value to a Single.
let singleFromBigInteger = float32 badSingle
printfn $"{singleFromBigInteger}"

' BigInteger to Single conversion.
Dim goodSingle As BigInteger = 102.43e22
Dim badSingle As BigInteger = CType(Single.MaxValue, BigInteger)  
badSingle = badSingle * 2

Dim singleFromBigInteger As Single

' Convert using CType function.
singleFromBigInteger = CType(goodSingle, Single)
Console.WriteLine(singleFromBigInteger)
' Convert using CSng function.
singleFromBigInteger = CSng(goodSingle)
Console.WriteLine(singleFromBigInteger)

' Convert an out-of-bounds BigInteger value to a Single.
singleFromBigInteger = CType(badSingle, Single)
Console.WriteLine(singleFromBigInteger)

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失或精度损失。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（如 CType visual Basic) 中的或 CSng ）时，它们才会执行转换。否则，它们会显示编译器错误。

BigInteger由于该值可能超出数据类型的范围Single，因此此操作是一种收缩转换。如果转换不成功，则不会引发 OverflowException。相反，如果 BigInteger 值小于 Single.MinValue，则生成的 Single 值为 Single.NegativeInfinity。 BigInteger如果值大于 Single.MaxValue，则生成的Single值为 Single.PositiveInfinity。

BigInteger将转换为可能Single涉及精度损失。在某些情况下，丢失精度可能会导致强制转换或转换操作成功，即使 BigInteger 该值超出数据类型的范围 Single 也是如此。下面的示例进行了这方面的演示。它将的最大值分配给两BigInteger个Single变量，递增一个BigInteger变量 9.999e291，并测试两个变量是否相等。如预期的那样，对方法的 BigInteger.Equals(BigInteger) 调用表明它们不相等。但是，将较大的 BigInteger 值转换回 Single 会成功，尽管该值 BigInteger 现在超过 Single.MaxValue。

// Increase a BigInteger so it exceeds Single.MaxValue.
BigInteger number1 = (BigInteger) Single.MaxValue;
BigInteger number2 = number1;
number2 = number2 + (BigInteger) 9.999e30;
// Compare the BigInteger values for equality.
Console.WriteLine("BigIntegers equal: {0}", number2.Equals(number1));

// Convert the BigInteger to a Single.
float sng = (float) number2;

// Display the two values.
Console.WriteLine("BigInteger: {0}", number2);
Console.WriteLine("Single:     {0}", sng);
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 3.4028235663752885981170396038E+38
//       Single:     3.402823E+38

// Increase a BigInteger so it exceeds Single.MaxValue.
let number1 = bigint Single.MaxValue

let number2 = number1 + bigint 9.999e30
// Compare the BigInteger values for equality.
printfn $"BigIntegers equal: {number2.Equals number1}"

// Convert the BigInteger to a Single.
let sng = float32 number2

// Display the two values.
printfn $"BigInteger: {number2}"
printfn $"Single:     {sng}"
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 3.4028235663752885981170396038E+38
//       Single:     3.402823E+38

' Increase a BigInteger so it exceeds Single.MaxValue.
Dim number1 As BigInteger = CType(Single.MaxValue, BigInteger)
Dim number2 As BigInteger = number1
number2 = number2 + 9.999e30
' Compare the BigInteger values for equality.
Console.WriteLine("BigIntegers equal: {0}", number2.Equals(number1))

' Convert the BigInteger to a Single.
Dim sng As Single = CType(number2, Single)

' Display the two values.
Console.WriteLine("BigInteger: {0}", number2)
Console.WriteLine("Single:     {0}", sng)      
' The example displays the following output:
'       BigIntegers equal: False
'       BigInteger: 3.4028235663752885981170396038E+38
'       Single:     3.402823E+38

适用于

Explicit(BigInteger to IntPtr)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将大整数显式转换为 IntPtr 值。

public:
 static explicit operator IntPtr(System::Numerics::BigInteger value);

public static explicit operator IntPtr (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> nativeint

Public Shared Narrowing Operator CType (value As BigInteger) As IntPtr

参数

value: BigInteger

要转换的值。

IntPtr

nativeint

value 转换为 IntPtr 值。

适用于

Explicit(BigInteger to Int64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到 64 位带符号整数值的显式转换。

public:
 static explicit operator long(System::Numerics::BigInteger value);

public static explicit operator long (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> int64

Public Shared Narrowing Operator CType (value As BigInteger) As Long

参数

value: BigInteger

要转换为 64 位带符号整数的值。

Int64

包含 value 参数值的对象。

例外

OverflowException

value 小于 Int64.MinValue 或大于 Int64.MaxValue。

示例

下面的示例演示了到值的转换BigInteger Int64。它还处理 OverflowException 由于值超出数据类型范围而引发 BigInteger 的 Int64 。

// BigInteger to Int64 conversion.
BigInteger goodLong = 2000000000;
BigInteger badLong = BigInteger.Pow(goodLong, 3);

long longFromBigInteger;

// Successful conversion using cast operator.
longFromBigInteger = (long) goodLong;
Console.WriteLine(longFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   longFromBigInteger = (long) badLong;
   Console.WriteLine(longFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badLong, e.Message);
}
Console.WriteLine();

// BigInteger to Int64 conversion.
let goodLong = 2000000000
let badLong = BigInteger.Pow(goodLong, 3)

// Successful conversion using cast operator.
let longFromBigInteger = int64 goodLong
printfn $"{longFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let longFromBigInteger = int64 badLong
    printfn $"{longFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badLong}:\n   {e.Message}"

' BigInteger to Int64 conversion.
Dim goodLong As BigInteger = 2000000000
Dim badLong As BigInteger = BigInteger.Pow(goodLong, 3)

Dim longFromBigInteger As Long

' Convert using CType function.
longFromBigInteger = CType(goodLong, Long)
Console.WriteLine(longFromBigInteger)
' Convert using CLng function.
longFromBigInteger = CLng(goodLong)
Console.WriteLine(longFromBigInteger)

' Handle conversion that should result in overflow.
Try
   longFromBigInteger = CType(badLong, Long)
   Console.WriteLine(longFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badLong, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（如 CType visual Basic) 中的或 CLng ）时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围Int64，则在运行时可能会引发 OverflowException 。

适用于

Explicit(BigInteger to Int16)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到 16 位带符号整数值的显式转换。

public:
 static explicit operator short(System::Numerics::BigInteger value);

public static explicit operator short (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> int16

Public Shared Narrowing Operator CType (value As BigInteger) As Short

参数

value: BigInteger

要转换为 16 位带符号整数的值。

Int16

包含 value 参数值的对象。

例外

OverflowException

value 小于 Int16.MinValue 或大于 Int16.MaxValue。

示例

下面的示例演示了到值的转换BigInteger Int16。它还处理 OverflowException 由于值超出数据类型范围而引发 BigInteger 的 Int16 。

// BigInteger to Int16 conversion.
BigInteger goodShort = 20000;
BigInteger badShort = 33000;

short shortFromBigInteger;

// Successful conversion using cast operator.
shortFromBigInteger = (short) goodShort;
Console.WriteLine(shortFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   shortFromBigInteger = (short) badShort;
   Console.WriteLine(shortFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badShort, e.Message);
}
Console.WriteLine();

// BigInteger to Int16 conversion.
let goodShort = bigint 20000
let badShort = bigint 33000

// Successful conversion using cast operator.
let shortFromBigInteger = int16 goodShort
printfn $"{shortFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let shortFromBigInteger = int16 badShort
    printfn $"{shortFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badShort}:\n   {e.Message}"

' BigInteger to Int16 conversion.
Dim goodShort As BigInteger = 20000
Dim badShort As BigInteger = 33000

Dim shortFromBigInteger As Short

' Convert using CType function.
shortFromBigInteger = CType(goodShort, Short)
Console.WriteLine(shortFromBigInteger)
' Convert using CShort function.
shortFromBigInteger = CShort(goodShort)
Console.WriteLine(shortFromBigInteger)

' Handle conversion that should result in overflow.
Try
   shortFromBigInteger = CType(badShort, Short)
   Console.WriteLine(shortFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badShort, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（如 CType visual Basic) 中的或 CShort ）时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围Int16，则在运行时可能会引发 OverflowException 。如果转换成功，则结果 Int16 值中不会丢失精度。

适用于

Explicit(BigInteger to Int128)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将大整数显式转换为 Int128 值。

public:
 static explicit operator Int128(System::Numerics::BigInteger value);

public static explicit operator Int128 (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> Int128

Public Shared Narrowing Operator CType (value As BigInteger) As Int128

参数

value: BigInteger

要转换的值。

Int128

value 转换为 Int128 值。

适用于

Explicit(BigInteger to Half)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将大整数显式转换为 Half 值。

public:
 static explicit operator Half(System::Numerics::BigInteger value);

public static explicit operator Half (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> Half

Public Shared Narrowing Operator CType (value As BigInteger) As Half

参数

value: BigInteger

要转换的值。

Half

value 转换为 Half 值。

适用于

Explicit(BigInteger to Double)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到 Double 值的显式转换。

public:
 static explicit operator double(System::Numerics::BigInteger value);

public static explicit operator double (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> double

Public Shared Narrowing Operator CType (value As BigInteger) As Double

参数

value: BigInteger

要转换为 Double 的值。

Double

包含 value 参数值的对象。

示例

下面的示例演示了到值的转换BigInteger Double。

// BigInteger to Double conversion.
BigInteger goodDouble = (BigInteger) 102.43e22;
BigInteger badDouble = (BigInteger) Double.MaxValue;
badDouble = badDouble * 2;

double doubleFromBigInteger;

// successful conversion using cast operator.
doubleFromBigInteger = (double) goodDouble;
Console.WriteLine(doubleFromBigInteger);

// Convert an out-of-bounds BigInteger value to a Double.
doubleFromBigInteger = (double) badDouble;
Console.WriteLine(doubleFromBigInteger);

// BigInteger to Double conversion.
let goodDouble = bigint 102.43e22
let badDouble = bigint Double.MaxValue * bigint 2

// successful conversion using cast operator.
let doubleFromBigInteger = double goodDouble
printfn $"{doubleFromBigInteger}"

// Convert an out-of-bounds BigInteger value to a Double.
let doubleFromBigInteger = double badDouble
printfn $"{doubleFromBigInteger}"

' BigInteger to Double conversion.
Dim goodDouble As BigInteger = 102.43e22
Dim badDouble As BigInteger = CType(Double.MaxValue, BigInteger)  
badDouble = badDouble * 2

Dim doubleFromBigInteger As Double

' Convert using CType function.
doubleFromBigInteger = CType(goodDouble, Double)
Console.WriteLine(doubleFromBigInteger)
' Convert using CDbl function.
doubleFromBigInteger = CDbl(goodDouble)
Console.WriteLine(doubleFromBigInteger)

' Convert an out-of-bounds BigInteger value to a Double.
doubleFromBigInteger = CType(badDouble, Double)
Console.WriteLine(doubleFromBigInteger)

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (，或使用 visual Basic) 中的或 CDbl (CType转换函数时，它们才会执行转换。

BigInteger由于值可能超出数据类型的范围Double，因此此操作是一种收缩转换。如果转换不成功，则不会引发 OverflowException。相反，如果 BigInteger 值小于 Double.MinValue，则生成的 Double 值为 Double.NegativeInfinity。 BigInteger如果值大于 Double.MaxValue，则生成的Double值为 Double.PositiveInfinity。

BigInteger将转换为可能Double涉及精度损失。在某些情况下，丢失精度可能会导致强制转换或转换操作成功，即使 BigInteger 该值超出了数据类型的范围 Double 。下面的示例进行了这方面的演示。它将的最大值分配给两个Double BigInteger变量，将一个BigInteger变量递增 9.999e291，并测试两个变量是否相等。如预期的那样，对方法的 BigInteger.Equals(BigInteger) 调用显示它们不相等。但是，将较大的 BigInteger 值转换回成功 Double ，尽管 BigInteger 该值现在超过 Double.MaxValue。

// Increase a BigInteger so it exceeds Double.MaxValue.
BigInteger number1 = (BigInteger) Double.MaxValue;
BigInteger number2 = number1;
number2 = number2 + (BigInteger) 9.999e291;
// Compare the BigInteger values for equality.
Console.WriteLine("BigIntegers equal: {0}", number2.Equals(number1));

// Convert the BigInteger to a Double.
double dbl = (double) number2;

// Display the two values.
Console.WriteLine("BigInteger: {0}", number2);
Console.WriteLine("Double:     {0}", dbl);
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 1.7976931348623158081352742373E+308
//       Double:     1.79769313486232E+308

// Increase a BigInteger so it exceeds Double.MaxValue.
let number1 = bigint Double.MaxValue
let number2 = number1 + bigint 9.999e291
// Compare the BigInteger values for equality.
printfn $"BigIntegers equal: {number2.Equals number1}"

// Convert the BigInteger to a Double.
let dbl = float number2

// Display the two values.
printfn $"BigInteger: {number2}"
printfn $"Double:     {dbl}"
// The example displays the following output:
//       BigIntegers equal: False
//       BigInteger: 1.7976931348623158081352742373E+308
//       Double:     1.79769313486232E+308

' Increase a BigInteger so it exceeds Double.MaxValue.
Dim number1 As BigInteger = CType(Double.MaxValue, BigInteger)
Dim number2 As BigInteger = number1
number2 = number2 + 9.999e291
' Compare the BigInteger values for equality.
Console.WriteLine("BigIntegers equal: {0}", number2.Equals(number1))

' Convert the BigInteger to a Double.
Dim dbl As Double = CType(number2, Double)

' Display the two values.
Console.WriteLine("BigInteger: {0}", number2)
Console.WriteLine("Double:     {0}", dbl)      
' The example displays the following output:
'       BigIntegers equal: False
'       BigInteger: 1.7976931348623158081352742373E+308
'       Double:     1.79769313486232E+308

适用于

Explicit(BigInteger to Decimal)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到 Decimal 值的显式转换。

public:
 static explicit operator System::Decimal(System::Numerics::BigInteger value);

public static explicit operator decimal (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> decimal

Public Shared Narrowing Operator CType (value As BigInteger) As Decimal

参数

value: BigInteger

要转换为 Decimal 的值。

Decimal

包含 value 参数值的对象。

例外

OverflowException

value 小于 Decimal.MinValue 或大于 Decimal.MaxValue。

示例

以下示例演示了如何 BigInteger 转换为 Decimal 值。它还处理 OverflowException 由于 BigInteger 值超出数据类型范围而引发的 Decimal 。

// BigInteger to Decimal conversion.
BigInteger goodDecimal = 761652543;
BigInteger badDecimal = (BigInteger) Decimal.MaxValue;
badDecimal += BigInteger.One;

Decimal decimalFromBigInteger;

// Successful conversion using cast operator.
decimalFromBigInteger = (decimal) goodDecimal;
Console.WriteLine(decimalFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   decimalFromBigInteger = (decimal) badDecimal;
   Console.WriteLine(decimalFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badDecimal, e.Message);
}
Console.WriteLine();

// BigInteger to Decimal conversion.
let goodDecimal = 761652543
let badDecimal = bigint Decimal.MaxValue + BigInteger.One

// Successful conversion using cast operator.
let decimalFromBigInteger = decimal goodDecimal
printfn $"{decimalFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let decimalFromBigInteger = decimal badDecimal
    printfn $"{decimalFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badDecimal}:\n   {e.Message}"

' BigInteger to Decimal conversion.
Dim goodDecimal As BigInteger = 761652543
Dim badDecimal As BigInteger = CType(Decimal.MaxValue, BigInteger) 
badDecimal += BigInteger.One

Dim decimalFromBigInteger As Decimal

' Convert using CType function.
decimalFromBigInteger = CType(goodDecimal, Decimal)
Console.WriteLine(decimalFromBigInteger)
' Convert using CDec function.
decimalFromBigInteger = CDec(goodDecimal)
Console.WriteLine(decimalFromBigInteger)

' Handle conversion that should result in overflow.
Try
   decimalFromBigInteger = CType(badDecimal, Decimal)
   Console.WriteLine(decimalFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badDecimal, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (，或使用 visual Basic) 中的或 CDec (CType转换函数时，它们才会执行转换。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围Decimal，则在运行时可能会引发 OverflowException 。

适用于

Explicit(BigInteger to Char)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将大整数显式转换为 Char 值。

public:
 static explicit operator char(System::Numerics::BigInteger value);

public static explicit operator char (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> char

Public Shared Narrowing Operator CType (value As BigInteger) As Char

参数

value: BigInteger

要转换的值。

Char

value 转换为 Char 值。

适用于

Explicit(BigInteger to Byte)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到无符号字节值的显式转换。

public:
 static explicit operator System::Byte(System::Numerics::BigInteger value);

public static explicit operator byte (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> byte

Public Shared Narrowing Operator CType (value As BigInteger) As Byte

参数

value: BigInteger

要转换为 Byte 的值。

Byte

包含 value 参数值的对象。

例外

OverflowException

value 小于 Byte.MinValue 或大于 Byte.MaxValue。

示例

以下示例演示了如何 BigInteger 转换为 Byte 值。它还处理 OverflowException 由于 BigInteger 值超出数据类型范围而引发的 Byte 。

// BigInteger to Byte conversion.
BigInteger goodByte = BigInteger.One;
BigInteger badByte = 256;

byte byteFromBigInteger;

// Successful conversion using cast operator.
byteFromBigInteger = (byte) goodByte;
Console.WriteLine(byteFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   byteFromBigInteger = (byte) badByte;
   Console.WriteLine(byteFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badByte, e.Message);
}
Console.WriteLine();

// BigInteger to Byte conversion.
let goodByte = BigInteger.One
let badByte = bigint 256

// Successful conversion using cast operator.
let byteFromBigInteger = byte goodByte
printfn $"{byteFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let byteFromBigInteger = byte badByte
    printfn $"{byteFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badByte}:\n   {e.Message}"

' BigInteger to Byte conversion.
Dim goodByte As BigInteger = BigInteger.One
Dim badByte As BigInteger = 256

Dim byteFromBigInteger As Byte   

' Convert using CType function.
byteFromBigInteger = CType(goodByte, Byte)
Console.WriteLine(byteFromBigInteger)
' Convert using CByte function.
byteFromBigInteger = CByte(goodByte)
Console.WriteLine(byteFromBigInteger)

' Handle conversion that should result in overflow.
Try
   byteFromBigInteger = CType(badByte, Byte)
   Console.WriteLine(byteFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badByte, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (，或使用 visual Basic) 中的或 CByte (CType转换函数时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围Byte，则在运行时可能会引发 OverflowException 。如果转换成功，则生成的 Byte 值不会丢失精度。

适用于

Explicit(Half to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

将值显式转换为 Half 大整数。

public:
 static explicit operator System::Numerics::BigInteger(Half value);

public static explicit operator System.Numerics.BigInteger (Half value);

static member op_Explicit : Half -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Half) As BigInteger

参数

value: Half

要转换的值。

BigInteger

value 转换为大整数。

适用于

Explicit(Double to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 Double 值到 BigInteger 值的显式转换。

public:
 static explicit operator System::Numerics::BigInteger(double value);

public static explicit operator System.Numerics.BigInteger (double value);

static member op_Explicit : double -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Double) As BigInteger

参数

value: Double

要转换为 BigInteger 的值。

BigInteger

包含 value 参数值的对象。

例外

OverflowException

value 为 NaN、PositiveInfinity 或 NegativeInfinity。

示例

以下示例将值数组 Double 中的单个元素转换为 BigInteger 对象，然后显示每次转换的结果。请注意，在转换期间，值的任何小数部分 Double 将被截断。

double[] doubles = { Double.MinValue, -1.430955172e03, 2.410970032e05,
                     Double.MaxValue, Double.PositiveInfinity,
                     Double.NegativeInfinity, Double.NaN };
BigInteger number;

Console.WriteLine("{0,37} {1,37}\n", "Double", "BigInteger");

foreach (double value in doubles)
{
   try {
      number = (BigInteger) value;
      Console.WriteLine("{0,37} {1,37}", value, number);
   }
   catch (OverflowException) {
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException");
   }
}
// The example displays the following output:
//                                Double                            BigInteger
//
//                -1.79769313486232E+308  -1.7976931348623157081452742373E+308
//                          -1430.955172                                 -1430
//                           241097.0032                                241097
//                 1.79769313486232E+308   1.7976931348623157081452742373E+308
//                              Infinity                     OverflowException
//                             -Infinity                     OverflowException
//                                   NaN                     OverflowException

let doubles =
    [| Double.MinValue
       -1.430955172e03
       2.410970032e05
       Double.MaxValue
       Double.PositiveInfinity
       Double.NegativeInfinity
       Double.NaN |]

printfn "%37s %37s\n" "Double" "BigInteger"

for value in doubles do
    try
        let number = BigInteger(value)
        printfn "%37O %37O" value number
    with :? OverflowException ->
        printfn "%37O %37s" value "OverflowException"
// The example displays the following output:
//                                Double                            BigInteger
//
//                -1.79769313486232E+308  -1.7976931348623157081452742373E+308
//                          -1430.955172                                 -1430
//                           241097.0032                                241097
//                 1.79769313486232E+308   1.7976931348623157081452742373E+308
//                              Infinity                     OverflowException
//                             -Infinity                     OverflowException
//                                   NaN                     OverflowException

Dim doubles() As Double = { Double.MinValue, -1.430955172e03, 2.410970032e05, 
                            Double.MaxValue, Double.PositiveInfinity, 
                            Double.NegativeInfinity, Double.NaN }
Dim number As BigInteger

Console.WriteLine("{0,37} {1,37}", "Double", "BigInteger")
Console.WriteLine()
For Each value As Double In doubles
   Try
      number = CType(value, BigInteger)
      Console.WriteLine("{0,37} {1,37}", value, number)
   Catch e As OverflowException
      Console.WriteLine("{0,37} {1,37}", value, "OverflowException")
   End Try      
Next
' The example displays the following output:
'                                Double                            BigInteger
' 
'                -1.79769313486232E+308  -1.7976931348623157081452742373E+308
'                          -1430.955172                                 -1430
'                           241097.0032                                241097
'                 1.79769313486232E+308   1.7976931348623157081452742373E+308
'                              Infinity                     OverflowException
'                             -Infinity                     OverflowException
'                                   NaN                     OverflowException

注解

参数的任何小数部分 value 在转换前被截断。

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 由于从 Double 到 BigInteger 的转换可能涉及截断的任何小数部分 value，因此语言编译器不会自动执行此转换。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（例如 CType 在 Visual Basic) 中）时才执行转换。否则，它们会显示编译器错误。

对于不支持自定义运算符的语言，替代方法是 BigInteger.BigInteger(Double)。

适用于

Explicit(Decimal to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 Decimal 对象到 BigInteger 值的显式转换。

public:
 static explicit operator System::Numerics::BigInteger(System::Decimal value);

public static explicit operator System.Numerics.BigInteger (decimal value);

static member op_Explicit : decimal -> System.Numerics.BigInteger

Public Shared Narrowing Operator CType (value As Decimal) As BigInteger

参数

value: Decimal

要转换为 BigInteger 的值。

BigInteger

包含 value 参数值的对象。

示例

以下示例将值数组 Decimal 中的单个元素转换为 BigInteger 对象，然后显示每次转换的结果。请注意，在转换期间，值的任何小数部分 Decimal 将被截断。

decimal[] decimals = { Decimal.MinValue, -15632.991m, 9029321.12m,
                       Decimal.MaxValue };
BigInteger number;

Console.WriteLine("{0,35} {1,35}\n", "Decimal", "BigInteger");

foreach (decimal value in decimals)
{
   number = (BigInteger) value;
   Console.WriteLine("{0,35} {1,35}", value, number);
}
// The example displays the following output:
//
//                          Decimal                          BigInteger
//
//    -79228162514264337593543950335      -79228162514264337593543950335
//                       -15632.991                              -15632
//                       9029321.12                             9029321
//    79228162514264337593543950335       79228162514264337593543950335

let decimals = [| Decimal.MinValue; -15632.991m; 9029321.12m; Decimal.MaxValue |]

printfn "%35s %35s\n" "Decimal" "BigInteger"

for value in decimals do
    let number = BigInteger(value)
    printfn "%35O %35O" value number
// The example displays the following output:
//
//                          Decimal                          BigInteger
//
//    -79228162514264337593543950335      -79228162514264337593543950335
//                       -15632.991                              -15632
//                       9029321.12                             9029321
//    79228162514264337593543950335       79228162514264337593543950335

' Explicit Decimal to BigInteger conversion
Dim decimals() As Decimal = { Decimal.MinValue, -15632.991d, 9029321.12d, 
                              Decimal.MaxValue }
Dim number As BigInteger 

Console.WriteLine("{0,35} {1,35}", "Decimal", "BigInteger")
Console.WriteLine()
For Each value As Decimal In decimals
   number = CType(value, BigInteger)
   Console.WriteLine("{0,35} {1,35}",
                     value, number)
Next
' The example displays the following output:
'
'                          Decimal                          BigInteger
'    
'    -79228162514264337593543950335      -79228162514264337593543950335
'                       -15632.991                              -15632
'                       9029321.12                             9029321
'    79228162514264337593543950335       79228162514264337593543950335

注解

参数的任何小数部分 value 在转换前被截断。

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 由于从 Decimal 到 BigInteger 的转换可能涉及截断的任何小数部分 value，因此语言编译器不会自动执行此转换。相反，仅当转换运算符在 C#) 中 (或使用转换函数 (（例如 CType 在 Visual Basic) 中）时才执行转换。否则，它们会显示编译器错误。

对于不支持自定义运算符的语言，替代方法是 BigInteger.BigInteger(Decimal)。

适用于

Explicit(BigInteger to Int32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

定义从 BigInteger 对象到 32 位带符号整数值的显式转换。

public:
 static explicit operator int(System::Numerics::BigInteger value);

public static explicit operator int (System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> int

Public Shared Narrowing Operator CType (value As BigInteger) As Integer

参数

value: BigInteger

要转换为 32 位带符号整数的值。

Int32

包含 value 参数值的对象。

例外

OverflowException

value 小于 Int32.MinValue 或大于 Int32.MaxValue。

示例

以下示例演示了如何 BigInteger 转换为 Int32 值。它还处理 OverflowException 由于 BigInteger 值超出数据类型范围而引发的 Int32 。

// BigInteger to Int32 conversion.
BigInteger goodInteger = 200000;
BigInteger badInteger = 65000000000;

int integerFromBigInteger;

// Successful conversion using cast operator.
integerFromBigInteger = (int) goodInteger;
Console.WriteLine(integerFromBigInteger);

// Handle conversion that should result in overflow.
try
{
   integerFromBigInteger = (int) badInteger;
   Console.WriteLine(integerFromBigInteger);
}
catch (OverflowException e)
{
   Console.WriteLine("Unable to convert {0}:\n   {1}",
                     badInteger, e.Message);
}
Console.WriteLine();

// BigInteger to Int32 conversion.
let goodInteger = bigint 200000
let badInteger = bigint 65000000000L

// Successful conversion using cast operator.
let integerFromBigInteger = int goodInteger
printfn $"{integerFromBigInteger}"

// Handle conversion that should result in overflow.
try
    let integerFromBigInteger = int badInteger
    printfn $"{integerFromBigInteger}"
with :? OverflowException as e ->
    printfn $"Unable to convert {badInteger}:\n   {e.Message}"

' BigInteger to Int32 conversion.
Dim goodInteger As BigInteger = 200000
Dim badInteger As BigInteger = 65000000000

Dim integerFromBigInteger As Integer

' Convert using CType function.
integerFromBigInteger = CType(goodInteger, Integer)
Console.WriteLine(integerFromBigInteger)
' Convert using CInt function.
integerFromBigInteger = CInt(goodInteger)
Console.WriteLIne(integerFromBigInteger)

' Handle conversion that should result in overflow.
Try
   integerFromBigInteger = CType(badInteger, Integer)
   Console.WriteLine(integerFromBigInteger)
Catch e As OverflowException
   Console.WriteLine("Unable to convert {0}:{1}   {2}", _
                     badInteger, vbCrLf, e.Message)
End Try
Console.WriteLine()

注解

方法的Explicit(Decimal to BigInteger)重载定义对象可以转换到的类型。BigInteger 语言编译器不会自动执行此转换，因为它可能涉及数据丢失。相反，仅当转换运算符在 C#) 中 (，或使用 visual Basic) 中的或 CInt (CType转换函数时，它们才会执行转换。否则，它们会显示编译器错误。

由于此操作定义了收缩转换，因此，如果BigInteger值超出数据类型的范围Int32，则在运行时可能会引发 OverflowException 。如果转换成功，则生成的 Int32 值不会丢失精度。

适用于

通过

BigInteger.Explicit 操作员

定义

重载

Explicit(BigInteger to SByte)

参数

返回

例外

示例

注解

适用于

Explicit(Single to BigInteger)

参数

返回

例外

示例

注解

适用于

Explicit(Complex to BigInteger)

参数

返回

适用于

Explicit(BigInteger to UIntPtr)

参数

返回

适用于

Explicit(BigInteger to UInt64)

参数

返回

例外

示例

注解

适用于

Explicit(BigInteger to UInt32)

参数

返回

例外

示例

注解

适用于

Explicit(BigInteger to UInt16)

参数

返回

例外

示例

注解

适用于

Explicit(BigInteger to UInt128)

参数

返回

适用于

Explicit(BigInteger to Single)

参数

返回

示例

注解

适用于

Explicit(BigInteger to IntPtr)

参数

返回

适用于

Explicit(BigInteger to Int64)

参数

返回

例外

示例

注解

适用于

Explicit(BigInteger to Int16)

参数

返回

例外

示例

注解

适用于

Explicit(BigInteger to Int128)

参数

返回

适用于

Explicit(BigInteger to Half)