BigInteger.Explicit Operator

Reference

Definition

Namespace:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Defines an explicit conversion between a BigInteger object and another type.

Overloads

Explicit(BigInteger to SByte)	Defines an explicit conversion of a BigInteger object to a signed 8-bit value. This API is not CLS-compliant. The compliant alternative is Int16.
Explicit(Single to BigInteger)	Defines an explicit conversion of a Single value to a BigInteger value.
Explicit(Complex to BigInteger)	Explicitly converts a Complex value to a big integer.
Explicit(BigInteger to UIntPtr)	Explicitly converts a big integer to a UIntPtr value.
Explicit(BigInteger to UInt64)	Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value. This API is not CLS-compliant. The compliant alternative is Double.
Explicit(BigInteger to UInt32)	Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value. This API is not CLS-compliant. The compliant alternative is Int64.
Explicit(BigInteger to UInt16)	Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value. This API is not CLS-compliant. The compliant alternative is Int32.
Explicit(BigInteger to UInt128)	Explicitly converts a big integer to a UInt128 value.
Explicit(BigInteger to Single)	Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.
Explicit(BigInteger to IntPtr)	Explicitly converts a big integer to a IntPtr value.
Explicit(BigInteger to Int64)	Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.
Explicit(BigInteger to Int16)	Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.
Explicit(BigInteger to Int128)	Explicitly converts a big integer to a Int128 value.
Explicit(BigInteger to Half)	Explicitly converts a big integer to a Half value.
Explicit(BigInteger to Double)	Defines an explicit conversion of a BigInteger object to a Double value.
Explicit(BigInteger to Decimal)	Defines an explicit conversion of a BigInteger object to a Decimal value.
Explicit(BigInteger to Char)	Explicitly converts a big integer to a Char value.
Explicit(BigInteger to Byte)	Defines an explicit conversion of a BigInteger object to an unsigned byte value.
Explicit(Half to BigInteger)	Explicitly converts a Half value to a big integer.
Explicit(Double to BigInteger)	Defines an explicit conversion of a Double value to a BigInteger value.
Explicit(Decimal to BigInteger)	Defines an explicit conversion of a Decimal object to a BigInteger value.
Explicit(BigInteger to Int32)	Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to SByte)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

This API is not CLS-compliant.

CLS-compliant alternative: System.Int16

Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

This API is not CLS-compliant. The compliant alternative is 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

Parameters

value: BigInteger

The value to convert to a signed 8-bit value.

Returns

SByte

An object that contains the value of the value parameter.

Attributes: CLSCompliantAttribute

Exceptions

OverflowException

value is less than SByte.MinValue or is greater than SByte.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to SByte values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the SByte data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CSByte in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the SByte data type. There is no loss of precision in the resulting SByte value if the conversion is successful.

Applies to

Explicit(Single to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a Single value to a BigInteger value.

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

Parameters

value: Single

The value to convert to a BigInteger.

Returns

BigInteger

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is NaN, PositiveInfinity, or NegativeInfinity.

Examples

The following example converts the individual elements in an array of Single values to BigInteger objects, and then displays the result of each conversion. Note that any fractional part of a Single value is truncated during the conversion.

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

Remarks

Any fractional part of the value parameter is truncated before conversion.

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Because the conversion from Single to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Otherwise, they display a compiler error.

For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Single).

Applies to

Explicit(Complex to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Explicitly converts a Complex value to a big integer.

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

Parameters

value: Complex

The value to convert.

Returns

BigInteger

value converted to a big integer.

Applies to

Explicit(BigInteger to UIntPtr)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

This API is not CLS-compliant.

Explicitly converts a big integer to a UIntPtr value.

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

Parameters

value: BigInteger

The value to convert.

Returns

UIntPtr

unativeint

value converted to UIntPtr value.

Attributes: CLSCompliantAttribute

Applies to

Explicit(BigInteger to UInt64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

This API is not CLS-compliant.

CLS-compliant alternative: System.Double

Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

This API is not CLS-compliant. The compliant alternative is 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

Parameters

value: BigInteger

The value to convert to an unsigned 64-bit integer.

Returns

UInt64

An object that contains the value of the value parameter.

Attributes: CLSCompliantAttribute

Exceptions

OverflowException

value is less than UInt64.MinValue or is greater than UInt64.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to UInt64 values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the UInt64 data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CULng in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the UInt64 data type. There is no loss of precision in the resulting UInt64 value if the conversion is successful.

Applies to

Explicit(BigInteger to UInt32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

This API is not CLS-compliant.

CLS-compliant alternative: System.Int64

Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

This API is not CLS-compliant. The compliant alternative is 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

Parameters

value: BigInteger

The value to convert to an unsigned 32-bit integer.

Returns

UInt32

An object that contains the value of the value parameter.

Attributes: CLSCompliantAttribute

Exceptions

OverflowException

value is less than UInt32.MinValue or is greater than UInt32.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to UInt32 values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the UInt32 data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CUInt in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the UInt32 data type. There is no loss of precision in the resulting UInt32 value if the conversion is successful.

Applies to

Explicit(BigInteger to UInt16)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

This API is not CLS-compliant.

CLS-compliant alternative: System.Int32

Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

This API is not CLS-compliant. The compliant alternative is 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

Parameters

value: BigInteger

The value to convert to an unsigned 16-bit integer.

Returns

UInt16

An object that contains the value of the value parameter.

Attributes: CLSCompliantAttribute

Exceptions

OverflowException

value is less than UInt16.MinValue or is greater than UInt16.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to UInt16 values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the UInt16 data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CUShort in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the UInt16 data type. There is no loss of precision in the resulting UInt16 value if the conversion is successful.

Applies to

Explicit(BigInteger to UInt128)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

This API is not CLS-compliant.

Explicitly converts a big integer to a UInt128 value.

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

Parameters

value: BigInteger

The value to convert.

Returns

UInt128

value converted to UInt128 value.

Attributes: CLSCompliantAttribute

Applies to

Explicit(BigInteger to Single)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

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

Parameters

value: BigInteger

The value to convert to a single-precision floating-point value.

Returns

Single

An object that contains the closest possible representation of the value parameter.

Examples

The following example illustrates the conversion of BigInteger to Single values.

// 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)

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss or a loss of precision. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CSng in Visual Basic) is used. Otherwise, they display a compiler error.

Because the BigInteger value can be outside the range of the Single data type, this operation is a narrowing conversion. If the conversion is unsuccessful, it does not throw an OverflowException. Instead, if the BigInteger value is less than Single.MinValue, the resulting Single value is Single.NegativeInfinity. If the BigInteger value is greater than Single.MaxValue, the resulting Single value is Single.PositiveInfinity.

The conversion of a BigInteger to a Single may involve a loss of precision. In some cases, the loss of precision may cause the casting or conversion operation to succeed even if the BigInteger value is outside the range of the Single data type. The following example provides an illustration. It assigns the maximum value of a Single to two BigInteger variables, increments one BigInteger variable by 9.999e291, and tests the two variables for equality. As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. However, the conversion of the larger BigInteger value back to a Single succeeds, although the BigInteger value now exceeds 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

Applies to

Explicit(BigInteger to IntPtr)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Explicitly converts a big integer to a IntPtr value.

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

Parameters

value: BigInteger

The value to convert.

Returns

IntPtr

nativeint

value converted to IntPtr value.

Applies to

Explicit(BigInteger to Int64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

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

Parameters

value: BigInteger

The value to convert to a 64-bit signed integer.

Returns

Int64

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is less than Int64.MinValue or is greater than Int64.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to Int64 values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Int64 data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CLng in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Int64 data type.

Applies to

Explicit(BigInteger to Int16)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

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

Parameters

value: BigInteger

The value to convert to a 16-bit signed integer.

Returns

Int16

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is less than Int16.MinValue or is greater than Int16.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to Int16 values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Int16 data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CShort in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Int16 data type. There is no loss of precision in the resulting Int16 value if the conversion is successful.

Applies to

Explicit(BigInteger to Int128)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Explicitly converts a big integer to a Int128 value.

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

Parameters

value: BigInteger

The value to convert.

Returns

Int128

value converted to Int128 value.

Applies to

Explicit(BigInteger to Half)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Explicitly converts a big integer to a Half value.

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

Parameters

value: BigInteger

The value to convert.

Returns

Half

value converted to Half value.

Applies to

Explicit(BigInteger to Double)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to a Double value.

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

Parameters

value: BigInteger

The value to convert to a Double.

Returns

Double

An object that contains the value of the value parameter.

Examples

The following example illustrates the conversion of BigInteger to Double values.

// 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)

Remarks

Because the BigInteger value can be outside the range of the Double data type, this operation is a narrowing conversion. If the conversion is unsuccessful, it does not throw an OverflowException. Instead, if the BigInteger value is less than Double.MinValue, the resulting Double value is Double.NegativeInfinity. If the BigInteger value is greater than Double.MaxValue, the resulting Double value is Double.PositiveInfinity.

The conversion of a BigInteger to a Double may involve a loss of precision. In some cases, the loss of precision may cause the casting or conversion operation to succeed even if the BigInteger value is outside the range of the Double data type. The following example provides an illustration. It assigns the maximum value of a Double to two BigInteger variables, increments one BigInteger variable by 9.999e291, and tests the two variables for equality. As expected, the call to the BigInteger.Equals(BigInteger) method shows that they are unequal. However, the conversion of the larger BigInteger value back to a Double succeeds, although the BigInteger value now exceeds 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

Applies to

Explicit(BigInteger to Decimal)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to a Decimal value.

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

Parameters

value: BigInteger

The value to convert to a Decimal.

Returns

Decimal

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is less than Decimal.MinValue or greater than Decimal.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to Decimal values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Decimal data type.

// 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()

Remarks

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Decimal data type.

Applies to

Explicit(BigInteger to Char)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Explicitly converts a big integer to a Char value.

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

Parameters

value: BigInteger

The value to convert.

Returns

Char

value converted to Char value.

Applies to

Explicit(BigInteger to Byte)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to an unsigned byte value.

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

Parameters

value: BigInteger

The value to convert to a Byte.

Returns

Byte

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is less than Byte.MinValue or greater than Byte.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to Byte values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Byte data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CByte in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Byte data type. There is no loss of precision in the resulting Byte value if the conversion is successful.

Applies to

Explicit(Half to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Explicitly converts a Half value to a big integer.

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

Parameters

value: Half

The value to convert.

Returns

BigInteger

value converted to a big integer.

Applies to

Explicit(Double to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a Double value to a BigInteger value.

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

Parameters

value: Double

The value to convert to a BigInteger.

Returns

BigInteger

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is NaN, PositiveInfinity, or NegativeInfinity.

Examples

The following example converts the individual elements in an array of Double values to BigInteger objects, and then displays the result of each conversion. Note that any fractional part of a Double value is truncated during the conversion.

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

Remarks

Any fractional part of the value parameter is truncated before conversion.

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Because the conversion from Double to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Otherwise, they display a compiler error.

For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Double).

Applies to

Explicit(Decimal to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a Decimal object to a BigInteger value.

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

Parameters

value: Decimal

The value to convert to a BigInteger.

Returns

BigInteger

An object that contains the value of the value parameter.

Examples

The following example converts the individual elements in an array of Decimal values to BigInteger objects, and then displays the result of each conversion. Note that any fractional part of a Decimal value is truncated during the conversion.

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

Remarks

Any fractional part of the value parameter is truncated before conversion.

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Because the conversion from Decimal to BigInteger can involve truncating any fractional part of value, language compilers do not perform this conversion automatically. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType in Visual Basic) is used. Otherwise, they display a compiler error.

For languages that do not support custom operators, the alternative method is BigInteger.BigInteger(Decimal).

Applies to

Explicit(BigInteger to Int32)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

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

Parameters

value: BigInteger

The value to convert to a 32-bit signed integer.

Returns

Int32

An object that contains the value of the value parameter.

Exceptions

OverflowException

value is less than Int32.MinValue or is greater than Int32.MaxValue.

Examples

The following example illustrates the conversion of BigInteger to Int32 values. It also handles an OverflowException that is thrown because the BigInteger value is outside the range of the Int32 data type.

// 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()

Remarks

The overloads of the Explicit(Decimal to BigInteger) method define the types to which or from which a BigInteger object can be converted. Language compilers do not perform this conversion automatically because it can involve data loss. Instead, they perform the conversion only if a casting operator (in C#) or a conversion function (such as CType or CInt in Visual Basic) is used. Otherwise, they display a compiler error.

Because this operation defines a narrowing conversion, it can throw an OverflowException at run time if the BigInteger value is outside the range of the Int32 data type. There is no loss of precision in the resulting Int32 value if the conversion is successful.

Applies to

Jaa

BigInteger.Explicit Operator

Definition

Overloads

Explicit(BigInteger to SByte)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(Single to BigInteger)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(Complex to BigInteger)

Parameters

Returns

Applies to

Explicit(BigInteger to UIntPtr)

Parameters

Returns

Applies to

Explicit(BigInteger to UInt64)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(BigInteger to UInt32)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(BigInteger to UInt16)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(BigInteger to UInt128)

Parameters

Returns

Applies to

Explicit(BigInteger to Single)

Parameters

Returns

Examples

Remarks

Applies to

Explicit(BigInteger to IntPtr)

Parameters

Returns

Applies to

Explicit(BigInteger to Int64)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(BigInteger to Int16)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

Explicit(BigInteger to Int128)

Parameters

Returns

Applies to

Explicit(BigInteger to Half)