BigInteger.Explicit Operator

Referensi

Definisi

Ruang nama:: System.Numerics

Rakitan:: System.Runtime.Numerics.dll

Rakitan:: System.Numerics.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Menentukan konversi eksplisit antara BigInteger objek dan jenis lain.

Overload

Explicit(BigInteger to SByte)	Menentukan konversi BigInteger eksplisit objek ke nilai 8-bit yang ditandatangani. API ini bukan kompatibel CLS. Alternatif yang sesuai adalah Int16.
Explicit(Single to BigInteger)	Menentukan konversi eksplisit nilai Single menjadi BigInteger nilai.
Explicit(Complex to BigInteger)	Secara eksplisit mengonversi nilai menjadi Complex bilangan bulat besar.
Explicit(BigInteger to UIntPtr)	Secara eksplisit mengonversi bilangan bulat besar menjadi UIntPtr nilai.
Explicit(BigInteger to UInt64)	Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat 64-bit yang tidak ditandatangani. API ini bukan kompatibel CLS. Alternatif yang sesuai adalah Double.
Explicit(BigInteger to UInt32)	Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat 32-bit yang tidak ditandatangani. API ini bukan kompatibel CLS. Alternatif yang sesuai adalah Int64.
Explicit(BigInteger to UInt16)	Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat 16-bit yang tidak ditandatangani. API ini bukan kompatibel CLS. Alternatif yang sesuai adalah Int32.
Explicit(BigInteger to UInt128)	Secara eksplisit mengonversi bilangan bulat besar menjadi UInt128 nilai.
Explicit(BigInteger to Single)	Menentukan konversi BigInteger eksplisit objek ke nilai floating-point presisi tunggal.
Explicit(BigInteger to IntPtr)	Secara eksplisit mengonversi bilangan bulat besar menjadi IntPtr nilai.
Explicit(BigInteger to Int64)	Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat bertanda tangan 64-bit.
Explicit(BigInteger to Int16)	Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat bertanda tangan 16-bit.
Explicit(BigInteger to Int128)	Secara eksplisit mengonversi bilangan bulat besar menjadi Int128 nilai.
Explicit(BigInteger to Half)	Secara eksplisit mengonversi bilangan bulat besar menjadi Half nilai.
Explicit(BigInteger to Double)	Menentukan konversi BigInteger eksplisit objek ke Double nilai.
Explicit(BigInteger to Decimal)	Menentukan konversi BigInteger eksplisit objek ke Decimal nilai.
Explicit(BigInteger to Char)	Secara eksplisit mengonversi bilangan bulat besar menjadi Char nilai.
Explicit(BigInteger to Byte)	Menentukan konversi BigInteger eksplisit objek ke nilai byte yang tidak ditandatangani.
Explicit(Half to BigInteger)	Secara eksplisit mengonversi nilai menjadi Half bilangan bulat besar.
Explicit(Double to BigInteger)	Menentukan konversi eksplisit nilai Double menjadi BigInteger nilai.
Explicit(Decimal to BigInteger)	Menentukan konversi Decimal eksplisit objek ke BigInteger nilai.
Explicit(BigInteger to Int32)	Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat bertanda tangan 32-bit.

Explicit(BigInteger to SByte)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS: System.Int16

Menentukan konversi BigInteger eksplisit objek ke nilai 8-bit yang ditandatangani.

API ini bukan kompatibel CLS. Alternatif yang sesuai adalah 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

Nilai yang akan dikonversi ke nilai 8-bit yang ditandatangani.

Mengembalikan

SByte

Objek yang berisi nilai value parameter .

Atribut: CLSCompliantAttribute

Pengecualian

OverflowException

value kurang dari SByte.MinValue atau lebih besar dari SByte.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke SByte nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang SByte jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CSByte di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang SByte jenis data. Tidak ada kehilangan presisi dalam nilai yang dihasilkan SByte jika konversi berhasil.

Berlaku untuk

Explicit(Single to BigInteger)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi eksplisit nilai Single menjadi BigInteger nilai.

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

Nilai yang akan dikonversi menjadi BigInteger.

Mengembalikan

BigInteger

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value adalah NaN, PositiveInfinity, atau NegativeInfinity.

Contoh

Contoh berikut mengonversi elemen individual dalam array Single nilai menjadi BigInteger objek, lalu menampilkan hasil setiap konversi. Perhatikan bahwa setiap bagian pecahan dari Single nilai dipotok selama konversi.

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

Keterangan

Setiap bagian pecahan dari value parameter dipotok sebelum konversi.

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Karena konversi dari Single ke BigInteger dapat melibatkan pemotokan bagian pecahan apa pun dari value, pengkompilasi bahasa tidak melakukan konversi ini secara otomatis. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Untuk bahasa yang tidak mendukung operator kustom, metode alternatifnya adalah BigInteger.BigInteger(Single).

Berlaku untuk

Explicit(Complex to BigInteger)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Secara eksplisit mengonversi nilai menjadi Complex bilangan bulat besar.

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

Nilai yang akan dikonversi.

Mengembalikan

BigInteger

value dikonversi menjadi bilangan bulat besar.

Berlaku untuk

Explicit(BigInteger to UIntPtr)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Secara eksplisit mengonversi bilangan bulat besar menjadi UIntPtr nilai.

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

Nilai yang akan dikonversi.

Mengembalikan

UIntPtr

unativeint

value dikonversi ke UIntPtr nilai.

Atribut: CLSCompliantAttribute

Berlaku untuk

Explicit(BigInteger to UInt64)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS: System.Double

Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat 64-bit yang tidak ditandatangani.

API ini bukan kompatibel CLS. Alternatif yang sesuai adalah 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

Nilai yang akan dikonversi ke bilangan bulat 64-bit yang tidak ditandatangani.

Mengembalikan

UInt64

Objek yang berisi nilai value parameter .

Atribut: CLSCompliantAttribute

Pengecualian

OverflowException

value kurang dari UInt64.MinValue atau lebih besar dari UInt64.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke UInt64 nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang UInt64 jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CULng di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang UInt64 jenis data. Tidak ada hilangnya presisi dalam nilai yang UInt64 dihasilkan jika konversi berhasil.

Berlaku untuk

Explicit(BigInteger to UInt32)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS: System.Int64

Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat 32-bit yang tidak ditandatangani.

API ini bukan kompatibel CLS. Alternatif yang sesuai adalah 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

Nilai yang akan dikonversi menjadi bilangan bulat 32-bit yang tidak ditandatangani.

Mengembalikan

UInt32

Objek yang berisi nilai value parameter .

Atribut: CLSCompliantAttribute

Pengecualian

OverflowException

value kurang dari UInt32.MinValue atau lebih besar dari UInt32.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke UInt32 nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang UInt32 jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CUInt di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang UInt32 jenis data. Tidak ada hilangnya presisi dalam nilai yang UInt32 dihasilkan jika konversi berhasil.

Berlaku untuk

Explicit(BigInteger to UInt16)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS: System.Int32

Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat 16-bit yang tidak ditandatangani.

API ini bukan kompatibel CLS. Alternatif yang sesuai adalah 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

Nilai yang akan dikonversi ke bilangan bulat 16-bit yang tidak ditandatangani.

Mengembalikan

UInt16

Objek yang berisi nilai value parameter .

Atribut: CLSCompliantAttribute

Pengecualian

OverflowException

value kurang dari UInt16.MinValue atau lebih besar dari UInt16.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke UInt16 nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang UInt16 jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CUShort di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang UInt16 jenis data. Tidak ada hilangnya presisi dalam nilai yang UInt16 dihasilkan jika konversi berhasil.

Berlaku untuk

Explicit(BigInteger to UInt128)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Secara eksplisit mengonversi bilangan bulat besar menjadi UInt128 nilai.

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

Nilai yang akan dikonversi.

Mengembalikan

UInt128

value dikonversi ke UInt128 nilai.

Atribut: CLSCompliantAttribute

Berlaku untuk

Explicit(BigInteger to Single)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke nilai floating-point presisi tunggal.

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

Nilai yang akan dikonversi menjadi nilai floating-point presisi tunggal.

Mengembalikan

Single

Objek yang berisi representasi parameter terdekat yang value mungkin.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Single nilai.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data atau hilangnya presisi. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CSng di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

BigInteger Karena nilainya dapat berada di luar rentang Single jenis data, operasi ini adalah konversi yang mempersempit. Jika konversi tidak berhasil, konversi tidak melemparkan OverflowException. Sebaliknya, jika BigInteger nilainya kurang dari Single.MinValue, nilai yang Single dihasilkan adalah Single.NegativeInfinity. Jika nilainya BigInteger lebih besar dari Single.MaxValue, nilai yang Single dihasilkan adalah Single.PositiveInfinity.

Konversi BigInteger ke Single suatu mungkin melibatkan hilangnya presisi. Dalam beberapa kasus, hilangnya presisi dapat menyebabkan operasi transmisi atau konversi berhasil bahkan jika BigInteger nilai berada di luar rentang Single jenis data. Contoh berikut memberikan ilustrasi. Ini menetapkan nilai maksimum dari hingga Single dua BigInteger variabel, menambah satu BigInteger variabel sebesar 9,999e291, dan menguji dua variabel untuk kesetaraan. Seperti yang diharapkan, panggilan ke BigInteger.Equals(BigInteger) metode menunjukkan bahwa mereka tidak sama. Namun, konversi nilai yang lebih besar BigInteger kembali ke berhasil Single , meskipun BigInteger nilainya sekarang melebihi 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

Berlaku untuk

Explicit(BigInteger to IntPtr)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Secara eksplisit mengonversi bilangan bulat besar menjadi IntPtr nilai.

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

Nilai yang akan dikonversi.

Mengembalikan

IntPtr

nativeint

value dikonversi ke IntPtr nilai.

Berlaku untuk

Explicit(BigInteger to Int64)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat bertanda 64-bit.

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

Nilai yang akan dikonversi menjadi bilangan bulat bertanda tangan 64-bit.

Mengembalikan

Int64

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value kurang dari Int64.MinValue atau lebih besar dari Int64.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Int64 nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang Int64 jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CLng di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang Int64 jenis data.

Berlaku untuk

Explicit(BigInteger to Int16)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat bertanda 16-bit.

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

Nilai yang akan dikonversi menjadi bilangan bulat bertanda tangan 16-bit.

Mengembalikan

Int16

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value kurang dari Int16.MinValue atau lebih besar dari Int16.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Int16 nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang Int16 jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CShort di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang Int16 jenis data. Tidak ada hilangnya presisi dalam nilai yang Int16 dihasilkan jika konversi berhasil.

Berlaku untuk

Explicit(BigInteger to Int128)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Secara eksplisit mengonversi bilangan bulat besar menjadi Int128 nilai.

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

Nilai yang akan dikonversi.

Mengembalikan

Int128

value dikonversi ke Int128 nilai.

Berlaku untuk

Explicit(BigInteger to Half)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Secara eksplisit mengonversi bilangan bulat besar menjadi Half nilai.

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

Nilai yang akan dikonversi.

Mengembalikan

Half

value dikonversi ke Half nilai.

Berlaku untuk

Explicit(BigInteger to Double)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke Double nilai.

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

Nilai yang akan dikonversi menjadi Double.

Mengembalikan

Double

Objek yang berisi nilai value parameter .

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Double nilai.

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

Keterangan

BigInteger Karena nilainya dapat berada di luar rentang Double jenis data, operasi ini adalah konversi yang mempersempit. Jika konversi tidak berhasil, konversi tidak melemparkan OverflowException. Sebaliknya, jika BigInteger nilainya kurang dari Double.MinValue, nilai yang Double dihasilkan adalah Double.NegativeInfinity. Jika nilainya BigInteger lebih besar dari Double.MaxValue, nilai yang Double dihasilkan adalah Double.PositiveInfinity.

Konversi BigInteger ke Double suatu mungkin melibatkan hilangnya presisi. Dalam beberapa kasus, hilangnya presisi dapat menyebabkan operasi transmisi atau konversi berhasil bahkan jika BigInteger nilai berada di luar rentang Double jenis data. Contoh berikut memberikan ilustrasi. Ini menetapkan nilai maksimum dari hingga Double dua BigInteger variabel, menambah satu BigInteger variabel sebesar 9,999e291, dan menguji dua variabel untuk kesetaraan. Seperti yang diharapkan, panggilan ke BigInteger.Equals(BigInteger) metode menunjukkan bahwa mereka tidak sama. Namun, konversi nilai yang lebih besar BigInteger kembali ke berhasil Double , meskipun BigInteger nilainya sekarang melebihi 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

Berlaku untuk

Explicit(BigInteger to Decimal)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke Decimal nilai.

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

Nilai yang akan dikonversi menjadi Decimal.

Mengembalikan

Decimal

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value kurang dari Decimal.MinValue atau lebih besar dari Decimal.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Decimal nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang Decimal jenis data.

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

Keterangan

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang Decimal jenis data.

Berlaku untuk

Explicit(BigInteger to Char)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Secara eksplisit mengonversi bilangan bulat besar menjadi Char nilai.

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

Nilai yang akan dikonversi.

Mengembalikan

Char

value dikonversi ke Char nilai.

Berlaku untuk

Explicit(BigInteger to Byte)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke nilai byte yang tidak ditandatangani.

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

Nilai yang akan dikonversi menjadi Byte.

Mengembalikan

Byte

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value kurang dari Byte.MinValue atau lebih besar dari Byte.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Byte nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang Byte jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CByte di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang Byte jenis data. Tidak ada hilangnya presisi dalam nilai yang Byte dihasilkan jika konversi berhasil.

Berlaku untuk

Explicit(Half to BigInteger)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Secara eksplisit mengonversi nilai menjadi Half bilangan bulat besar.

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

Nilai yang akan dikonversi.

Mengembalikan

BigInteger

value dikonversi menjadi bilangan bulat besar.

Berlaku untuk

Explicit(Double to BigInteger)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi eksplisit dari Double nilai menjadi BigInteger nilai.

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

Nilai yang akan dikonversi menjadi BigInteger.

Mengembalikan

BigInteger

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value adalah NaN, PositiveInfinity, atau NegativeInfinity.

Contoh

Contoh berikut mengonversi elemen individual dalam array Double nilai menjadi BigInteger objek, lalu menampilkan hasil setiap konversi. Perhatikan bahwa setiap bagian pecahan dari Double nilai dipotong selama konversi.

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

Keterangan

Setiap bagian pecahan dari value parameter dipotong sebelum konversi.

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Karena konversi dari Double ke BigInteger dapat melibatkan pemotongan bagian pecahan valuedari , pengkompilasi bahasa tidak melakukan konversi ini secara otomatis. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Untuk bahasa yang tidak mendukung operator kustom, metode alternatifnya adalah BigInteger.BigInteger(Double).

Berlaku untuk

Explicit(Decimal to BigInteger)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi Decimal eksplisit objek ke BigInteger nilai.

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

Nilai yang akan dikonversi menjadi BigInteger.

Mengembalikan

BigInteger

Objek yang berisi nilai value parameter .

Contoh

Contoh berikut mengonversi elemen individual dalam array Decimal nilai menjadi BigInteger objek, lalu menampilkan hasil setiap konversi. Perhatikan bahwa setiap bagian pecahan dari Decimal nilai dipotong selama konversi.

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

Keterangan

Setiap bagian pecahan dari value parameter dipotong sebelum konversi.

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Karena konversi dari Decimal ke BigInteger dapat melibatkan pemotongan bagian pecahan valuedari , pengkompilasi bahasa tidak melakukan konversi ini secara otomatis. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Untuk bahasa yang tidak mendukung operator kustom, metode alternatifnya adalah BigInteger.BigInteger(Decimal).

Berlaku untuk

Explicit(BigInteger to Int32)

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Sumber:: BigInteger.cs

Menentukan konversi BigInteger eksplisit objek ke nilai bilangan bulat bertanda 32-bit.

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

Nilai yang akan dikonversi menjadi bilangan bulat bertanda tangan 32-bit.

Mengembalikan

Int32

Objek yang berisi nilai value parameter .

Pengecualian

OverflowException

value kurang dari Int32.MinValue atau lebih besar dari Int32.MaxValue.

Contoh

Contoh berikut mengilustrasikan konversi BigInteger ke Int32 nilai. Ini juga menangani OverflowException yang dilemparkan karena BigInteger nilainya berada di luar rentang Int32 jenis data.

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

Keterangan

Kelebihan beban Explicit(Decimal to BigInteger) metode menentukan jenis tempat atau dari mana BigInteger objek dapat dikonversi. Pengkompilasi bahasa tidak melakukan konversi ini secara otomatis karena dapat melibatkan kehilangan data. Sebaliknya, mereka melakukan konversi hanya jika operator transmisi (dalam C#) atau fungsi konversi (seperti CType atau CInt di Visual Basic) digunakan. Jika tidak, mereka menampilkan kesalahan pengkompilasi.

Karena operasi ini mendefinisikan konversi yang mempersempit, operasi ini dapat melemparkan OverflowException pada durasi jika BigInteger nilai berada di luar rentang Int32 jenis data. Tidak ada hilangnya presisi dalam nilai yang Int32 dihasilkan jika konversi berhasil.

Berlaku untuk

Bagikan melalui

BigInteger.Explicit Operator

Definisi

Overload

Explicit(BigInteger to SByte)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(Single to BigInteger)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(Complex to BigInteger)

Parameter

Mengembalikan

Berlaku untuk

Explicit(BigInteger to UIntPtr)

Parameter

Mengembalikan

Berlaku untuk

Explicit(BigInteger to UInt64)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(BigInteger to UInt32)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(BigInteger to UInt16)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(BigInteger to UInt128)

Parameter

Mengembalikan

Berlaku untuk

Explicit(BigInteger to Single)

Parameter

Mengembalikan

Contoh

Keterangan

Berlaku untuk

Explicit(BigInteger to IntPtr)

Parameter

Mengembalikan

Berlaku untuk

Explicit(BigInteger to Int64)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(BigInteger to Int16)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Berlaku untuk

Explicit(BigInteger to Int128)

Parameter

Mengembalikan

Berlaku untuk

Explicit(BigInteger to Half)