System.Numerics.BigInteger 結構

本文提供此 API 參考文件的補充備註。

此 BigInteger 類型是不可變的類型，代表任意大整數，理論上其值沒有上限或下限。 BigInteger類型的成員與其他整數類型的成員（例如Byte、Int16、Int32、Int64、SByte、UInt16、UInt32和UInt64類型）非常相似。此類型與 .NET 中的其他整數型別不同，其範圍是以其 MinValue 和 MaxValue 屬性表示。

備註

由於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 變數併為其指派值，就如同任何數值類型一樣。以下範例使用指派將BigInteger的值建立為Int64。

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 中轉換 Double 和 Decimal 的值為 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 {newBigInt} (or 0x{newBigInt:x}).");
// 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).

您可以呼叫 Parse 或 TryParse 方法，將數位的字串表示轉換成 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 '{positiveString}' to a BigInteger value.");
}

if (BigInteger.TryParse(negativeString, out negBigInt))
  Console.WriteLine(negBigInt);
else
   Console.WriteLine($"Unable to convert the string '{negativeString}' to a BigInteger value.");

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

您可以呼叫 static 在數值表達式上執行某些運算的（Shared 在 Visual Basic 中為） BigInteger 方法，並傳回計算 BigInteger 結果。下列範例會通過將 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 也支援位元運算的 And、Or、XOr、左移和右移運算子。對於不支援自定義運算符的語言，結構 BigInteger 也提供執行數學運算的對等方法。這些包括 Add、 Divide、 Multiply、 Negate、 Subtract和數個其他專案。

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

Sign，其傳回值會顯示 BigInteger 值的正負號。
Abs，此函數會傳回 BigInteger 的絕對值。
DivRem，其會傳回除法運算的商數和餘數。
GreatestCommonDivisor，其會傳回兩 BigInteger 個值的最大通用除數。

其中許多額外的成員對應至類別 Math 的成員，該類別提供功能來處理基本數值類型。

可變動性

下列範例會具現化 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 預期位元組陣列中的個別位元組會以小端序出現（也就是值的低位元組在高位元組之前）。您可以藉由呼叫 BigInteger 方法，然後將產生的位元組陣列傳遞至 ToByteArray 建構函式，以進行 BigInteger(Byte[]) 值的回程運算，如下列範例所示。

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。若要區分正值與負值，正值應該包含前置零。方法的相關多載 ToString 在傳遞「X」格式字串時，將前置零加入傳回的十六進位字串中，以取得正值。這可讓您使用 BigInteger 和 ToString 方法來回Parse值，如下列範例所示。

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 {negativeNumber:N0} to {negativeHex} back to {negativeNumber2:N0}.");
Console.WriteLine($"Converted {positiveNumber:N0} to {positiveHex} back to {positiveNumber2:N0}.");
// 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參數之ToString方法的多載toBase所建立的十六進位字串，無法顯示該數值的正負號或來源數據類型。要從這類字串成功實例化 BigInteger 值，需要一些額外的邏輯。下列範例提供一個可能的實作。

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

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

public class ByteHexExample2
{
    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 {positiveNumber} to {hexValue1.Value} and back to {positiveBigInt}.");

        hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
        negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
        Console.WriteLine($"Converted {negativeNumber} to {hexValue2.Value} and back to {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 Example2
    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.

意見反應

此頁面對您有幫助嗎？

Last updated on 2025-04-04