Aracılığıyla paylaş

BigInteger.Explicit Operatör

  • Başvuru

Tanım

Ad Alanı:
System.Numerics
Bütünleştirilmiş Kod:
System.Runtime.Numerics.dll
Bütünleştirilmiş Kod:
System.Numerics.dll
Bütünleştirilmiş Kod:
netstandard.dll

Bir nesne ile başka bir tür arasında açık bir BigInteger dönüştürme tanımlar.

Aşırı Yüklemeler

Explicit(BigInteger to SByte)

Bir nesnenin BigInteger imzalı 8 bit değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Int16.
Explicit(Single to BigInteger)

Bir değerin değere açık bir SingleBigInteger dönüştürmesini tanımlar.
Explicit(Complex to BigInteger)

Bir değeri açıkça büyük bir tamsayıya dönüştürür Complex .
Explicit(BigInteger to UIntPtr)

Büyük bir tamsayıyı açıkça bir UIntPtr değere dönüştürür.
Explicit(BigInteger to UInt64)

Bir BigInteger nesnenin işaretsiz 64 bit tamsayı değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Double.
Explicit(BigInteger to UInt32)

Bir BigInteger nesnenin işaretsiz 32 bit tamsayı değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Int64.
Explicit(BigInteger to UInt16)

Bir BigInteger nesnenin işaretsiz 16 bit tamsayı değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Int32.
Explicit(BigInteger to UInt128)

Büyük bir tamsayıyı açıkça bir UInt128 değere dönüştürür.
Explicit(BigInteger to Single)

Bir BigInteger nesnenin tek duyarlıklı kayan nokta değerine açık bir dönüştürmesini tanımlar.
Explicit(BigInteger to IntPtr)

Büyük bir tamsayıyı açıkça bir IntPtr değere dönüştürür.
Explicit(BigInteger to Int64)

Bir BigInteger nesnenin 64 bit imzalı tamsayı değerine açık bir dönüştürmesini tanımlar.
Explicit(BigInteger to Int16)

Bir BigInteger nesnenin 16 bit imzalı tamsayı değerine açık bir dönüştürmesini tanımlar.
Explicit(BigInteger to Int128)

Büyük bir tamsayıyı açıkça bir Int128 değere dönüştürür.
Explicit(BigInteger to Half)

Büyük bir tamsayıyı açıkça bir Half değere dönüştürür.
Explicit(BigInteger to Double)

Nesnenin BigInteger bir değere açık dönüştürmesini Double tanımlar.
Explicit(BigInteger to Decimal)

Nesnenin BigInteger bir değere açık dönüştürmesini Decimal tanımlar.
Explicit(BigInteger to Char)

Büyük bir tamsayıyı açıkça bir Char değere dönüştürür.
Explicit(BigInteger to Byte)

Bir BigInteger nesnenin işaretsiz bayt değerine açık bir dönüştürmesini tanımlar.
Explicit(Half to BigInteger)

Bir değeri açıkça büyük bir tamsayıya dönüştürür Half .
Explicit(Double to BigInteger)

Bir değerin değere açık bir DoubleBigInteger dönüştürmesini tanımlar.
Explicit(Decimal to BigInteger)

Nesnenin Decimal bir değere açık dönüştürmesini BigInteger tanımlar.
Explicit(BigInteger to Int32)

Bir BigInteger nesnenin 32 bit imzalı tamsayı değerine açık bir dönüştürmesini tanımlar.

Explicit(BigInteger to SByte)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

CLS uyumlu alternatif
System.Int16

Bir nesnenin BigInteger imzalı 8 bit değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir 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

Parametreler

value
BigInteger

İmzalı 8 bit değere dönüştürülecek değer.

Döndürülenler

SByte

parametresinin value değerini içeren bir nesne.

Öznitelikler
CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MinValue değerinden küçük veya SByte.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerSByte gösterilmektedir. Ayrıca, değer veri türü aralığının SByte dışında olduğundan BigInteger oluşan bir OverflowException işlemi de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCSByte ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerSByte dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta SByte elde edilen değerde duyarlık kaybı olmaz.

Şunlara uygulanır

Explicit(Single to BigInteger)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir değerin değere açık bir SingleBigInteger dönüştürmesini tanımlar.

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

Parametreler

value
Single

dönüştürülecek BigIntegerdeğer.

Döndürülenler

BigInteger

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value, PositiveInfinityveya NegativeInfinityşeklindedirNaN.

Örnekler

Aşağıdaki örnek, bir değer dizisindeki Single tek tek öğeleri nesnelere BigInteger dönüştürür ve sonra her dönüştürmenin sonucunu görüntüler. Dönüştürme sırasında değerin kesirli bölümlerinin Single kesildiğini unutmayın.

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

Açıklamalar

Parametrenin value herhangi bir kesirli bölümü dönüştürmeden önce kesilir.

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. dönüştürme işleminin SingleBigInteger kesirli bir kısmının valuekesilmesini içerebileceğinden, dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (Visual Basic'te olduğu gibi CType ) kullanılırsa gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Özel işleçleri desteklemeyen diller için alternatif yöntem şeklindedir BigInteger.BigInteger(Single).

Şunlara uygulanır

Explicit(Complex to BigInteger)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir değeri açıkça büyük bir tamsayıya dönüştürür Complex .

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

Parametreler

value
Complex

Dönüştürülecek değer.

Döndürülenler

BigInteger

value büyük bir tamsayıya dönüştürülür.

Şunlara uygulanır

Explicit(BigInteger to UIntPtr)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

Büyük bir tamsayıyı açıkça bir UIntPtr değere dönüştürür.

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

Parametreler

value
BigInteger

Dönüştürülecek değer.

Döndürülenler

UIntPtr

unativeint

value değere UIntPtr dönüştürülür.

Öznitelikler
CLSCompliantAttribute

Şunlara uygulanır

Explicit(BigInteger to UInt64)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

CLS uyumlu alternatif
System.Double

Bir BigInteger nesnenin işaretsiz 64 bit tamsayı değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir 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

Parametreler

value
BigInteger

İşaretsiz bir 64 bit tamsayıya dönüştürülecek değer.

Döndürülenler

UInt64

parametresinin value değerini içeren bir nesne.

Öznitelikler
CLSCompliantAttribute

Özel durumlar

OverflowException

value UInt64.MinValue değerinden küçük veya UInt64.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerUInt64 gösterilmektedir. Ayrıca, değer veri türü aralığının UInt64 dışında olduğundan BigInteger oluşan bir OverflowException işlemi de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCULng ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerUInt64 dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta UInt64 elde edilen değerde duyarlık kaybı olmaz.

Şunlara uygulanır

Explicit(BigInteger to UInt32)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

CLS uyumlu alternatif
System.Int64

Bir BigInteger nesnenin işaretsiz 32 bit tamsayı değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir 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

Parametreler

value
BigInteger

İşaretsiz bir 32 bit tamsayıya dönüştürülecek değer.

Döndürülenler

UInt32

parametresinin value değerini içeren bir nesne.

Öznitelikler
CLSCompliantAttribute

Özel durumlar

OverflowException

value UInt32.MinValue değerinden küçük veya UInt32.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerUInt32 gösterilmektedir. Ayrıca, değer veri türü aralığının UInt32 dışında olduğundan BigInteger oluşan bir OverflowException işlemi de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCUInt ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerUInt32 dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta UInt32 elde edilen değerde duyarlık kaybı olmaz.

Şunlara uygulanır

Explicit(BigInteger to UInt16)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

CLS uyumlu alternatif
System.Int32

Bir BigInteger nesnenin işaretsiz 16 bit tamsayı değerine açık bir dönüştürmesini tanımlar.

Bu API, CLS uyumlu değildir. Uyumlu alternatiftir 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

Parametreler

value
BigInteger

İşaretsiz bir 16 bit tamsayıya dönüştürülecek değer.

Döndürülenler

UInt16

parametresinin value değerini içeren bir nesne.

Öznitelikler
CLSCompliantAttribute

Özel durumlar

OverflowException

value UInt16.MinValue değerinden küçük veya UInt16.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerUInt16 gösterilmektedir. Ayrıca, değer veri türü aralığının UInt16 dışında olduğundan BigInteger oluşan bir OverflowException işlemi de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCUShort ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerUInt16 dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta UInt16 elde edilen değerde duyarlık kaybı olmaz.

Şunlara uygulanır

Explicit(BigInteger to UInt128)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Önemli

Bu API, CLS uyumlu değildir.

Büyük bir tamsayıyı açıkça bir UInt128 değere dönüştürür.

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

Parametreler

value
BigInteger

Dönüştürülecek değer.

Döndürülenler

UInt128

value değere UInt128 dönüştürülür.

Öznitelikler
CLSCompliantAttribute

Şunlara uygulanır

Explicit(BigInteger to Single)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir BigInteger nesnenin tek duyarlıklı kayan nokta değerine açık bir dönüştürmesini tanımlar.

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

Parametreler

value
BigInteger

Tek duyarlıklı kayan nokta değerine dönüştürülecek değer.

Döndürülenler

Single

Parametresinin mümkün olan en yakın gösterimini value içeren bir nesne.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerSingle gösterilmektedir.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı veya duyarlık kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCSng ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

BigInteger Değer veri türü aralığının dışında olabileceğindenSingle, bu işlem bir daraltma dönüştürme işlemidir. Dönüştürme başarısız olursa, oluşturmaz OverflowException. Bunun yerine, değer değerinden BigIntegerSingle.MinValueküçükse, sonuçta elde edilen Single değer olur Single.NegativeInfinity. Değer değerinden BigIntegerSingle.MaxValuebüyükse, sonuçta elde edilen Single değer olur Single.PositiveInfinity.

bir'in BigInteger bir'e Single dönüştürülmesi duyarlık kaybı içerebilir. Bazı durumlarda duyarlık kaybı, değer veri türü aralığının dışında olsa BigInteger bile atama veya dönüştürme işleminin Single başarılı olmasına neden olabilir. Aşağıdaki örnek, bir gösterim sağlar. en yüksek değerini Single iki BigInteger değişkene atar, bir BigInteger değişkeni 9,999e291 artırır ve iki değişkeni eşitlik için test eder. Beklendiği gibi yöntemine yapılan BigInteger.Equals(BigInteger) çağrı, bunların eşit olmadığını gösterir. Ancak, daha büyük BigInteger değerin değerine geri dönüştürülmesi Single başarılı olur, ancak BigInteger değer artık değerini aşıyor 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

Şunlara uygulanır

Explicit(BigInteger to IntPtr)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Büyük bir tamsayıyı açıkça bir IntPtr değere dönüştürür.

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

Parametreler

value
BigInteger

Dönüştürülecek değer.

Döndürülenler

IntPtr

nativeint

value değere IntPtr dönüştürülür.

Şunlara uygulanır

Explicit(BigInteger to Int64)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir BigInteger nesnenin 64 bit imzalı tamsayı değerine açık bir dönüştürmesini tanımlar.

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

Parametreler

value
BigInteger

64 bit imzalı tamsayıya dönüştürülecek değer.

Döndürülenler

Int64

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value Int64.MinValue değerinden küçük veya Int64.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerInt64 gösterilmektedir. Ayrıca, değer veri türü aralığının Int64 dışında olduğundan BigInteger oluşan bir OverflowException işlemi de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCLng ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerInt64 dışındaysa çalışma zamanında bir OverflowException oluşturabilir.

Şunlara uygulanır

Explicit(BigInteger to Int16)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir BigInteger nesnenin 16 bit imzalı tamsayı değerine açık bir dönüştürmesini tanımlar.

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

Parametreler

value
BigInteger

16 bit imzalı tamsayıya dönüştürülecek değer.

Döndürülenler

Int16

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value Int16.MinValue değerinden küçük veya Int16.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerInt16 gösterilmektedir. Ayrıca, değer veri türü aralığının Int16 dışında olduğundan BigInteger oluşan bir OverflowException işlemi de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCShort ) kullanıldığında gerçekleştirir. Aksi takdirde, bir derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerInt16 dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta Int16 elde edilen değerde duyarlık kaybı olmaz.

Şunlara uygulanır

Explicit(BigInteger to Int128)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Büyük bir tamsayıyı açıkça bir Int128 değere dönüştürür.

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

Parametreler

value
BigInteger

Dönüştürülecek değer.

Döndürülenler

Int128

value değere Int128 dönüştürülür.

Şunlara uygulanır

Explicit(BigInteger to Half)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Büyük bir tamsayıyı açıkça bir Half değere dönüştürür.

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

Parametreler

value
BigInteger

Dönüştürülecek değer.

Döndürülenler

Half

value değere Half dönüştürülür.

Şunlara uygulanır

Explicit(BigInteger to Double)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Nesnenin BigInteger bir değere açık dönüştürmesini Double tanımlar.

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

Parametreler

value
BigInteger

dönüştürülecek Doubledeğer.

Döndürülenler

Double

parametresinin value değerini içeren bir nesne.

Örnekler

Aşağıdaki örnekte değerlerin dönüştürülmesi BigIntegerDouble gösterilmektedir.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCDbl ) kullanıldığında gerçekleştirir.

BigInteger Değer veri türü aralığının dışında olabileceğindenDouble, bu işlem bir daraltma dönüştürme işlemidir. Dönüştürme başarısız olursa, oluşturmaz OverflowException. Bunun yerine, değer değerinden BigIntegerDouble.MinValueküçükse, sonuçta elde edilen Double değer olur Double.NegativeInfinity. Değer değerinden BigIntegerDouble.MaxValuebüyükse, sonuçta elde edilen Double değer olur Double.PositiveInfinity.

bir'in BigInteger bir'e Double dönüştürülmesi duyarlık kaybı içerebilir. Bazı durumlarda, değer veri türü aralığının dışında olsa BigInteger bile duyarlık kaybı atama veya dönüştürme işleminin Double başarılı olmasına neden olabilir. Aşağıdaki örnek, bir gösterim sağlar. bir en yüksek değerini Double iki BigInteger değişkene atar, bir BigInteger değişkeni 9,999e291 artırır ve iki değişkeni eşitlik için test eder. Beklendiği gibi yöntemine yapılan BigInteger.Equals(BigInteger) çağrı, bunların eşit olmadığını gösterir. Ancak, daha büyük BigInteger değerin değerine geri dönüştürülmesi Double başarılı olur, ancak BigInteger değer artık değerini aşıyor 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

Şunlara uygulanır

Explicit(BigInteger to Decimal)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Nesnenin BigInteger bir değere açık dönüştürmesini Decimal tanımlar.

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

Parametreler

value
BigInteger

dönüştürülecek Decimaldeğer.

Döndürülenler

Decimal

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value Decimal.MinValue değerinden küçük veya Decimal.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte, değerinin değerlere dönüştürülmesi BigIntegerDecimal gösterilmektedir. Değer veri türü aralığının Decimal dışında olduğundan oluşan BigInteger bir OverflowException de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCDec ) kullanıldığında gerçekleştirir.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerDecimal dışındaysa çalışma zamanında bir OverflowException oluşturabilir.

Şunlara uygulanır

Explicit(BigInteger to Char)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Büyük bir tamsayıyı açıkça bir Char değere dönüştürür.

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

Parametreler

value
BigInteger

Dönüştürülecek değer.

Döndürülenler

Char

value Char değerine dönüştürülür.

Şunlara uygulanır

Explicit(BigInteger to Byte)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir BigInteger nesnenin işaretsiz bayt değerine açık bir dönüştürmesini tanımlar.

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

Parametreler

value
BigInteger

dönüştürülecek Bytedeğer.

Döndürülenler

Byte

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value , Byte.MinValue değerinden küçük veya Byte.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte, değerinin değerlere dönüştürülmesi BigIntegerByte gösterilmektedir. Değer veri türü aralığının Byte dışında olduğundan oluşan BigInteger bir OverflowException de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCByte ) kullanıldığında gerçekleştirir. Aksi takdirde, derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerByte dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta elde edilen Byte değerde duyarlık kaybı olmaz.

Şunlara uygulanır

Explicit(Half to BigInteger)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir Half değeri açıkça büyük bir tamsayıya dönüştürür.

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

Parametreler

value
Half

Dönüştürülecek değer.

Döndürülenler

BigInteger

value büyük bir tamsayıya dönüştürülür.

Şunlara uygulanır

Explicit(Double to BigInteger)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir değerin Double bir değere açık dönüştürmesini BigInteger tanımlar.

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

Parametreler

value
Double

dönüştürülecek BigIntegerdeğer.

Döndürülenler

BigInteger

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value, PositiveInfinityveya NegativeInfinityşeklindedirNaN.

Örnekler

Aşağıdaki örnek, bir değer dizisindeki Double tek tek öğeleri nesnelere BigInteger dönüştürür ve sonra her dönüştürmenin sonucunu görüntüler. Dönüştürme sırasında bir değerin kesirli bölümlerinin Double kesildiğini unutmayın.

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

Açıklamalar

Parametrenin value herhangi bir kesirli bölümü dönüştürmeden önce kesilir.

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. dönüştürme işleminin DoubleBigInteger kesirli bir kısmının valuekesilmesini içerebileceğinden, dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'de) veya bir dönüştürme işlevi (Visual Basic'te olduğu gibi CType ) kullanılıyorsa gerçekleştirirler. Aksi takdirde, derleyici hatası görüntüler.

Özel işleçleri desteklemeyen diller için alternatif yöntemdir BigInteger.BigInteger(Double).

Şunlara uygulanır

Explicit(Decimal to BigInteger)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Nesnenin Decimal bir değere açık dönüştürmesini BigInteger tanımlar.

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

Parametreler

value
Decimal

dönüştürülecek BigIntegerdeğer.

Döndürülenler

BigInteger

parametresinin value değerini içeren bir nesne.

Örnekler

Aşağıdaki örnek, bir değer dizisindeki Decimal tek tek öğeleri nesnelere BigInteger dönüştürür ve sonra her dönüştürmenin sonucunu görüntüler. Dönüştürme sırasında bir değerin kesirli bölümlerinin Decimal kesildiğini unutmayın.

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

Açıklamalar

Parametrenin value herhangi bir kesirli bölümü dönüştürmeden önce kesilir.

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. dönüştürme işleminin DecimalBigInteger kesirli bir kısmının valuekesilmesini içerebileceğinden, dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'de) veya bir dönüştürme işlevi (Visual Basic'te olduğu gibi CType ) kullanılıyorsa gerçekleştirirler. Aksi takdirde, derleyici hatası görüntüler.

Özel işleçleri desteklemeyen diller için alternatif yöntemdir BigInteger.BigInteger(Decimal).

Şunlara uygulanır

Explicit(BigInteger to Int32)

Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs
Kaynak:
BigInteger.cs

Bir BigInteger nesnenin 32 bit imzalı tamsayı değerine açık dönüştürmesini tanımlar.

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

Parametreler

value
BigInteger

32 bit işaretli tamsayıya dönüştürülecek değer.

Döndürülenler

Int32

parametresinin value değerini içeren bir nesne.

Özel durumlar

OverflowException

value Int32.MinValue değerinden küçük veya Int32.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnekte, değerinin değerlere dönüştürülmesi BigIntegerInt32 gösterilmektedir. Değer veri türü aralığının Int32 dışında olduğundan oluşan BigInteger bir OverflowException de işler.

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

Açıklamalar

yönteminin Explicit(Decimal to BigInteger) aşırı yüklemeleri, bir BigInteger nesnenin dönüştürülebileceği veya dönüştürülebileceği türleri tanımlar. Veri kaybı içerebileceğinden dil derleyicileri bu dönüştürmeyi otomatik olarak gerçekleştirmez. Bunun yerine, dönüştürmeyi yalnızca bir atama işleci (C#'ta) veya dönüştürme işlevi (visual basic gibi CTypeCInt ) kullanıldığında gerçekleştirir. Aksi takdirde, derleyici hatası görüntüler.

Bu işlem bir daraltma dönüştürmesi tanımladığından, değer veri türü aralığının BigIntegerInt32 dışındaysa çalışma zamanında bir OverflowException oluşturabilir. Dönüştürme başarılı olursa sonuçta elde edilen Int32 değerde duyarlık kaybı olmaz.

Şunlara uygulanır