BigInteger 結構

定義

表示任意大、帶正負號的整數。

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, ISpanFormattable
public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<System::Numerics::BigInteger>, System::Numerics::IAdditionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IAdditiveIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IBinaryInteger<System::Numerics::BigInteger>, System::Numerics::IBinaryNumber<System::Numerics::BigInteger>, System::Numerics::IBitwiseOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IComparisonOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IDecrementOperators<System::Numerics::BigInteger>, System::Numerics::IDivisionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IEqualityOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IIncrementOperators<System::Numerics::BigInteger>, System::Numerics::IModulusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplicativeIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplyOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::INumber<System::Numerics::BigInteger>, System::Numerics::INumberBase<System::Numerics::BigInteger>, System::Numerics::IShiftOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::ISignedNumber<System::Numerics::BigInteger>, System::Numerics::ISubtractionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryNegationOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryPlusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, ISpanFormattable
public readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<System.Numerics.BigInteger>, System.Numerics.IAdditionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IBinaryInteger<System.Numerics.BigInteger>, System.Numerics.IBinaryNumber<System.Numerics.BigInteger>, System.Numerics.IBitwiseOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IComparisonOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IDecrementOperators<System.Numerics.BigInteger>, System.Numerics.IDivisionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IEqualityOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IIncrementOperators<System.Numerics.BigInteger>, System.Numerics.IModulusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplyOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.INumber<System.Numerics.BigInteger>, System.Numerics.INumberBase<System.Numerics.BigInteger>, System.Numerics.IShiftOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.ISignedNumber<System.Numerics.BigInteger>, System.Numerics.ISubtractionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryNegationOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryPlusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
type BigInteger = struct
    interface ISpanFormattable
    interface IFormattable
type BigInteger = struct
    interface IFormattable
    interface IParsable<BigInteger>
    interface ISpanFormattable
    interface ISpanParsable<BigInteger>
    interface IAdditionOperators<BigInteger, BigInteger, BigInteger>
    interface IAdditiveIdentity<BigInteger, BigInteger>
    interface IBinaryInteger<BigInteger>
    interface IBinaryNumber<BigInteger>
    interface IBitwiseOperators<BigInteger, BigInteger, BigInteger>
    interface IComparisonOperators<BigInteger, BigInteger>
    interface IEqualityOperators<BigInteger, BigInteger>
    interface IDecrementOperators<BigInteger>
    interface IDivisionOperators<BigInteger, BigInteger, BigInteger>
    interface IIncrementOperators<BigInteger>
    interface IModulusOperators<BigInteger, BigInteger, BigInteger>
    interface IMultiplicativeIdentity<BigInteger, BigInteger>
    interface IMultiplyOperators<BigInteger, BigInteger, BigInteger>
    interface INumber<BigInteger>
    interface INumberBase<BigInteger>
    interface ISubtractionOperators<BigInteger, BigInteger, BigInteger>
    interface IUnaryNegationOperators<BigInteger, BigInteger>
    interface IUnaryPlusOperators<BigInteger, BigInteger>
    interface IShiftOperators<BigInteger, BigInteger>
    interface ISignedNumber<BigInteger>
[<System.Serializable>]
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), ISpanFormattable
Public Structure BigInteger
Implements IAdditionOperators(Of BigInteger, BigInteger, BigInteger), IAdditiveIdentity(Of BigInteger, BigInteger), IBinaryInteger(Of BigInteger), IBinaryNumber(Of BigInteger), IBitwiseOperators(Of BigInteger, BigInteger, BigInteger), IComparable(Of BigInteger), IComparisonOperators(Of BigInteger, BigInteger), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger), IEquatable(Of BigInteger), IIncrementOperators(Of BigInteger), IModulusOperators(Of BigInteger, BigInteger, BigInteger), IMultiplicativeIdentity(Of BigInteger, BigInteger), IMultiplyOperators(Of BigInteger, BigInteger, BigInteger), INumber(Of BigInteger), INumberBase(Of BigInteger), IParsable(Of BigInteger), IShiftOperators(Of BigInteger, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger)
繼承
BigInteger
屬性
實作
IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> IEquatable<TSelf> IParsable<BigInteger> IParsable<TSelf> ISpanParsable<BigInteger> ISpanParsable<TSelf> IAdditionOperators<BigInteger,BigInteger,BigInteger> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<BigInteger,BigInteger> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<BigInteger> IBinaryNumber<BigInteger> IBinaryNumber<TSelf> IBitwiseOperators<BigInteger,BigInteger,BigInteger> IBitwiseOperators<TSelf,TSelf,TSelf> System.Numerics.IComparisonOperators<BigInteger,BigInteger> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<BigInteger,BigInteger> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> IIncrementOperators<BigInteger> IIncrementOperators<TSelf> IModulusOperators<BigInteger,BigInteger,BigInteger> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<BigInteger,BigInteger> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<BigInteger,BigInteger,BigInteger> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<BigInteger> INumber<TSelf> INumberBase<BigInteger> INumberBase<TSelf> System.Numerics.IShiftOperators<BigInteger,BigInteger> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<BigInteger> ISubtractionOperators<BigInteger,BigInteger,BigInteger> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<BigInteger,BigInteger> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<BigInteger,BigInteger> IUnaryPlusOperators<TSelf,TSelf>

備註

BigInteger 類型是不可變的型別,代表理論上沒有上限或下限的任意大整數。 型別的成員會 (、、、、、 SByteUInt32 UInt16UInt64 類型) 平行處理其他整數型 Byte 別的成員 BigIntegerInt64 Int32 Int16 此類型不同于.NET Framework中的其他整數型別,其範圍是由 其 MinValueMaxValue 屬性工作表示。

注意

BigInteger因為類型是不可變的 (所以會看到可變動性和 BigInteger 結構) ,而且因為其沒有上限或下限, OutOfMemoryException 所以任何會導致 BigInteger 值成長太大的作業,都可以擲回 。

具現化 BigInteger 物件

您可以透過數種方式具現化 BigInteger 物件:

  • 您可以使用 關鍵字, new 並提供任何整數或浮點值做為建構函式的參數 BigInteger 。 (浮點值在指派給 BigInteger .) 之前截斷浮點值。下列範例說明如何使用 new 關鍵字來具現化 BigInteger 值。

    BigInteger bigIntFromDouble = new BigInteger(179032.6541);
    Console.WriteLine(bigIntFromDouble);
    BigInteger bigIntFromInt64 = new BigInteger(934157136952);
    Console.WriteLine(bigIntFromInt64);
    // The example displays the following output:
    //   179032
    //   934157136952
    
    Dim bigIntFromDouble As New BigInteger(179032.6541)
    Console.WriteLine(bigIntFromDouble)
    Dim bigIntFromInt64 As New BigInteger(934157136952)
    Console.WriteLine(bigIntFromInt64)
    ' The example displays the following output:
    '   179032
    '   934157136952
    
  • 只要該值是整數型別,您就可以宣告 BigInteger 變數並為其指派一個值,就像是任何數數值型別一樣。 下列範例會使用指派從 Int64 建立 BigInteger 值。

    long longValue = 6315489358112;
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • 如果您轉換值或先轉換值,您可以將小數點或浮點值指派給 BigInteger 物件。 下列範例會在 C#) 中明確轉換 (,或在 Visual Basic 中將 () DoubleDecimal 值轉換成 BigInteger

    BigInteger assignedFromDouble = (BigInteger) 179032.6541;
    Console.WriteLine(assignedFromDouble);
    BigInteger assignedFromDecimal = (BigInteger) 64312.65m;
    Console.WriteLine(assignedFromDecimal);
    // The example displays the following output:
    //   179032
    //   64312
    
    Dim assignedFromDouble As BigInteger = CType(179032.6541, BigInteger)
    Console.WriteLine(assignedFromDouble)   
    Dim assignedFromDecimal As BigInteger = CType(64312.65d, BigInteger)      
    Console.WriteLine(assignedFromDecimal)
    ' The example displays the following output:
    '   179032
    '   64312
    

這些方法可讓您具現化 BigInteger 物件,其值只存在於其中一個現有數數值型別的範圍內。 您可以具現化 BigInteger 物件,其值可以超過現有數數值型別的範圍,有三種方式之一:

  • 您可以使用 關鍵字, new 並將任何大小的 BigInteger.BigInteger 位元組陣列提供給建構函式。 例如:

    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    Dim newBigInt As New BigInteger(byteArray)
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
    ' The example displays the following output:
    '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
  • 您可以呼叫 ParseTryParse 方法,將數位的字串表示轉換為 BigInteger 。 例如:

    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    Dim positiveString As String = "91389681247993671255432112000000"
    Dim negativeString As string = "-90315837410896312071002088037140000"
    Dim posBigInt As BigInteger = 0
    Dim negBigInt As BigInteger = 0
    
    Try
       posBigInt = BigInteger.Parse(positiveString)
       Console.WriteLine(posBigInt)
    Catch e As FormatException
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                         positiveString)
    End Try
    
    If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
    Else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                          negativeString)
    End If         
    ' The example displays the following output:
    '   9.1389681247993671255432112E+31
    '   -9.0315837410896312071002088037E+34
    
  • 您可以在 Visual Basic) BigInteger 方法中呼叫 static (Shared ,以對數值運算式執行某些運算,並傳回計算 BigInteger 結果。 下列範例會藉由將結果 Cubing UInt64.MaxValue 和指派給 BigInteger 來執行此作業。

    BigInteger number = BigInteger.Pow(UInt64.MaxValue, 3);
    Console.WriteLine(number);
    // The example displays the following output:
    //    6277101735386680762814942322444851025767571854389858533375
    
    Dim number As BigInteger = BigInteger.Pow(UInt64.MaxValue, 3)
    Console.WriteLine(number)
    ' The example displays the following output:
      ' 6277101735386680762814942322444851025767571854389858533375
    

BigInteger 未初始化值是 Zero

對 BigInteger 值執行作業

您可以使用 BigInteger 實例,就像使用任何其他整數類型一樣。 BigInteger 多載標準數值運算子,讓您能夠執行基本數學運算,例如加法、減法、除法、乘法和一元負數。 您也可以使用標準數值運算子來比較兩 BigInteger 個值彼此。 與其他整數類型一樣, BigInteger 也支援位 AndOrXOr 左移和右移運算子。 對於不支援自訂運算子的語言,結構 BigInteger 也提供執行數學運算的對等方法。 這些包括 AddDivideMultiplyNegateSubtract 和數個其他專案。

結構的許多 BigInteger 成員會直接對應至其他整數型別的成員。 此外, BigInteger 新增如下的成員:

其中許多額外的成員會對應至 類別的成員 Math ,提供使用基本數數值型別的功能。

可變動性和 BigInteger 結構

下列範例會具現化 BigInteger 物件,然後將其值遞增一。

BigInteger number = BigInteger.Multiply(Int64.MaxValue, 3);
number++;
Console.WriteLine(number);
Dim number As BigInteger = BigInteger.Multiply(Int64.MaxValue, 3)
number += 1
Console.WriteLine(number)

雖然這個範例似乎修改現有物件的值,但這不是這種情況。 BigInteger 物件是不可變的,這表示在內部,Common Language Runtime 實際上會建立新的 BigInteger 物件,並為其指派一個大於先前值的值。 這個新的 物件接著會傳回給呼叫端。

注意

.NET 中的其他數數值型別也是不可變的。 不過,因為 BigInteger 類型沒有上限或下限,所以其值可能會變得非常大,而且會對效能產生可測量的影響。

雖然此程式對呼叫端而言是透明的,但會產生效能負面影響。 在某些情況下,特別是在非常大型 BigInteger 值的迴圈中執行重複作業時,效能降低可能相當重要。 例如,在下列範例中,作業會重複執行最多一百萬次,而且每次作業成功時,都會遞增一個 BigInteger 值。

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   number++;
}
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   number += 1
Next

在這種情況下,您可以藉由對變數執行所有中繼指派 Int32 來改善效能。 當迴圈結束時,可以將變數的最終值指派給 BigInteger 物件。 下列範例提供說明。

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
int actualRepetitions = 0;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   actualRepetitions++;
}
number += actualRepetitions;
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
Dim actualRepetitions As Integer = 0
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   actualRepetitions += 1
Next
number += actualRepetitions

使用位元組陣列和十六進位字串

如果您將值轉換成 BigInteger 位元組陣列,或將位元組陣列 BigInteger 轉換成值,則必須考慮位元組的順序。 結構 BigInteger 預期位元組陣列中的個別位元組會以小到尾順序出現, (也就是說,值較低順序的位元組位在較高順序的位元組前面) 。 您可以藉由呼叫 ToByteArray 方法,然後將產生的位元組陣列傳遞至 BigInteger(Byte[]) 建構函式來回 BigInteger 傳值,如下列範例所示。

BigInteger number = BigInteger.Pow(Int64.MaxValue, 2);
Console.WriteLine(number);

// Write the BigInteger value to a byte array.
byte[] bytes = number.ToByteArray();

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0:X2} ", byteValue);
Console.WriteLine();

// Restore the BigInteger value from a Byte array.
BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine(newNumber);
// The example displays the following output:
//    8.5070591730234615847396907784E+37
//    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
//
//    8.5070591730234615847396907784E+37
Dim number As BigInteger = BigInteger.Pow(Int64.MaxValue, 2)     
Console.WriteLine(number)

' Write the BigInteger value to a byte array.
Dim bytes() As Byte = number.ToByteArray()

' Display the byte array.
For Each byteValue As Byte In bytes
   Console.Write("0x{0:X2} ", byteValue)
Next   
Console.WriteLine()

' Restore the BigInteger value from a Byte array.
Dim newNumber As BigInteger = New BigInteger(bytes)
Console.WriteLine(newNumber)               
' The example displays the following output:
'    8.5070591730234615847396907784E+37
'    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
'    
'    8.5070591730234615847396907784E+37

若要從代表某些其他整數型別值的位元組陣列具現化 BigInteger 值,您可以將整數值傳遞至 BitConverter.GetBytes 方法,然後將產生的位元組陣列傳遞至 BigInteger(Byte[]) 建構函式。 下列範例會 BigInteger 從表示 Int16 值的位元組陣列中具現化值。

short originalValue = 30000;
Console.WriteLine(originalValue);

// Convert the Int16 value to a byte array.
byte[] bytes = BitConverter.GetBytes(originalValue);

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0} ", byteValue.ToString("X2"));
Console.WriteLine();

// Pass byte array to the BigInteger constructor.
BigInteger number = new BigInteger(bytes);
Console.WriteLine(number);
// The example displays the following output:
//       30000
//       0x30 0x75
//       30000
Dim originalValue As Short = 30000
Console.WriteLine(originalValue)

' Convert the Int16 value to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalValue)

' Display the byte array.
For Each byteValue As Byte In bytes
   Console.Write("0x{0} ", byteValue.ToString("X2"))
Next    
Console.WriteLine() 

' Pass byte array to the BigInteger constructor.
Dim number As BigInteger = New BigInteger(bytes)
Console.WriteLine(number)
' The example displays the following output:
'       30000
'       0x30 0x75
'       30000

結構 BigInteger 假設負值是使用兩個補數標記法來儲存。 BigInteger因為 結構代表沒有固定長度的數值,所以 BigInteger(Byte[]) 建構函式一律會將陣列中最後一個位元組的最大有效位解譯為符號位。 為了防止 BigInteger(Byte[]) 建構函式混淆兩個負值的補數標記法,其正值具有正值的正數標記法,其中位元組陣列中最後一個位元組的最大有效位通常會包含值為 0 的額外位元組。 例如,0xC0 0xBD 0xF0 0xFF是 -1,000,000 或 4,293,967,296 的位元組十六進位標記法。 因為這個陣列中最後一個位元組的最大有效位是開啟的,所以位元組陣列的值會由 BigInteger(Byte[]) 建構函式解譯為 -1,000,000。 若要具現化 BigInteger 其值為正數的 ,必須將元素0xC0 0xBD 0xF0 0xFF 0x00的位元組陣列傳遞至建構函式。 下列範例將說明這點。

int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

byte[] negativeBytes = BitConverter.GetBytes(negativeNumber);
BigInteger negativeBigInt = new BigInteger(negativeBytes);
Console.WriteLine(negativeBigInt.ToString("N0"));

byte[] tempPosBytes = BitConverter.GetBytes(positiveNumber);
byte[] positiveBytes = new byte[tempPosBytes.Length + 1];
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length);
BigInteger positiveBigInt = new BigInteger(positiveBytes);
Console.WriteLine(positiveBigInt.ToString("N0"));
// The example displays the following output:
//    -1,000,000
//    4,293,967,296
Dim negativeNumber As Integer = -1000000
Dim positiveNumber As UInteger = 4293967296

Dim negativeBytes() As Byte = BitConverter.GetBytes(negativeNumber) 
Dim negativeBigInt As New BigInteger(negativeBytes)
Console.WriteLine(negativeBigInt.ToString("N0"))

Dim tempPosBytes() As Byte = BitConverter.GetBytes(positiveNumber)
Dim positiveBytes(tempposBytes.Length) As Byte
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length)
Dim positiveBigInt As New BigInteger(positiveBytes)
Console.WriteLine(positiveBigInt.ToString("N0")) 
' The example displays the following output:
'    -1,000,000
'    4,293,967,296

方法從正值建立的 ToByteArray 位元組陣列包含這個額外的零值位元組。 因此,結構 BigInteger 可以藉由指派這些值,然後從位元組陣列還原它們,藉此成功來回值,如下列範例所示。

BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"));
byte[] bytes = positiveValue.ToByteArray();

foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue = new BigInteger(bytes);
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"));

Console.WriteLine();

Console.WriteLine("Negative value: " + negativeValue.ToString("N0"));
bytes = negativeValue.ToByteArray();
foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue = new BigInteger(bytes);
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"));
// The example displays the following output:
//       Positive value: 15,777,216
//       C0 BD F0 00
//       Restored positive value: 15,777,216
//
//       Negative value: -1,000,000
//       C0 BD F0
//       Restored negative value: -1,000,000
Dim positiveValue As BigInteger = 15777216
Dim negativeValue As BigInteger = -1000000

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"))
Dim bytes() As Byte = positiveValue.ToByteArray()
For Each byteValue As Byte In bytes
   Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
positiveValue = New BigInteger(bytes)
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"))

Console.WriteLine()
   
Console.WriteLIne("Negative value: " + negativeValue.ToString("N0"))
bytes = negativeValue.ToByteArray()
For Each byteValue As Byte In bytes
   Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
negativeValue = New BigInteger(bytes)
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"))
' The example displays the following output:
'       Positive value: 15,777,216
'       C0 BD F0 00
'       Restored positive value: 15,777,216
'       
'       Negative value: -1,000,000
'       C0 BD F0
'       Restored negative value: -1,000,000

不過,您可能需要將這個額外的零值位元組加入開發人員所建立的位元組陣列,或是由將不帶正負號整數轉換成位元組 (陣列的方法所傳回,例如 BitConverter.GetBytes(UInt16)BitConverter.GetBytes(UInt32)BitConverter.GetBytes(UInt64)) 。

剖析十六進位字串時, BigInteger.Parse(String, NumberStyles)BigInteger.Parse(String, NumberStyles, IFormatProvider) 方法會假設如果設定字串中第一個位元組的最大有效位,或字串的第一個十六進位數位代表位元組值的下四位,則會使用兩個補數表示來表示值。 例如,「FF01」 和 「F01」 都代表十進位值 -255。 若要區分正值與負值,正值應該包含前置零。 當方法傳遞 「X」 格式字串時,方法的相關多載 ToString 會將前置零加入傳回的十六進位字串中,以取得正值。 這可讓您使用 ToStringParse 方法來來回 BigInteger 值,如下列範例所示。

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

string negativeHex = negativeNumber.ToString("X");
string positiveHex = positiveNumber.ToString("X");

BigInteger negativeNumber2, positiveNumber2;
negativeNumber2 = BigInteger.Parse(negativeHex,
                                   NumberStyles.HexNumber);
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber);

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.",
                   negativeNumber, negativeHex, negativeNumber2);
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.",
                   positiveNumber, positiveHex, positiveNumber2);
// The example displays the following output:
//       Converted -1,000,000 to F0BDC0 back to -1,000,000.
//       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.
Dim negativeNumber As BigInteger = -1000000
Dim positiveNumber As BigInteger = 15777216

Dim negativeHex As String = negativeNumber.ToString("X")
Dim positiveHex As string = positiveNumber.ToString("X")

Dim negativeNumber2, positiveNumber2 As BigInteger 
negativeNumber2 = BigInteger.Parse(negativeHex, 
                                   NumberStyles.HexNumber)
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber)

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   negativeNumber, negativeHex, negativeNumber2)                                         
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   positiveNumber, positiveHex, positiveNumber2)                                         
' The example displays the following output:
'       Converted -1,000,000 to F0BDC0 back to -1,000,000.
'       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.

不過,呼叫 ToString 其他整數型別的方法或包含 toBase 參數之方法的多載 ToString 所建立的十六進位字串,不會指出衍生十六進位字串的值或源資料類型的正負號。 成功從這類字串具 BigInteger 現化值需要一些額外的邏輯。 下列範例提供一個可能的實作。

using System;
using System.Globalization;
using System.Numerics;

public struct HexValue
{
   public int Sign;
   public string Value;
}

public class Example
{
   public static void Main()
   {
      uint positiveNumber = 4039543321;
      int negativeNumber = -255423975;

      // Convert the numbers to hex strings.
      HexValue hexValue1, hexValue2;
      hexValue1.Value = positiveNumber.ToString("X");
      hexValue1.Sign = Math.Sign(positiveNumber);

      hexValue2.Value = Convert.ToString(negativeNumber, 16);
      hexValue2.Sign = Math.Sign(negativeNumber);

      // Round-trip the hexadecimal values to BigInteger values.
      string hexString;
      BigInteger positiveBigInt, negativeBigInt;

      hexString = (hexValue1.Sign == 1 ? "0" : "") + hexValue1.Value;
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        positiveNumber, hexValue1.Value, positiveBigInt);

      hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        negativeNumber, hexValue2.Value, negativeBigInt);
   }
}
// The example displays the following output:
//       Converted 4039543321 to F0C68A19 and back to 4039543321.
//       Converted -255423975 to f0c68a19 and back to -255423975.
Imports System.Globalization
Imports System.Numerics

Public Structure HexValue
   Public Sign As Integer
   Public Value As String
End Structure
   
Module Example
   Public Sub Main()
      Dim positiveNumber As UInteger = 4039543321
      Dim negativeNumber As Integer = -255423975

      ' Convert the numbers to hex strings.
      Dim hexValue1, hexValue2 As HexValue
      hexValue1.Value = positiveNumber.ToString("X")
      hexValue1.Sign = Math.Sign(positiveNumber)
      
      hexValue2.Value = Convert.ToString(negativeNumber, 16)
      hexValue2.Sign = Math.Sign(negativeNumber)
      
      ' Round-trip the hexadecimal values to BigInteger values.
      Dim hexString As String
      Dim positiveBigInt, negativeBigInt As BigInteger
      
      hexString = CStr(IIf(hexValue1.Sign = 1, "0", "")) + hexValue1.Value
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        positiveNumber, hexValue1.Value, positiveBigInt)

      hexString = CStr(IIf(hexValue2.Sign = 1, "0", "")) + hexValue2.Value
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        negativeNumber, hexValue2.Value, negativeBigInt)

   End Sub
End Module
' The example displays the following output:
'       Converted 4039543321 to F0C68A19 and back to 4039543321.
'       Converted -255423975 to f0c68a19 and back to -255423975.

建構函式

BigInteger(Byte[])

使用位元組陣列中的值,初始化 BigInteger 結構的新執行個體。

BigInteger(Decimal)

使用 BigInteger 值,初始化 Decimal 結構的新執行個體。

BigInteger(Double)

使用雙精確度浮點值,初始化 BigInteger 結構的新執行個體。

BigInteger(Int32)

使用 32 位元帶正負號的整數值,初始化 BigInteger 結構的新執行個體。

BigInteger(Int64)

使用 64 位元帶正負號的整數值,初始化 BigInteger 結構的新執行個體。

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

使用唯讀位元組範圍中的值並選擇性指出是否帶正負號與無大小順序的位元組順序,來初始化 BigInteger 結構的新執行個體。

BigInteger(Single)

使用單精確度浮點值,初始化 BigInteger 結構的新執行個體。

BigInteger(UInt32)

使用不帶正負號的 32 位元整數值,初始化 BigInteger 結構的新執行個體。

BigInteger(UInt64)

使用不帶正負號的 64 位元整數值,初始化 BigInteger 結構的新執行個體。

屬性

IsEven

表示目前 BigInteger 物件的值是否為偶數。

IsOne

表示目前 BigInteger 物件的值是否為 One

IsPowerOfTwo

表示目前 BigInteger 物件的值是否為二乘冪。

IsZero

表示目前 BigInteger 物件的值是否為 Zero

MinusOne

取得表示數字負一 (-1) 的值。

One

取得表示數字一 (1) 的值。

Sign

取得數字,這個數字表示目前 BigInteger 物件的正負號 (負數、正數或零)。

Zero

取得表示數字 0 (零) 的值。

方法

Abs(BigInteger)

取得 BigInteger 物件的絕對值。

Add(BigInteger, BigInteger)

兩個 BigInteger 值相加,並傳回結果。

Clamp(BigInteger, BigInteger, BigInteger)

將值限制為內含最小值和最大值。

Compare(BigInteger, BigInteger)

比較兩個 BigInteger 值並傳回整數,這個整數表示第一個值小於、等於或大於第二個值。

CompareTo(BigInteger)

比較這個執行個體與第二個 BigInteger,並且傳回整數,這個整數表示這個執行個體的值小於、等於或大於指定之物件的值。

CompareTo(Int64)

比較這個執行個體與帶正負號的 64 位元整數,並且傳回整數,這個整數表示這個執行個體的值小於、等於或大於帶正負號 64 位元整數的值。

CompareTo(Object)

比較這個執行個體與特定物件,並且傳回一個整數,指出這個執行個體的值是小於、等於或大於特定物件的值。

CompareTo(UInt64)

比較這個執行個體與不帶正負號的 64 位元整數,並且傳回整數,這個整數表示這個執行個體的值小於、等於或大於不帶正負號 64 位元整數的值。

CopySign(BigInteger, BigInteger)

將值的正負號複製到另一個值的正負號。

Divide(BigInteger, BigInteger)

某個 BigInteger 值除以另一個值,並且傳回結果。

DivRem(BigInteger, BigInteger)

計算兩個值的商數和餘數。

DivRem(BigInteger, BigInteger, BigInteger)

某個 BigInteger 值除以另一個值,傳回結果,並在輸出參數中傳回餘數。

Equals(BigInteger)

傳回值,這個值表示目前執行個體與指定的 BigInteger 物件是否有相同的值。

Equals(Int64)

傳回值,這個值表示目前執行個體與帶正負號的 64 位元整數是否有相同的值。

Equals(Object)

傳回值,這個值表示目前執行個體與指定的物件是否有相同的值。

Equals(UInt64)

傳回值,這個值表示目前執行個體與不帶正負號的 64 位元整數是否有相同的值。

GetBitLength()

取得目前執行個體沒有正負號位元的最短二補數表示所需的位元數目。

GetByteCount(Boolean)

取得將由 ToByteArray(Boolean, Boolean)TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) 輸出的位元組數。

GetHashCode()

傳回目前 BigInteger 物件的雜湊碼。

GreatestCommonDivisor(BigInteger, BigInteger)

求兩個 BigInteger 值的最大公因數。

IsEvenInteger(BigInteger)

判斷值是否代表偶數整數。

IsNegative(BigInteger)

判斷值是否為負值。

IsOddInteger(BigInteger)

判斷值是否代表奇數整數。

IsPositive(BigInteger)

判斷值是否為正數。

IsPow2(BigInteger)

判斷值是否為兩個的乘冪。

LeadingZeroCount(BigInteger)

計算值中的前置零數目。

Log(BigInteger)

傳回指定數字的自然 (底數為 e) 對數。

Log(BigInteger, Double)

傳回指定底數中指定數字的對數。

Log10(BigInteger)

傳回指定數字的以 10 為底數的對數。

Log2(BigInteger)

計算值的 log2。

Max(BigInteger, BigInteger)

傳回兩個 BigInteger 值的較大值。

MaxMagnitude(BigInteger, BigInteger)

比較兩個值與大於的計算。

Min(BigInteger, BigInteger)

傳回兩個 BigInteger 值的較小值。

MinMagnitude(BigInteger, BigInteger)

比較兩個值與比較較少的計算。

ModPow(BigInteger, BigInteger, BigInteger)

一個數目自乘至另一個數目的乘冪後,執行模數除法。

Multiply(BigInteger, BigInteger)

傳回兩個 BigInteger 值的乘積。

Negate(BigInteger)

將指定的 BigInteger 值變換正負號。

Parse(ReadOnlySpan<Char>, IFormatProvider)

將字元範圍剖析為值。

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

將所指定唯讀字元範圍中具有所指定樣式的數字表示法轉換為其 BigInteger 對等項目。

Parse(String)

將數字的字串表示,轉換為其相等的 BigInteger

Parse(String, IFormatProvider)

將使用指定特定文化特性格式之數字的字串表示轉換為其相等的 BigInteger

Parse(String, NumberStyles)

將指定樣式中數字的字串表示轉換為其相等的 BigInteger

Parse(String, NumberStyles, IFormatProvider)

將數字的字串表示 (使用指定樣式和特定文化特性的格式) 轉換為其相等的 BigInteger

PopCount(BigInteger)

計算值中所設定的位數。

Pow(BigInteger, Int32)

BigInteger 值自乘至指定之值的乘冪。

Remainder(BigInteger, BigInteger)

對兩個 BigInteger 值執行整數除法運算,並傳回餘數。

RotateLeft(BigInteger, Int32)

將值向左旋轉指定的數量。

RotateRight(BigInteger, Int32)

以指定的數量向右旋轉值。

Subtract(BigInteger, BigInteger)

某個 BigInteger 值減去另一個值,並且傳回結果。

ToByteArray()

BigInteger 值轉換成位元組陣列。

ToByteArray(Boolean, Boolean)

使用盡可能最少的位元組數,傳回這個 BigInteger 的值作為位元組陣列。 如果值為零,則傳回其元素為 0x00 的一個位元組陣列。

ToString()

將目前 BigInteger 物件的數值,轉換為其相等的字串表示。

ToString(IFormatProvider)

使用指定的文化特性特定格式資訊,將目前 BigInteger 物件的數值轉換為其對等字串表示。

ToString(String)

使用指定的格式,將目前 BigInteger 物件的值,轉換為其相等字串表示。

ToString(String, IFormatProvider)

使用指定的格式和特定文化特性的格式資訊,將目前 BigInteger 物件的數值,轉換為其相等的字串表示。

TrailingZeroCount(BigInteger)

計算值中尾端零的數目。

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

將此大整數執行個體的格式設定為字元範圍。

TryParse(ReadOnlySpan<Char>, BigInteger)

嘗試將所指定唯讀字元範圍中包含的數字表示法轉換為其 BigInteger 對等項目,並傳回指出轉換是否成功的值。

TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)

嘗試將字元範圍剖析成值。

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)

嘗試將數字的字串表示轉換成其相等的 BigInteger,並傳回一個值表示轉換是否成功。

TryParse(String, BigInteger)

嘗試將數字的字串表示轉換成其相等的 BigInteger,並傳回一個值表示轉換是否成功。

TryParse(String, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger)

使用指定的文化特性特定格式資訊和格式樣式,將日期和時間的指定字串表示轉換為其對等的 BigInteger,並傳回值,這個值表示轉換是否成功。

TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)

使用盡可能最少位元組數來複製這個 BigInteger 的值,作為位元組由小到大的二補數位元組。 如果值為零,則輸出其元素為 0x00 的一個位元組。

運算子

Addition(BigInteger, BigInteger)

兩個指定之 BigInteger 物件的值相加。

BitwiseAnd(BigInteger, BigInteger)

對兩個 BigInteger 值執行位元 And 運算。

BitwiseOr(BigInteger, BigInteger)

對兩個 BigInteger 值執行位元 Or 運算。

Decrement(BigInteger)

BigInteger 值遞減 1。

Division(BigInteger, BigInteger)

使用整數除法,將指定的 BigInteger 值除以另一個指定的 BigInteger 值。

Equality(BigInteger, BigInteger)

傳回值,這個值表示兩個 BigInteger 物件的值是否相等。

Equality(BigInteger, Int64)

傳回值,這個值表示 BigInteger 值與帶正負號長整數值是否相等。

Equality(BigInteger, UInt64)

傳回值,這個值表示 BigInteger 值與不帶正負號長整數值是否相等。

Equality(Int64, BigInteger)

傳回值,這個值表示帶正負號長整數值與 BigInteger 值是否相等。

Equality(UInt64, BigInteger)

傳回值,這個值表示不帶正負號長整數值與 BigInteger 值是否相等。

ExclusiveOr(BigInteger, BigInteger)

對兩個 BigInteger 值執行位元互斥 Or (XOr) 運算。

Explicit(BigInteger to Byte)

定義從 BigInteger 物件到不帶正負號位元組值的明確轉換。

Explicit(BigInteger to Char)

明確將大整數轉換成 Char 值。

Explicit(BigInteger to Decimal)

定義從 BigInteger 物件到 Decimal 值的明確轉換。

Explicit(BigInteger to Double)

定義從 BigInteger 物件到 Double 值的明確轉換。

Explicit(BigInteger to Half)

明確地將大整數轉換為 Half 值。

Explicit(BigInteger to Int128)

明確地將大整數轉換為 Int128 值。

Explicit(BigInteger to Int16)

定義從 BigInteger 物件到 16 位元帶正負號整數值的明確轉換。

Explicit(BigInteger to Int32)

定義從 BigInteger 物件到 32 位元帶正負號整數值的明確轉換。

Explicit(BigInteger to Int64)

定義從 BigInteger 物件到 64 位元帶正負號整數值的明確轉換。

Explicit(BigInteger to IntPtr)

明確地將大整數轉換為 IntPtr 值。

Explicit(BigInteger to SByte)

定義從 BigInteger 物件到帶正負號 8 位元值的明確轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Int16

Explicit(BigInteger to Single)

定義從 BigInteger 物件到單精確度浮點值的明確轉換。

Explicit(BigInteger to UInt128)

明確地將大整數轉換為 UInt128 值。

Explicit(BigInteger to UInt16)

定義從 BigInteger 物件到不帶正負號 16 位元整數值的明確轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Int32

Explicit(BigInteger to UInt32)

定義從 BigInteger 物件到不帶正負號 32 位元整數值的明確轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Int64

Explicit(BigInteger to UInt64)

定義從 BigInteger 物件到不帶正負號 64 位元整數值的明確轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Double

Explicit(BigInteger to UIntPtr)

明確地將大整數轉換為 UIntPtr 值。

Explicit(Complex to BigInteger)

明確地將 Complex 值轉換成大整數。

Explicit(Decimal to BigInteger)

定義從 Decimal 物件到 BigInteger 值的明確轉換。

Explicit(Double to BigInteger)

定義從 Double 值到 BigInteger 值的明確轉換。

Explicit(Half to BigInteger)

明確將值轉換成 Half 大整數。

Explicit(Single to BigInteger)

定義從 Single 值到 BigInteger 值的明確轉換。

GreaterThan(BigInteger, BigInteger)

傳回值,這個值表示 BigInteger 值是否大於另一個 BigInteger 值。

GreaterThan(BigInteger, Int64)

傳回值,這個值表示 BigInteger 是否大於 64 位元帶正負號的整數值。

GreaterThan(BigInteger, UInt64)

傳回值,這個值表示 BigInteger 值是否大於 64 位元不帶正負號的整數。

GreaterThan(Int64, BigInteger)

傳回值,這個值表示 64 位元帶正負號的整數是否大於 BigInteger 值。

GreaterThan(UInt64, BigInteger)

傳回值,這個值表示 BigInteger 值是否大於 64 位元不帶正負號的整數。

GreaterThanOrEqual(BigInteger, BigInteger)

傳回值,這個值表示 BigInteger 值是否大於或等於另一個 BigInteger 值。

GreaterThanOrEqual(BigInteger, Int64)

傳回值,這個值表示 BigInteger 值是否大於或等於 64 位元帶正負號的整數值。

GreaterThanOrEqual(BigInteger, UInt64)

傳回值,這個值表示 BigInteger 值是否大於或等於 64 位元不帶正負號的整數值。

GreaterThanOrEqual(Int64, BigInteger)

傳回值,這個值表示 64 位元帶正負號的整數是否大於或等於 BigInteger 值。

GreaterThanOrEqual(UInt64, BigInteger)

傳回值,這個值表示 64 位元不帶正負號的整數是否大於或等於 BigInteger 值。

Implicit(Byte to BigInteger)

定義從不帶正負號的位元組到 BigInteger 值的隱含轉換。

Implicit(Char to BigInteger)

隱含地將值轉換成 Char 大整數。

Implicit(Int128 to BigInteger)

隱含地將值轉換成 Int128 大整數。

Implicit(Int16 to BigInteger)

定義從帶正負號的 16 位元整數到 BigInteger 值的隱含轉換。

Implicit(Int32 to BigInteger)

定義從帶正負號的 32 位元整數到 BigInteger 值的隱含轉換。

Implicit(Int64 to BigInteger)

定義從帶正負號的 64 位元整數到 BigInteger 值的隱含轉換。

Implicit(IntPtr to BigInteger)

隱含地將值轉換成 IntPtr 大整數。

Implicit(SByte to BigInteger)

定義從 8 位元帶正負號的整數到 BigInteger 值的隱含轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 BigInteger(Int32)

Implicit(UInt128 to BigInteger)

隱含地將值轉換成 UInt128 大整數。

Implicit(UInt16 to BigInteger)

定義從 16 位元不帶正負號的整數到 BigInteger 值的隱含轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Implicit(Int32 to BigInteger)

Implicit(UInt32 to BigInteger)

定義從 32 位元不帶正負號的整數到 BigInteger 值的隱含轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Implicit(Int64 to BigInteger)

Implicit(UInt64 to BigInteger)

定義從 64 位元不帶正負號的整數到 BigInteger 值的隱含轉換。

此應用程式開發介面不符合 CLS 標準。 符合規範的替代項目為 Double

Implicit(UIntPtr to BigInteger)

隱含地將值轉換成 UIntPtr 大整數。

Increment(BigInteger)

BigInteger 值遞增 1。

Inequality(BigInteger, BigInteger)

傳回值,指出兩個 BigInteger 物件是否有不同的值。

Inequality(BigInteger, Int64)

傳回值,這個值表示 BigInteger 值與 64 位元帶正負號的整數是否不相等。

Inequality(BigInteger, UInt64)

傳回值,這個值表示 BigInteger 值與 64 位元不帶正負號的整數是否不相等。

Inequality(Int64, BigInteger)

傳回值,這個值表示 64 位元帶正負號的整數與 BigInteger 值是否不相等。

Inequality(UInt64, BigInteger)

傳回值,這個值表示 64 位元不帶正負號的整數與 BigInteger 值是否不相等。

LeftShift(BigInteger, Int32)

BigInteger 值向左移動指定的位元數。

LessThan(BigInteger, BigInteger)

傳回值,這個值表示 BigInteger 值是否小於另一個 BigInteger 值。

LessThan(BigInteger, Int64)

傳回值,這個值表示 BigInteger 值是否小於 64 位元帶正負號的整數。

LessThan(BigInteger, UInt64)

傳回值,這個值表示 BigInteger 值是否小於 64 位元不帶正負號的整數。

LessThan(Int64, BigInteger)

傳回值,這個值表示 64 位元帶正負號的整數是否小於 BigInteger 值。

LessThan(UInt64, BigInteger)

傳回值,這個值表示 64 位元不帶正負號的整數是否小於 BigInteger 值。

LessThanOrEqual(BigInteger, BigInteger)

傳回值,這個值表示 BigInteger 值是否小於或等於另一個 BigInteger 值。

LessThanOrEqual(BigInteger, Int64)

傳回值,這個值表示 BigInteger 值是否小於或等於 64 位元帶正負號的整數。

LessThanOrEqual(BigInteger, UInt64)

傳回值,這個值表示 BigInteger 值是否小於或等於 64 位元不帶正負號的整數。

LessThanOrEqual(Int64, BigInteger)

傳回值,這個值表示 64 位元帶正負號的整數是否小於或等於 BigInteger 值。

LessThanOrEqual(UInt64, BigInteger)

傳回值,這個值表示 64 位元不帶正負號的整數是否小於或等於 BigInteger 值。

Modulus(BigInteger, BigInteger)

傳回從兩個指定的 BigInteger 值相除所得的餘數。

Multiply(BigInteger, BigInteger)

將兩個指定的 BigInteger 值相乘。

OnesComplement(BigInteger)

傳回 BigInteger 值的位元一進位補數。

RightShift(BigInteger, Int32)

BigInteger 值向右移動指定的位元數。

Subtraction(BigInteger, BigInteger)

將某個 BigInteger 值減去另一個 BigInteger 值。

UnaryNegation(BigInteger)

將指定的 BigInteger 值變換正負號。

UnaryPlus(BigInteger)

傳回 BigInteger 運算元的值。 (運算元的正負號不會變更)。

UnsignedRightShift(BigInteger, Int32)

以指定的數量向右移位值。

明確介面實作

IBinaryInteger<BigInteger>.GetByteCount()

取得將寫入為 的 TryWriteLittleEndian(Span<Byte>, Int32) 位元組數目。

IBinaryInteger<BigInteger>.GetShortestBitLength()

取得最小兩個補數標記法目前值的長度,以位為單位。

IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)

嘗試以大到大到大的格式,將目前的值寫入指定的範圍。

IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)

嘗試以位元組端格式將目前的值寫入指定的範圍。

IComparable.CompareTo(Object)

比較這個執行個體與特定物件,並且傳回一個整數,指出這個執行個體的值是小於、等於或大於特定物件的值。

適用於