BigInteger.Explicit Operátor

Reference

Definice

Obor názvů:: System.Numerics

Sestavení:: System.Runtime.Numerics.dll

Sestavení:: System.Numerics.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Definuje explicitní převod mezi objektem a jiným typem BigInteger .

Přetížení

Explicit(BigInteger to SByte)	Definuje explicitní převod objektu BigInteger na podepsanou 8bitovou hodnotu. Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Int16.
Explicit(Single to BigInteger)	Definuje explicitní převod Single hodnoty na BigInteger hodnotu.
Explicit(Complex to BigInteger)	Explicitně Complex převede hodnotu na velké celé číslo.
Explicit(BigInteger to UIntPtr)	Explicitně převede velké celé číslo na UIntPtr hodnotu.
Explicit(BigInteger to UInt64)	Definuje explicitní převod objektu BigInteger na 64bitovou celočíselnou hodnotu bez znaménka. Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Double.
Explicit(BigInteger to UInt32)	Definuje explicitní převod objektu BigInteger na 32bitovou celočíselnou hodnotu bez znaménka. Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Int64.
Explicit(BigInteger to UInt16)	Definuje explicitní převod objektu BigInteger na 16bitovou celočíselnou hodnotu bez znaménka. Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Int32.
Explicit(BigInteger to UInt128)	Explicitně převede velké celé číslo na UInt128 hodnotu.
Explicit(BigInteger to Single)	Definuje explicitní převod objektu BigInteger na hodnotu s plovoucí desetinou čárkou s jednou přesností.
Explicit(BigInteger to IntPtr)	Explicitně převede velké celé číslo na IntPtr hodnotu.
Explicit(BigInteger to Int64)	Definuje explicitní převod objektu BigInteger na 64bitovou celočíselnou hodnotu.
Explicit(BigInteger to Int16)	Definuje explicitní převod objektu BigInteger na 16bitovou celočíselnou hodnotu.
Explicit(BigInteger to Int128)	Explicitně převede velké celé číslo na Int128 hodnotu.
Explicit(BigInteger to Half)	Explicitně převede velké celé číslo na Half hodnotu.
Explicit(BigInteger to Double)	Definuje explicitní převod objektu BigInteger na Double hodnotu.
Explicit(BigInteger to Decimal)	Definuje explicitní převod objektu BigInteger na Decimal hodnotu.
Explicit(BigInteger to Char)	Explicitně převede velké celé číslo na Char hodnotu.
Explicit(BigInteger to Byte)	Definuje explicitní převod objektu BigInteger na hodnotu bez znaménka.
Explicit(Half to BigInteger)	Explicitně Half převede hodnotu na velké celé číslo.
Explicit(Double to BigInteger)	Definuje explicitní převod Double hodnoty na BigInteger hodnotu.
Explicit(Decimal to BigInteger)	Definuje explicitní převod objektu Decimal na BigInteger hodnotu.
Explicit(BigInteger to Int32)	Definuje explicitní převod objektu BigInteger na 32bitovou celočíselnou hodnotu.

Explicit(BigInteger to SByte)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS: System.Int16

Definuje explicitní převod objektu BigInteger na podepsanou 8bitovou hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value: BigInteger

Hodnota, která se má převést na 8bitovou 8bitovou hodnotu.

Návraty

SByte

Objekt, který obsahuje hodnotu parametru value .

Atributy: CLSCompliantAttribute

Výjimky

OverflowException

value je menší než SByte.MinValue nebo je větší než SByte.MaxValue.

Příklady

Následující příklad znázorňuje převod hodnoty BigInteger na SByte hodnoty. Zpracovává také vyvolání OverflowException , protože BigInteger hodnota je mimo rozsah datového SByte typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyků neprovádějí tento převod automaticky, protože může zahrnovat ztrátu dat. Místo toho provádějí převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo převodní funkce (například CType nebo CSByte v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat OverflowException hodnotu, pokud BigInteger je hodnota mimo rozsah datového SByte typu. Při úspěšném převodu nedojde ke ztrátě přesnosti výsledné SByte hodnoty.

Platí pro

Explicit(Single to BigInteger)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod Single hodnoty na BigInteger hodnotu.

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

Parametry

value: Single

Hodnota, která se má převést na BigInteger.

Návraty

BigInteger

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je NaN, PositiveInfinitynebo NegativeInfinity.

Příklady

Následující příklad převede jednotlivé prvky v poli Single hodnot na BigInteger objekty a pak zobrazí výsledek každého převodu. Všimněte si, že během převodu Single se zkrátí jakákoli zlomková část hodnoty.

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

Poznámky

Jakákoli zlomková část parametru se před převodem value zkrátí.

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Vzhledem k tomu, že převod z Single na BigInteger může zahrnovat zkrácení jakékoli zlomkové části value, kompilátory jazyka neprovedou tento převod automaticky. Místo toho provádějí převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Pro jazyky, které nepodporují vlastní operátory, je BigInteger.BigInteger(Single)alternativní metoda .

Platí pro

Explicit(Complex to BigInteger)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Explicitně Complex převede hodnotu na velké celé číslo.

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

Parametry

value: Complex

Hodnota, kterou chcete převést.

Návraty

BigInteger

value převedeno na velké celé číslo.

Platí pro

Explicit(BigInteger to UIntPtr)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Explicitně převede velké celé číslo na UIntPtr hodnotu.

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

Parametry

value: BigInteger

Hodnota, kterou chcete převést.

Návraty

UIntPtr

unativeint

value převedeno na UIntPtr hodnotu.

Atributy: CLSCompliantAttribute

Platí pro

Explicit(BigInteger to UInt64)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS: System.Double

Definuje explicitní převod objektu BigInteger na 64bitovou celočíselnou hodnotu bez znaménka.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value: BigInteger

Hodnota, která se má převést na 64bitové celé číslo bez znaménka.

Návraty

UInt64

Objekt, který obsahuje hodnotu parametru value .

Atributy: CLSCompliantAttribute

Výjimky

OverflowException

value je menší než UInt64.MinValue nebo je větší než UInt64.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger UInt64 hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového UInt64 typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CULng v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového UInt64 typu. Při úspěšném převodu nedojde ke ztrátě přesnosti ve výsledné UInt64 hodnotě.

Platí pro

Explicit(BigInteger to UInt32)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS: System.Int64

Definuje explicitní převod objektu BigInteger na 32bitovou celočíselnou hodnotu bez znaménka.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value: BigInteger

Hodnota, která se má převést na 32bitové celé číslo bez znaménka.

Návraty

UInt32

Objekt, který obsahuje hodnotu parametru value .

Atributy: CLSCompliantAttribute

Výjimky

OverflowException

value je menší než UInt32.MinValue nebo je větší než UInt32.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger UInt32 hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového UInt32 typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CUInt v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového UInt32 typu. Při úspěšném převodu nedojde ke ztrátě přesnosti ve výsledné UInt32 hodnotě.

Platí pro

Explicit(BigInteger to UInt16)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS: System.Int32

Definuje explicitní převod objektu BigInteger na 16bitovou celočíselnou hodnotu bez znaménka.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value: BigInteger

Hodnota, která se má převést na 16bitové celé číslo bez znaménka.

Návraty

UInt16

Objekt, který obsahuje hodnotu parametru value .

Atributy: CLSCompliantAttribute

Výjimky

OverflowException

value je menší než UInt16.MinValue nebo je větší než UInt16.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger UInt16 hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového UInt16 typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CUShort v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového UInt16 typu. Při úspěšném převodu nedojde ke ztrátě přesnosti ve výsledné UInt16 hodnotě.

Platí pro

Explicit(BigInteger to UInt128)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Explicitně převede velké celé číslo na UInt128 hodnotu.

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

Parametry

value: BigInteger

Hodnota, kterou chcete převést.

Návraty

UInt128

value převedeno na UInt128 hodnotu.

Atributy: CLSCompliantAttribute

Platí pro

Explicit(BigInteger to Single)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na hodnotu s plovoucí desetinou čárkou s jednou přesností.

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

Parametry

value: BigInteger

Hodnota, která se má převést na hodnotu s plovoucí desetinou čárkou s jednou přesností.

Návraty

Single

Objekt, který obsahuje nejbližší možnou reprezentaci parametru value .

Příklady

Následující příklad ukazuje převod na BigInteger Single hodnoty.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může zahrnovat ztrátu dat nebo ztrátu přesnosti. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CSng v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že BigInteger hodnota může být mimo rozsah datového Single typu, jedná se o zužující převod. Pokud je převod neúspěšný, nevyvolá chybu OverflowException. BigInteger Pokud je hodnota menší než Single.MinValue, výsledná Single hodnota je Single.NegativeInfinity. BigInteger Pokud je hodnota větší než Single.MaxValue, výsledná Single hodnota je Single.PositiveInfinity.

Převod na BigInteger Single může znamenat ztrátu přesnosti. V některých případech může ztráta přesnosti způsobit, že operace přetypování nebo převodu proběhne úspěšně, i když BigInteger je hodnota mimo rozsah datového Single typu. V následujícím příkladu je uvedena ukázka. Přiřadí maximální hodnotu Single proměnné dvěma BigInteger proměnným, zvýší jednu BigInteger proměnnou o 9,999e291 a otestuje obě proměnné z hlediska rovnosti. Podle očekávání volání BigInteger.Equals(BigInteger) metody ukazuje, že jsou nerovné. Převod větší BigInteger hodnoty zpět na Single hodnotu je však úspěšný, i když BigInteger hodnota teď přesahuje Single.MaxValuehodnotu .

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

Platí pro

Explicit(BigInteger to IntPtr)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Explicitně převede velké celé číslo na IntPtr hodnotu.

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

Parametry

value: BigInteger

Hodnota, kterou chcete převést.

Návraty

IntPtr

nativeint

value převedeno na IntPtr hodnotu.

Platí pro

Explicit(BigInteger to Int64)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na 64bitovou celočíselnou hodnotu.

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

Parametry

value: BigInteger

Hodnota, která se má převést na 64bitové celé číslo se signoumi sadou.

Návraty

Int64

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je menší než Int64.MinValue nebo je větší než Int64.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger Int64 hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového Int64 typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CLng v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového Int64 typu.

Platí pro

Explicit(BigInteger to Int16)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na 16bitovou celočíselnou hodnotu se signoumi sadou.

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

Parametry

value: BigInteger

Hodnota, která se má převést na 16bitové celé číslo se signedýmmm sadou.

Návraty

Int16

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je menší než Int16.MinValue nebo je větší než Int16.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger Int16 hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového Int16 typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CShort v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového Int16 typu. Při úspěšném převodu nedojde ke ztrátě přesnosti ve výsledné Int16 hodnotě.

Platí pro

Explicit(BigInteger to Int128)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Explicitně převede velké celé číslo na Int128 hodnotu.

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

Parametry

value: BigInteger

Hodnota, kterou chcete převést.

Návraty

Int128

value převedeno na Int128 hodnotu.

Platí pro

Explicit(BigInteger to Half)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Explicitně převede velké celé číslo na Half hodnotu.

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

Parametry

value: BigInteger

Hodnota, kterou chcete převést.

Návraty

Half

value převedeno na Half hodnotu.

Platí pro

Explicit(BigInteger to Double)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na Double hodnotu.

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

Parametry

value: BigInteger

Hodnota, která se má převést na Double.

Návraty

Double

Objekt, který obsahuje hodnotu parametru value .

Příklady

Následující příklad ukazuje převod na BigInteger Double hodnoty.

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

Poznámky

Vzhledem k tomu, že BigInteger hodnota může být mimo rozsah datového Double typu, jedná se o zužující převod. Pokud je převod neúspěšný, nevyvolá chybu OverflowException. BigInteger Pokud je hodnota menší než Double.MinValue, výsledná Double hodnota je Double.NegativeInfinity. BigInteger Pokud je hodnota větší než Double.MaxValue, výsledná Double hodnota je Double.PositiveInfinity.

Převod na BigInteger Double může znamenat ztrátu přesnosti. V některých případech může ztráta přesnosti způsobit, že operace přetypování nebo převodu proběhne úspěšně, i když BigInteger je hodnota mimo rozsah datového Double typu. V následujícím příkladu je uvedena ukázka. Přiřadí maximální hodnotu Double proměnné dvěma BigInteger proměnným, zvýší jednu BigInteger proměnnou o 9,999e291 a otestuje obě proměnné z hlediska rovnosti. Podle očekávání volání BigInteger.Equals(BigInteger) metody ukazuje, že jsou nerovné. Převod větší BigInteger hodnoty zpět na Double hodnotu je však úspěšný, i když BigInteger hodnota teď přesahuje Double.MaxValuehodnotu .

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

Platí pro

Explicit(BigInteger to Decimal)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na Decimal hodnotu.

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

Parametry

value: BigInteger

Hodnota, která se má převést na Decimal.

Návraty

Decimal

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je menší než Decimal.MinValue nebo větší než Decimal.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger Decimal hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového Decimal typu.

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

Poznámky

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového Decimal typu.

Platí pro

Explicit(BigInteger to Char)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Explicitně převede velké celé číslo na Char hodnotu.

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

Parametry

value: BigInteger

Hodnota, kterou chcete převést.

Návraty

Char

value převedeno na Char hodnotu.

Platí pro

Explicit(BigInteger to Byte)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na hodnotu bajtů bez znaménka.

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

Parametry

value: BigInteger

Hodnota, která se má převést na Byte.

Návraty

Byte

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je menší než Byte.MinValue nebo větší než Byte.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger Byte hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového Byte typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CByte v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového Byte typu. Při úspěšném převodu nedojde ke ztrátě přesnosti ve výsledné Byte hodnotě.

Platí pro

Explicit(Half to BigInteger)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Explicitně převede Half hodnotu na velké celé číslo.

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

Parametry

value: Half

Hodnota, kterou chcete převést.

Návraty

BigInteger

value převedeno na velké celé číslo.

Platí pro

Explicit(Double to BigInteger)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod Double hodnoty na BigInteger hodnotu.

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

Parametry

value: Double

Hodnota, která se má převést na BigInteger.

Návraty

BigInteger

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je NaN, PositiveInfinitynebo NegativeInfinity.

Příklady

Následující příklad převede jednotlivé prvky v poli Double hodnot na BigInteger objekty a zobrazí výsledek každého převodu. Všimněte si, že všechny zlomkové části Double hodnoty jsou během převodu zkráceny.

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

Poznámky

Libovolná zlomková část parametru se před převodem value zkrátí.

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Vzhledem k tomu, že převod z Double na BigInteger může zahrnovat zkrácení jakékoli zlomkové části value, kompilátory jazyka neprovádějí tento převod automaticky. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Pro jazyky, které nepodporují vlastní operátory, je BigInteger.BigInteger(Double)alternativní metoda .

Platí pro

Explicit(Decimal to BigInteger)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu Decimal na BigInteger hodnotu.

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

Parametry

value: Decimal

Hodnota, která se má převést na BigInteger.

Návraty

BigInteger

Objekt, který obsahuje hodnotu parametru value .

Příklady

Následující příklad převede jednotlivé prvky v poli Decimal hodnot na BigInteger objekty a zobrazí výsledek každého převodu. Všimněte si, že všechny zlomkové části Decimal hodnoty jsou během převodu zkráceny.

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

Poznámky

Libovolná zlomková část parametru se před převodem value zkrátí.

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Vzhledem k tomu, že převod z Decimal na BigInteger může zahrnovat zkrácení jakékoli zlomkové části value, kompilátory jazyka neprovádějí tento převod automaticky. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Pro jazyky, které nepodporují vlastní operátory, je BigInteger.BigInteger(Decimal)alternativní metoda .

Platí pro

Explicit(BigInteger to Int32)

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Zdroj:: BigInteger.cs

Definuje explicitní převod objektu BigInteger na 32bitovou celočíselnou hodnotu.

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

Parametry

value: BigInteger

Hodnota, která se má převést na 32bitové celé číslo se signoumi sadou.

Návraty

Int32

Objekt, který obsahuje hodnotu parametru value .

Výjimky

OverflowException

value je menší než Int32.MinValue nebo je větší než Int32.MaxValue.

Příklady

Následující příklad ukazuje převod na BigInteger Int32 hodnoty. Zpracovává také , OverflowException který je vyvolán, protože BigInteger hodnota je mimo rozsah datového Int32 typu.

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

Poznámky

Přetížení Explicit(Decimal to BigInteger) metody definují typy, na které nebo ze kterých BigInteger lze objekt převést. Kompilátory jazyka neprovádějí tento převod automaticky, protože může dojít ke ztrátě dat. Místo toho provedou převod pouze v případě, že je použit operátor přetypování (v jazyce C#) nebo funkce převodu (například CType nebo CInt v jazyce Visual Basic). V opačném případě se zobrazí chyba kompilátoru.

Vzhledem k tomu, že tato operace definuje zužující převod, může za běhu vyvolat výjimku OverflowException , pokud BigInteger je hodnota mimo rozsah datového Int32 typu. Při úspěšném převodu nedojde ke ztrátě přesnosti ve výsledné Int32 hodnotě.

Platí pro

Sdílet prostřednictvím

BigInteger.Explicit Operátor

Definice

Přetížení

Explicit(BigInteger to SByte)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(Single to BigInteger)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(Complex to BigInteger)

Parametry

Návraty

Platí pro

Explicit(BigInteger to UIntPtr)

Parametry

Návraty

Platí pro

Explicit(BigInteger to UInt64)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(BigInteger to UInt32)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(BigInteger to UInt16)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(BigInteger to UInt128)

Parametry

Návraty

Platí pro

Explicit(BigInteger to Single)

Parametry

Návraty

Příklady

Poznámky

Platí pro

Explicit(BigInteger to IntPtr)

Parametry

Návraty

Platí pro

Explicit(BigInteger to Int64)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(BigInteger to Int16)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Platí pro

Explicit(BigInteger to Int128)

Parametry

Návraty

Platí pro

Explicit(BigInteger to Half)