BigInteger.Explicit Operator

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

Retouren

Een object dat de waarde van de value parameter bevat.

Voorbeelden

In het volgende voorbeeld worden de afzonderlijke elementen in een matrix met Decimal waarden geconverteerd naar BigInteger objecten en wordt vervolgens het resultaat van elke conversie weergegeven. Houd er rekening mee dat een breukdeel van een Decimal waarde tijdens de conversie wordt afgekapt.

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

Opmerkingen

Een breukdeel van de value parameter wordt afgekapt vóór de conversie.

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Omdat de conversie van Decimal naar kan BigInteger leiden tot het afkappen van een breukdeel van value, voeren taalcompilers deze conversie niet automatisch uit. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Voor talen die geen aangepaste operators ondersteunen, is BigInteger.BigInteger(Decimal)de alternatieve methode.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld worden de afzonderlijke elementen in een matrix met Double waarden geconverteerd naar BigInteger objecten en wordt vervolgens het resultaat van elke conversie weergegeven. Houd er rekening mee dat een breukdeel van een Double waarde tijdens de conversie wordt afgekapt.

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

Opmerkingen

Een breukdeel van de value parameter wordt afgekapt vóór de conversie.

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Omdat de conversie van Double naar kan BigInteger leiden tot het afkappen van een breukdeel van value, voeren taalcompilers deze conversie niet automatisch uit. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Voor talen die geen aangepaste operators ondersteunen, is BigInteger.BigInteger(Double)de alternatieve methode.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden Byte . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het Byte gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CByte in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het Byte gegevenstype valt. Er is geen verlies van precisie in de resulterende Byte waarde als de conversie is geslaagd.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden Decimal . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het Decimal gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CDec in Visual Basic) wordt gebruikt.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het Decimal gegevenstype valt.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden 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)

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CDbl in Visual Basic) wordt gebruikt.

Omdat de BigInteger waarde buiten het gegevensbereik van het Double gegevenstype kan liggen, is deze bewerking een smalle conversie. Als de conversie mislukt, wordt OverflowExceptioner geen . Als de BigInteger waarde kleiner is danDouble.MinValue, is Double.NegativeInfinityde resulterende Double waarde in plaats daarvan . Als de BigInteger waarde groter is dan Double.MaxValue, is Double.PositiveInfinityde resulterende Double waarde .

De conversie van een BigInteger naar een Double kan leiden tot verlies van precisie. In sommige gevallen kan het verlies van precisie ertoe leiden dat de cast- of conversiebewerking slaagt, zelfs als de BigInteger waarde buiten het bereik van het Double gegevenstype valt. In het volgende voorbeeld ziet u een afbeelding. Hiermee wordt de maximumwaarde van een Double aan twee BigInteger variabelen toegewezen, één BigInteger variabele verhoogd met 9,999e291 en worden de twee variabelen getest op gelijkheid. Zoals verwacht laat de aanroep van de BigInteger.Equals(BigInteger) methode zien dat ze ongelijk zijn. De conversie van de grotere BigInteger waarde naar een Double geslaagde waarde slaagt echter, hoewel de BigInteger waarde nu groter is Double.MaxValuedan .

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

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden Int16 . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het Int16 gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CShort in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het Int16 gegevenstype valt. Er is geen verlies van precisie in de resulterende Int16 waarde als de conversie is geslaagd.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden Int32 . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het Int32 gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CInt in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het Int32 gegevenstype valt. Er is geen verlies van precisie in de resulterende Int32 waarde als de conversie is geslaagd.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden Int64 . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het Int64 gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CLng in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het Int64 gegevenstype valt.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden SByte . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het SByte gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CSByte in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het SByte gegevenstype valt. Er is geen verlies van precisie in de resulterende SByte waarde als de conversie is geslaagd.

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

Retouren

Een object dat de dichtstbijzijnde mogelijke weergave van de value parameter bevat.

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden 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)

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies of verlies van precisie kan omvatten. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CSng in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat de BigInteger waarde buiten het gegevensbereik van het Single gegevenstype kan liggen, is deze bewerking een smalle conversie. Als de conversie mislukt, wordt OverflowExceptioner geen . Als de BigInteger waarde kleiner is danSingle.MinValue, is Single.NegativeInfinityde resulterende Single waarde in plaats daarvan . Als de BigInteger waarde groter is dan Single.MaxValue, is Single.PositiveInfinityde resulterende Single waarde .

De conversie van een BigInteger naar een Single kan leiden tot verlies van precisie. In sommige gevallen kan het verlies van precisie ertoe leiden dat de cast- of conversiebewerking slaagt, zelfs als de BigInteger waarde buiten het bereik van het Single gegevenstype valt. In het volgende voorbeeld ziet u een afbeelding. Hiermee wordt de maximumwaarde van een Single aan twee BigInteger variabelen toegewezen, één BigInteger variabele verhoogd met 9,999e291 en worden de twee variabelen getest op gelijkheid. Zoals verwacht laat de aanroep van de BigInteger.Equals(BigInteger) methode zien dat ze ongelijk zijn. De conversie van de grotere BigInteger waarde naar een Single geslaagde waarde slaagt echter, hoewel de BigInteger waarde nu groter is Single.MaxValuedan .

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

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

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden UInt16 . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het UInt16 gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CUShort in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het UInt16 gegevenstype valt. Er is geen verlies van precisie in de resulterende UInt16 waarde als de conversie is geslaagd.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden UInt32 . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het UInt32 gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CUInt in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het UInt32 gegevenstype valt. Er is geen verlies van precisie in de resulterende UInt32 waarde als de conversie is geslaagd.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u de conversie van BigInteger waarden UInt64 . Er wordt ook een OverflowException gegenereerde waarde verwerkt omdat de BigInteger waarde buiten het bereik van het UInt64 gegevenstype valt.

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

Opmerkingen

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Taalcompilers voeren deze conversie niet automatisch uit omdat dit gegevensverlies kan veroorzaken. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType of CULng in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Omdat deze bewerking een narrowing conversie definieert, kan deze een OverflowException runtime genereren als de BigInteger waarde buiten het bereik van het UInt64 gegevenstype valt. Er is geen verlies van precisie in de resulterende UInt64 waarde als de conversie is geslaagd.

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

Retouren

Een object dat de waarde van de value parameter bevat.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld worden de afzonderlijke elementen in een matrix met Single waarden geconverteerd naar BigInteger objecten en wordt vervolgens het resultaat van elke conversie weergegeven. Houd er rekening mee dat een breukdeel van een Single waarde tijdens de conversie wordt afgekapt.

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

Opmerkingen

Een breukdeel van de value parameter wordt afgekapt vóór de conversie.

De overbelasting van de Explicit(Decimal to BigInteger) methode definieert de typen waarnaar of van waaruit een BigInteger object kan worden geconverteerd. Omdat de conversie van Single naar kan BigInteger leiden tot het afkappen van een breukdeel van value, voeren taalcompilers deze conversie niet automatisch uit. In plaats daarvan voeren ze de conversie alleen uit als een cast-operator (in C#) of een conversiefunctie (zoals CType in Visual Basic) wordt gebruikt. Anders geven ze een compilerfout weer.

Voor talen die geen aangepaste operators ondersteunen, is BigInteger.BigInteger(Single)de alternatieve methode.