BigInteger.Explicit Operator

Definition

Namespace:: System.Numerics

Assemblys:: netstandard.dll, System.Runtime.Numerics.dll

Assemblys:: System.Numerics.dll, System.Runtime.Numerics.dll

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Definiert eine explizite Konvertierung zwischen einem BigInteger Objekt und einem anderen Typ.

Überlädt

Name	Beschreibung
Explicit(BigInteger to BFloat16)
Explicit(Single to BigInteger)	Definiert eine explizite Konvertierung eines Single Werts in einen BigInteger Wert.
Explicit(Complex to BigInteger)	Wandelt einen Complex Wert explizit in eine große ganze Zahl um.
Explicit(BigInteger to UIntPtr)	Wandelt eine große ganze Zahl explizit in einen UIntPtr Wert um.
Explicit(BigInteger to UInt64)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 64-Bit-Wert ohne Vorzeichen. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Double.
Explicit(BigInteger to UInt32)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen nicht signierten ganzzahligen 32-Bit-Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Int64.
Explicit(BigInteger to UInt16)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 16-Bit-Wert ohne Vorzeichen. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Int32.
Explicit(BigInteger to UInt128)	Wandelt eine große ganze Zahl explizit in einen UInt128 Wert um.
Explicit(BigInteger to Single)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen Gleitkommawert mit einer Genauigkeit.
Explicit(BigInteger to SByte)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen signierten 8-Bit-Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Int16.
Explicit(BigInteger to Int64)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 64-Bit-Wert mit Vorzeichen.
Explicit(BigInteger to IntPtr)	Wandelt eine große ganze Zahl explizit in einen IntPtr Wert um.
Explicit(BigInteger to Int16)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 16-Bit-Wert mit Vorzeichen.
Explicit(BigInteger to Int128)	Wandelt eine große ganze Zahl explizit in einen Int128 Wert um.
Explicit(BigInteger to Half)	Wandelt eine große ganze Zahl explizit in einen Half Wert um.
Explicit(BigInteger to Double)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen Double Wert.
Explicit(BigInteger to Decimal)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen Decimal Wert.
Explicit(BigInteger to Char)	Wandelt eine große ganze Zahl explizit in einen Char Wert um.
Explicit(BigInteger to Byte)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen nicht signierten Bytewert.
Explicit(BFloat16 to BigInteger)
Explicit(Half to BigInteger)	Wandelt einen Half Wert explizit in eine große ganze Zahl um.
Explicit(Double to BigInteger)	Definiert eine explizite Konvertierung eines Double Werts in einen BigInteger Wert.
Explicit(Decimal to BigInteger)	Definiert eine explizite Konvertierung eines Decimal Objekts in einen BigInteger Wert.
Explicit(BigInteger to Int32)	Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 32-Bit-Wert mit Vorzeichen.

Explicit(BigInteger to BFloat16)

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

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

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

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

Parameter

value: BigInteger

Gibt zurück

BFloat16

Gilt für:

Explicit(Single to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines Single Werts in einen BigInteger Wert.

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

Parameter

value: Single

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist NaN, , PositiveInfinityoder NegativeInfinity.

Beispiele

Im folgenden Beispiel werden die einzelnen Elemente in einem Array von Single Werten in BigInteger Objekte konvertiert und anschließend das Ergebnis jeder Konvertierung angezeigt. Beachten Sie, dass jeder Bruchteil eines Single Werts während der Konvertierung abgeschnitten wird.

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

Hinweise

Jeder Bruchteil des value Parameters wird vor der Konvertierung abgeschnitten.

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Da die Konvertierung von Single zu BigInteger "zu" das Abschneiden eines Bruchteils von value" umfassen kann , führen Sprachcompiler diese Konvertierung nicht automatisch aus. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Für Sprachen, die keine benutzerdefinierten Operatoren unterstützen, lautet BigInteger.BigInteger(Single)die alternative Methode .

Gilt für:

Explicit(Complex to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt einen Complex Wert explizit in eine große ganze Zahl um.

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

Parameter

value: Complex

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Gilt für:

Explicit(BigInteger to UIntPtr)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Wandelt eine große ganze Zahl explizit in einen UIntPtr Wert um.

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

Parameter

value: BigInteger

Der zu konvertierende Wert.

Gibt zurück

UIntPtr

unativeint

value in UIntPtr Wert konvertiert.

Attribute: CLSCompliantAttribute

Gilt für:

Explicit(BigInteger to UInt64)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Double

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 64-Bit-Wert ohne Vorzeichen.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: BigInteger

Der Wert, der in eine nicht signierte 64-Bit-Ganzzahl konvertiert werden soll.

Gibt zurück

UInt64

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Ausnahmen

OverflowException

value ist kleiner als UInt64.MinValue oder größer als UInt64.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger UInt64 Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des UInt64 Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CULng Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des UInt64 Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden UInt64 Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Explicit(BigInteger to UInt32)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Int64

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen nicht signierten ganzzahligen 32-Bit-Wert.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: BigInteger

Der Wert, der in eine nicht signierte 32-Bit-Ganzzahl konvertiert werden soll.

Gibt zurück

UInt32

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Ausnahmen

OverflowException

value ist kleiner als UInt32.MinValue oder größer als UInt32.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger UInt32 Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des UInt32 Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CUInt Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des UInt32 Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden UInt32 Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Explicit(BigInteger to UInt16)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Int32

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 16-Bit-Wert ohne Vorzeichen.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: BigInteger

Der Wert, der in eine nicht signierte 16-Bit-Ganzzahl konvertiert werden soll.

Gibt zurück

UInt16

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Ausnahmen

OverflowException

value ist kleiner als UInt16.MinValue oder größer als UInt16.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger UInt16 Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des UInt16 Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CUShort Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des UInt16 Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden UInt16 Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Explicit(BigInteger to UInt128)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Wandelt eine große ganze Zahl explizit in einen UInt128 Wert um.

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

Parameter

value: BigInteger

Der zu konvertierende Wert.

Gibt zurück

UInt128

value in UInt128 Wert konvertiert.

Attribute: CLSCompliantAttribute

Gilt für:

Explicit(BigInteger to Single)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen Gleitkommawert mit einer Genauigkeit.

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

Parameter

value: BigInteger

Der Wert, der in einen Gleitkommawert mit einfacher Genauigkeit konvertiert werden soll.

Gibt zurück

Single

Ein Objekt, das die nächstmögliche Darstellung des value Parameters enthält.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Single Werten veranschaulicht.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste oder einen Genauigkeitsverlust beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CSng Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da sich der BigInteger Wert außerhalb des Single Datentypbereichs befinden kann, handelt es sich bei diesem Vorgang um eine schmale Konvertierung. Wenn die Konvertierung nicht erfolgreich ist, wird kein Fehler ausgelöst OverflowException. Wenn der BigInteger Wert kleiner als Single.MinValueist, lautet Single.NegativeInfinityder resultierende Single Wert stattdessen . Wenn der BigInteger Wert größer als Single.MaxValueist, lautet Single.PositiveInfinityder resultierende Single Wert .

Die Konvertierung einer BigInteger in eine Single kann zu einem Genauigkeitsverlust führen. In einigen Fällen kann der Genauigkeitsverlust dazu führen, dass der Umwandlungs- oder Konvertierungsvorgang erfolgreich verläuft, auch wenn sich der BigInteger Wert außerhalb des Bereichs des Single Datentyps befindet. Dies wird im folgenden Beispiel veranschaulicht. Er weist den Maximalwert einer Single variablen auf zwei BigInteger Variablen zu, erhöht eine BigInteger Variable um 9,999e291 und testet die beiden Variablen auf Gleichheit. Wie erwartet zeigt der Aufruf der BigInteger.Equals(BigInteger) Methode, dass sie ungleich sind. Die Konvertierung des größeren BigInteger Werts in einen Single erfolgreichen Wert ist jedoch erfolgreich, obwohl der BigInteger Wert jetzt überschritten wird 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

Gilt für:

Explicit(BigInteger to SByte)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Int16

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen signierten 8-Bit-Wert.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: BigInteger

Der Wert, der in einen signierten 8-Bit-Wert konvertiert werden soll.

Gibt zurück

SByte

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Ausnahmen

OverflowException

value ist kleiner als SByte.MinValue oder größer als SByte.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger SByte Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des SByte Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CSByte Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des SByte Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden SByte Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Explicit(BigInteger to Int64)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 64-Bit-Wert mit Vorzeichen.

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

Parameter

value: BigInteger

Der Wert, der in eine 64-Bit-Ganzzahl konvertiert werden soll.

Gibt zurück

Int64

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist kleiner als Int64.MinValue oder größer als Int64.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Int64 Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des Int64 Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CLng Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Gilt für:

Explicit(BigInteger to IntPtr)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt eine große ganze Zahl explizit in einen IntPtr Wert um.

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

Parameter

value: BigInteger

Der zu konvertierende Wert.

Gibt zurück

IntPtr

nativeint

value in IntPtr Wert konvertiert.

Gilt für:

Explicit(BigInteger to Int16)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 16-Bit-Wert mit Vorzeichen.

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

Parameter

value: BigInteger

Der Wert, der in eine 16-Bit-Ganzzahl konvertiert werden soll.

Gibt zurück

Int16

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist kleiner als Int16.MinValue oder größer als Int16.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Int16 Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des Int16 Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CShort Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des Int16 Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden Int16 Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Explicit(BigInteger to Int128)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt eine große ganze Zahl explizit in einen Int128 Wert um.

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

Parameter

value: BigInteger

Der zu konvertierende Wert.

Gibt zurück

Int128

value in Int128 Wert konvertiert.

Gilt für:

Explicit(BigInteger to Half)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt eine große ganze Zahl explizit in einen Half Wert um.

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

Parameter

value: BigInteger

Der zu konvertierende Wert.

Gibt zurück

Half

value in Half Wert konvertiert.

Gilt für:

Explicit(BigInteger to Double)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen Double Wert.

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

Parameter

value: BigInteger

Der Wert, der in ein Double.

Gibt zurück

Double

Ein Objekt, das den Wert des value Parameters enthält.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Double Werten veranschaulicht.

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

Hinweise

Da sich der BigInteger Wert außerhalb des Double Datentypbereichs befinden kann, handelt es sich bei diesem Vorgang um eine schmale Konvertierung. Wenn die Konvertierung nicht erfolgreich ist, wird kein Fehler ausgelöst OverflowException. Wenn der BigInteger Wert kleiner als Double.MinValueist, lautet Double.NegativeInfinityder resultierende Double Wert stattdessen . Wenn der BigInteger Wert größer als Double.MaxValueist, lautet Double.PositiveInfinityder resultierende Double Wert .

Die Konvertierung einer BigInteger in eine Double kann zu einem Genauigkeitsverlust führen. In einigen Fällen kann der Genauigkeitsverlust dazu führen, dass der Umwandlungs- oder Konvertierungsvorgang erfolgreich verläuft, auch wenn sich der BigInteger Wert außerhalb des Bereichs des Double Datentyps befindet. Dies wird im folgenden Beispiel veranschaulicht. Er weist den Maximalwert einer Double variablen auf zwei BigInteger Variablen zu, erhöht eine BigInteger Variable um 9,999e291 und testet die beiden Variablen auf Gleichheit. Wie erwartet zeigt der Aufruf der BigInteger.Equals(BigInteger) Methode, dass sie ungleich sind. Die Konvertierung des größeren BigInteger Werts in einen Double erfolgreichen Wert ist jedoch erfolgreich, obwohl der BigInteger Wert jetzt überschritten wird 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

Gilt für:

Explicit(BigInteger to Decimal)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen Decimal Wert.

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

Parameter

value: BigInteger

Der Wert, der in ein Decimal.

Gibt zurück

Decimal

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist kleiner als Decimal.MinValue oder größer als Decimal.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Decimal Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des Decimal Datentyps befindet.

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

Hinweise

Gilt für:

Explicit(BigInteger to Char)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt eine große ganze Zahl explizit in einen Char Wert um.

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

Parameter

value: BigInteger

Der zu konvertierende Wert.

Gibt zurück

Char

value in Char Wert konvertiert.

Gilt für:

Explicit(BigInteger to Byte)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen nicht signierten Bytewert.

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

Parameter

value: BigInteger

Der Wert, der in ein Byte.

Gibt zurück

Byte

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist kleiner als Byte.MinValue oder größer als Byte.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Byte Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des Byte Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CByte Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des Byte Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden Byte Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Explicit(BFloat16 to BigInteger)

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

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

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

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

Parameter

value: BFloat16

Gibt zurück

BigInteger

Gilt für:

Explicit(Half to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt einen Half Wert explizit in eine große ganze Zahl um.

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

Parameter

value: Half

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Gilt für:

Explicit(Double to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines Double Werts in einen BigInteger Wert.

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

Parameter

value: Double

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist NaN, , PositiveInfinityoder NegativeInfinity.

Beispiele

Im folgenden Beispiel werden die einzelnen Elemente in einem Array von Double Werten in BigInteger Objekte konvertiert und anschließend das Ergebnis jeder Konvertierung angezeigt. Beachten Sie, dass jeder Bruchteil eines Double Werts während der Konvertierung abgeschnitten wird.

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

Hinweise

Jeder Bruchteil des value Parameters wird vor der Konvertierung abgeschnitten.

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Da die Konvertierung von Double zu BigInteger "zu" das Abschneiden eines Bruchteils von value" umfassen kann , führen Sprachcompiler diese Konvertierung nicht automatisch aus. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Für Sprachen, die keine benutzerdefinierten Operatoren unterstützen, lautet BigInteger.BigInteger(Double)die alternative Methode .

Gilt für:

Explicit(Decimal to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines Decimal Objekts in einen BigInteger Wert.

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

Parameter

value: Decimal

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Beispiele

Im folgenden Beispiel werden die einzelnen Elemente in einem Array von Decimal Werten in BigInteger Objekte konvertiert und anschließend das Ergebnis jeder Konvertierung angezeigt. Beachten Sie, dass jeder Bruchteil eines Decimal Werts während der Konvertierung abgeschnitten wird.

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

Hinweise

Jeder Bruchteil des value Parameters wird vor der Konvertierung abgeschnitten.

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Da die Konvertierung von Decimal zu BigInteger "zu" das Abschneiden eines Bruchteils von value" umfassen kann , führen Sprachcompiler diese Konvertierung nicht automatisch aus. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Für Sprachen, die keine benutzerdefinierten Operatoren unterstützen, lautet BigInteger.BigInteger(Decimal)die alternative Methode .

Gilt für:

Explicit(BigInteger to Int32)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine explizite Konvertierung eines BigInteger Objekts in einen ganzzahligen 32-Bit-Wert mit Vorzeichen.

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

Parameter

value: BigInteger

Der Wert, der in eine 32-Bit-Ganzzahl konvertiert werden soll.

Gibt zurück

Int32

Ein Objekt, das den Wert des value Parameters enthält.

Ausnahmen

OverflowException

value ist kleiner als Int32.MinValue oder größer als Int32.MaxValue.

Beispiele

Im folgenden Beispiel wird die Konvertierung von BigInteger Int32 Werten veranschaulicht. Außerdem wird ein Ausgelöstes OverflowException behandelt, da sich der BigInteger Wert außerhalb des Bereichs des Int32 Datentyps befindet.

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

Hinweise

Die Überladungen der Explicit(Decimal to BigInteger) Methode definieren die Typen, in die bzw. aus denen ein BigInteger Objekt konvertiert werden kann. Sprachcompiler führen diese Konvertierung nicht automatisch durch, da sie Datenverluste beinhalten kann. Stattdessen führen sie die Konvertierung nur aus, wenn ein Umwandlungsoperator (in C#) oder eine Konvertierungsfunktion (z CType . B. in CInt Visual Basic) verwendet wird. Andernfalls wird ein Compilerfehler angezeigt.

Da dieser Vorgang eine Schmalungskonvertierung definiert, kann dies zur Laufzeit ausgelöst OverflowException werden, wenn sich der BigInteger Wert außerhalb des Bereichs des Int32 Datentyps befindet. Es gibt keinen Genauigkeitsverlust im resultierenden Int32 Wert, wenn die Konvertierung erfolgreich ist.

Gilt für:

Feedback

War diese Seite hilfreich?

Teilen über

BigInteger.Explicit Operator

Definition

Überlädt

Explicit(BigInteger to BFloat16)

Parameter

Gibt zurück

Gilt für:

Explicit(Single to BigInteger)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(Complex to BigInteger)

Parameter

Gibt zurück

Gilt für:

Explicit(BigInteger to UIntPtr)

Parameter

Gibt zurück

Gilt für:

Explicit(BigInteger to UInt64)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to UInt32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to UInt16)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to UInt128)

Parameter

Gibt zurück

Gilt für:

Explicit(BigInteger to Single)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to SByte)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to Int64)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to IntPtr)

Parameter

Gibt zurück

Gilt für:

Explicit(BigInteger to Int16)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Explicit(BigInteger to Int128)