BigInteger Struktúra

Definíció

Névtér:

System.Numerics

Szerelvények:

netstandard.dll, System.Runtime.Numerics.dll

Forrás:

BigInteger.cs

Tetszőlegesen nagy aláírt egész számot jelöl.

public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<System::Numerics::BigInteger>, IUtf8SpanParsable<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, bool>, 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, bool>, 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, int, 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 readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<System.Numerics.BigInteger>, IUtf8SpanParsable<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,bool>, 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,bool>, 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,int,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>

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, bool>
    interface IEqualityOperators<BigInteger, BigInteger, bool>
    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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<BigInteger>
    interface ISubtractionOperators<BigInteger, BigInteger, BigInteger>
    interface IUnaryNegationOperators<BigInteger, BigInteger>
    interface IUnaryPlusOperators<BigInteger, BigInteger>
    interface IShiftOperators<BigInteger, int, BigInteger>
    interface ISignedNumber<BigInteger>

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, Boolean), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger, Boolean), 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, Integer, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger), IUtf8SpanParsable(Of BigInteger)

Öröklődés

Object

ValueType

BigInteger

Megvalósítás

IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<BigInteger> IParsable<TSelf> ISpanFormattable ISpanParsable<BigInteger> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<BigInteger> IUtf8SpanParsable<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> IComparisonOperators<BigInteger,BigInteger,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<BigInteger,BigInteger,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> 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> IShiftOperators<BigInteger,Int32,BigInteger> IShiftOperators<TSelf,Int32,TSelf> ISignedNumber<BigInteger> ISubtractionOperators<BigInteger,BigInteger,BigInteger> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<BigInteger,BigInteger> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<BigInteger,BigInteger> IUnaryPlusOperators<TSelf,TSelf>

Megjegyzések

A BigInteger típus egy nem módosítható típus, amely tetszőlegesen nagy egész számot jelöl, amelynek értéke elméletileg nem rendelkezik felső vagy alsó határokkal. A BigInteger tagjai szorosan párhuzamosak más integráltípusokéval (Byte, Int16, Int32, Int64, SByte, UInt16, UInt32és UInt64 típusokkal). Ez a típus eltér a .NET többi integráltípusától, amelyek MinValue és MaxValue tulajdonságaik által megjelölt tartományt mutatnak.

Note

Mivel a BigInteger típus nem módosítható (lásd a módosíthatósági) és mivel nincs felső vagy alsó határa, OutOfMemoryException bármely olyan művelethez eldobható, amely miatt a BigInteger érték túl nagy lesz.

BigInteger objektum példányosítása

A BigInteger objektumokat többféleképpen is létrehozhatja:

• A new kulcsszót használhatja, és paraméterként bármilyen integrál- vagy lebegőpontos értéket megadhat a BigInteger konstruktor számára. (A lebegőpontos értékek csonkulnak, mielőtt hozzá vannak rendelve a BigInteger.) Az alábbi példa bemutatja, hogyan használhatja a new kulcsszót a BigInteger értékek példányosítására.

  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
  

• Deklarálhat egy BigInteger változót, és ugyanúgy rendelhet hozzá értéket, mint bármely numerikus típushoz, feltéve, hogy ez az érték egy integráltípus. Az alábbi példa hozzárendeléssel hoz létre egy BigInteger értéket Int64-ből.

  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
  

• Decimális vagy lebegőpontos értéket rendelhet egy BigInteger objektumhoz, ha először az értéket adja meg vagy konvertálja. Az alábbi példa explicit módon átalakít (C#-ban) vagy konvertál (Visual Basic-ben) egy Double és egy Decimal értéket egy BigInteger-re.

  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
  

Ezek a módszerek lehetővé teszik egy BigInteger objektum példányosítását, amelynek értéke csak a meglévő numerikus típusok egyikének tartományában található. Létrehozhat egy BigInteger objektumot, amelynek értéke háromféleképpen haladhatja meg a meglévő numerikus típusok tartományát:

• Használhatja a new kulcsszót, és bármilyen méretű bájttömböt adhat meg a BigInteger.BigInteger konstruktornak. Például:

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

• Meghívhatja a Parse vagy TryParse metódusokat, hogy egy szám szöveges ábrázolását BigInteger-re alakítsa. Például:

  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
  

• Meghívhat egy static (Shared a Visual Basicben) BigInteger metódust, amely valamilyen műveletet hajt végre egy numerikus kifejezésen, és kiszámított BigInteger eredményt ad vissza. Az alábbi példa a UInt64.MaxValue köbére emelésével, majd az eredmény BigInteger-hez való hozzárendelésével történik.

  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
  

Egy BigInteger nem inicializált értéke Zero.

Műveletek végrehajtása BigInteger-értékeken

Használhat egy BigInteger-példányt, mint bármely más integráltípust. BigInteger felüldefiniálja a standard numerikus operátorokat, hogy olyan alapszintű matematikai műveleteket hajthasson végre, mint az összeadás, kivonás, osztás, szorzás és a negáció. A standard numerikus operátorokkal két BigInteger értéket is összehasonlíthat egymással. A többi integrált típushoz hasonlóan a BigInteger is támogatja a bitenkénti And, Or, XOr, balra tolás és jobbra tolás operátorokat. Az egyéni operátorokat nem támogató nyelvek esetében a BigInteger struktúra egyenértékű módszereket is biztosít a matematikai műveletek végrehajtásához. Ezek közé tartozik Add, Divide, Multiply, Negate, Subtractés még sok más.

A BigInteger szerkezet számos tagja közvetlenül megfelel a többi integráltípus tagjainak. Ezenkívül BigInteger a következő tagokat is hozzáadja:

• Sign, amely egy BigInteger érték előjelét jelző értéket ad vissza.

• Abs, amely egy BigInteger érték abszolút értékét adja vissza.

• DivRem, amely egy osztási művelet hányadosát és hátralévő részét is visszaadja.

• GreatestCommonDivisor, amely két BigInteger érték legnagyobb közös osztóját adja vissza.

Ezen további tagok közül sok megfelel a Math osztály tagjainak, amely biztosítja a primitív numerikus típusokkal való munkavégzéshez szükséges funkciókat.

Mutability

Az alábbi példa egy BigInteger objektumot példányosít, majd egyenként növeli annak értékét.

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)

Bár ez a példa úgy tűnik, hogy módosítja a meglévő objektum értékét, ez nem így van. BigInteger objektumok nem módosíthatók, ami azt jelenti, hogy a közös nyelvi futtatókörnyezet belsőleg létrehoz egy új BigInteger objektumot, és az előző értéknél nagyobb értéket rendel hozzá. Ezt az új objektumot a rendszer visszaadja a hívónak.

Note

A .NET többi numerikus típusa szintén nem módosítható. Mivel azonban a BigInteger típusnak nincsenek felső vagy alsó határai, értékei rendkívül nagyok lehetnek, és mérhető hatással lehetnek a teljesítményre.

Bár ez a folyamat transzparens a hívó számára, teljesítménybüntetést von maga után. Bizonyos esetekben, különösen akkor, ha az ismétlődő műveleteket egy ciklusban hajtják végre nagyon nagy BigInteger értékeken, ez a teljesítménybírság jelentős lehet. A következő példában például egy műveletet ismétlődően, akár egymilliószor hajtanak végre, és a művelet sikeres végrehajtásakor egy BigInteger érték eggyel növekszik.

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

Ilyen esetben javíthatja a teljesítményt, ha az összes köztes hozzárendelést végrehajtja egy Int32 változóhoz. A változó végső értéke ezután hozzárendelhető a BigInteger objektumhoz, amikor a hurok kilép. Az alábbi példa egy illusztrációt tartalmaz.

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

Bájttömbök és hexadecimális sztringek

Ha BigInteger értékeket bájttömbökké konvertálja, vagy ha a bájttömböket BigInteger értékké alakítja, figyelembe kell vennie a bájtok sorrendjét. A BigInteger struktúra azt várja, hogy a bájttömb egyes bájtjai kis végű sorrendben jelenjenek meg (vagyis az érték alacsonyabb rendű bájtjai előzik meg a magasabb szintű bájtokat). Egy BigInteger érték kerekítéséhez hívja meg a ToByteArray metódust, majd adja át az eredményként kapott bájttömböt a BigInteger(Byte[]) konstruktornak, ahogy az alábbi példa is mutatja.

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

Ha egy BigInteger értéket szeretne létrehozni egy olyan bájttömbből, amely valamilyen más integrál típusú értéket jelöl, az integrál értéket átadhatja a BitConverter.GetBytes metódusnak, majd átadhatja az eredményül kapott bájttömböt a BigInteger(Byte[]) konstruktornak. Az alábbi példa egy BigInteger értéket hoz létre egy Int16 értéket képviselő bájttömbből.

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

A BigInteger szerkezet feltételezi, hogy a negatív értékek tárolása két komplementer ábrázolással történik. Mivel a BigInteger struktúra nem rögzített hosszúságú numerikus értéket képvisel, a BigInteger(Byte[]) konstruktor mindig jelbitként értelmezi a tömb utolsó bájtjának legjelentősebb bitjét. Annak érdekében, hogy a BigInteger(Byte[]) konstruktor ne keverje össze a negatív érték két egymást kiegészítő ábrázolását egy pozitív érték jelével és nagyságával, a pozitív értékeknek, amelyekben a bájttömb utolsó bájtjának legfontosabb bitje általában be van állítva, egy további bájtot kell tartalmaznia, amelynek értéke 0. A 0xC0 0xBD 0xF0 0xFF például -1 000 000 vagy 4 293 967 296 kis végű hexadecimális ábrázolása. Mivel a tömb utolsó bájtjának legjelentősebb része be van kapcsolva, a bájttömb értékét a BigInteger(Byte[]) konstruktor -1 000 000 értékként értelmezi. A pozitív értéket tartalmazó BigInteger példányosításához egy olyan bájttömböt kell átadni a konstruktornak, amelynek elemei 0xC0 0xBD 0xF0 0xFF 0x00. A következő példa ezt szemlélteti.

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

A pozitív értékekből ToByteArray metódus által létrehozott bájttömbök közé tartozik ez a plusz nulla értékű bájt. Ezért a BigInteger struktúra sikeresen meg tudja kerekíteni az értékeket úgy, hogy bájttömbökhöz rendeli őket, majd visszaállítja őket a bájttömbökből, ahogy az alábbi példa is mutatja.

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

Előfordulhat azonban, hogy ezt a további nulla értékű bájtot hozzá kell adnia a fejlesztő által dinamikusan létrehozott bájttömbökhöz, vagy amelyeket az aláíratlan egész számokat bájttömbökké konvertáló metódusok (például BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)és BitConverter.GetBytes(UInt64)) adnak vissza.

Hexadecimális sztring elemzésekor a BigInteger.Parse(String, NumberStyles) és a BigInteger.Parse(String, NumberStyles, IFormatProvider) metódus feltételezi, hogy ha a karakterlánc első bájtjának legjelentősebb bitje be van állítva, vagy ha a sztring első hexadecimális számjegye a bájtérték alsó négy bitjét jelöli, az értéket két egymást kiegészítő ábrázolással jelöljük. Például az "FF01" és az "F01" egyaránt a -255 tizedes értéket jelöli. A pozitív értékek negatív értékektől való megkülönböztetéséhez a pozitív értékeknek kezdő nullát kell tartalmazniuk. A ToString metódus megfelelő túlterhelései, amikor az "X" formátumú sztringet kapják meg, egy kezdeti nullát adnak hozzá a visszaadott hexadecimális sztringhez a pozitív értékek esetén. Ez lehetővé teszi a BigInteger értékek körforgását a ToString és Parse metódusok használatával, ahogy az alábbi példa mutatja.

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.

Azonban a más integrált típusok ToString metódusainak meghívásával vagy a ToString metódus olyan túlterheléseinek használatával, amelyek tartalmazzák a toBase paramétert, létrehozott hexadecimális sztringek nem jelzik sem az érték előjelét, sem pedig a forrásadat típusát, amelyből a hexadecimális sztring származik. Egy ilyen sztringből BigInteger érték sikeres példányosításához további logikára van szükség. Az alábbi példa egy lehetséges implementációt kínál.

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.

Konstruktorok

Name	Description
BigInteger(Byte[])	Inicializálja a BigInteger struktúra új példányát egy bájttömb értékeinek használatával.
BigInteger(Decimal)	Inicializálja a BigInteger struktúra új példányát egy Decimal érték használatával.
BigInteger(Double)	Inicializálja a BigInteger struktúra új példányát dupla pontosságú lebegőpontos érték használatával.
BigInteger(Int32)	Inicializálja a BigInteger struktúra új példányát egy 32 bites aláírt egész számértékkel.
BigInteger(Int64)	Inicializálja a BigInteger struktúra új példányát egy 64 bites aláírt egész számértékkel.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Inicializálja a BigInteger struktúra egy új példányát a bájtok írásvédett tartományában lévő értékekkel, és opcionálisan jelzi az aláírás kódolását és az endianness bájtsorrendet.
BigInteger(Single)	Inicializálja a BigInteger struktúra új példányát egy egy pontosságú lebegőpontos érték használatával.
BigInteger(UInt32)	Inicializálja a BigInteger struktúra új példányát egy aláíratlan 32 bites egész számértékkel.
BigInteger(UInt64)	Inicializálja a BigInteger struktúra új példányát egy aláíratlan 64 bites egész számértékkel.

Tulajdonságok

Name	Description
IsEven	Azt jelzi, hogy az aktuális BigInteger objektum értéke páros szám-e.
IsOne	Azt jelzi, hogy az aktuális BigInteger objektum értéke.One
IsPowerOfTwo	Azt jelzi, hogy az aktuális BigInteger objektum értéke kettőből áll-e.
IsZero	Azt jelzi, hogy az aktuális BigInteger objektum értéke.Zero
MinusOne	Olyan értéket kap, amely a negatív számot (-1) jelöli.
One	Olyan értéket kap, amely az első számot (1) jelöli.
Sign	Lekéri az aktuális BigInteger objektum jelét (negatív, pozitív vagy nulla) jelző számot.
Zero	A 0 számot (nulla) jelképező értéket kap.

Metódusok

Name	Description
Abs(BigInteger)	Lekéri egy BigInteger objektum abszolút értékét.
Add(BigInteger, BigInteger)	Két BigInteger értéket ad hozzá, és visszaadja az eredményt.
Clamp(BigInteger, BigInteger, BigInteger)	Egy értéket egy befogadó minimális és maximális értékhez rögzít.
Compare(BigInteger, BigInteger)	Két BigInteger értéket hasonlít össze, és egy egész számot ad vissza, amely azt jelzi, hogy az első érték kisebb, egyenlő vagy nagyobb,mint a második érték.
CompareTo(BigInteger)	Összehasonlítja ezt a példányt egy másodperccel BigInteger , és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.
CompareTo(Int64)	Összehasonlítja ezt a példányt egy aláírt 64 bites egész számokkal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint az aláírt 64 bites egész szám értéke.
CompareTo(Object)	Összehasonlítja ezt a példányt egy adott objektummal, és egy egész számot ad vissza, amely jelzi, hogy a példány értéke kisebb,egyenlő vagy nagyobb-e, mint a megadott objektum értéke.
CompareTo(UInt64)	Összehasonlítja ezt a példányt egy nem aláírt 64 bites egész számokkal, és egy egész számot ad vissza, amely azt jelzi, hogy a példány értéke kisebb, egyenlő vagy nagyobb-e, mint az aláíratlan 64 bites egész szám értéke.
CopySign(BigInteger, BigInteger)	Egy érték jelét egy másik érték jelére másolja.
CreateChecked<TOther>(TOther)	Létrehozza az aktuális típus egy példányát egy értékből, amely túlcsordulási kivételt eredményez az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
CreateSaturating<TOther>(TOther)	Egy értékből hozza létre az aktuális típus egy példányát, amely az aktuális típus reprezentáló tartományán kívül eső értékeket telít át.
CreateTruncating<TOther>(TOther)	Az aktuális típus egy példányát hozza létre egy értékből, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
Divide(BigInteger, BigInteger)	Elosztja az egyik BigInteger értéket egy másikkal, és visszaadja az eredményt.
DivRem(BigInteger, BigInteger, BigInteger)	Az egyik BigInteger értéket egy másikkal osztja el, az eredményt adja vissza, a többit pedig egy kimeneti paraméterben adja vissza.
DivRem(BigInteger, BigInteger)	Kiszámítja a hányadost és a két érték fennmaradó részét.
Equals(BigInteger)	Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy adott BigInteger objektum azonos értékkel rendelkezik-e.
Equals(Int64)	Olyan értéket ad vissza, amely azt jelzi, hogy az aktuális példány és egy aláírt 64 bites egész szám ugyanazzal az értékkel rendelkezik-e.
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy adott objektum azonos értékkel rendelkezik-e.
Equals(UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy az aktuális példány és egy nem aláírt 64 bites egész szám azonos értékkel rendelkezik-e.
GetBitLength()	Lekéri az aktuális példány jelbit nélküli, legfeljebb két kiegészítő ábrázolásához szükséges bitek számát.
GetByteCount(Boolean)	Lekéri a bájtok számát, amelyek a következővel lesznek kiadva ToByteArray(Boolean, Boolean) : és TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).
GetHashCode()	Az aktuális BigInteger objektum kivonatkódját adja vissza.
GreatestCommonDivisor(BigInteger, BigInteger)	Két BigInteger érték legnagyobb közös osztóját keresi meg.
IsEvenInteger(BigInteger)	Meghatározza, hogy egy érték páros integrál számot jelöl-e.
IsNegative(BigInteger)	Meghatározza, hogy egy érték negatív-e.
IsOddInteger(BigInteger)	Meghatározza, hogy egy érték páratlan integrál számot jelöl-e.
IsPositive(BigInteger)	Meghatározza, hogy egy érték pozitív-e.
IsPow2(BigInteger)	Meghatározza, hogy egy érték kettőből áll-e.
LeadingZeroCount(BigInteger)	Kiszámítja egy érték kezdő nulláinak számát.
Log(BigInteger, Double)	Egy megadott szám logaritmusát adja vissza egy megadott alapban.
Log(BigInteger)	Egy megadott szám természetes (alap e) logaritmusát adja vissza.
Log10(BigInteger)	Egy megadott szám alap 10 logaritmusát adja vissza.
Log2(BigInteger)	Kiszámítja egy érték napló2-ét.
Max(BigInteger, BigInteger)	Két BigInteger érték közül a nagyobbat adja vissza.
MaxMagnitude(BigInteger, BigInteger)	Két értéket hasonlít össze a nagyobb számítási értékekkel.
Min(BigInteger, BigInteger)	Két BigInteger érték közül a kisebbet adja eredményül.
MinMagnitude(BigInteger, BigInteger)	Két értéket hasonlít össze a kisebb számítási értékkel.
ModPow(BigInteger, BigInteger, BigInteger)	Modulus osztást hajt végre egy másik szám hatványára emelt számon.
Multiply(BigInteger, BigInteger)	Két BigInteger érték szorzatát adja vissza.
Negate(BigInteger)	Egy megadott értéket nem ad BigInteger meg.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	A megadott írásvédett karaktertartományban lévő szám ábrázolását konvertálja a megadott stílusban annak megfelelőjeként BigInteger .
Parse(String, IFormatProvider)	Egy adott kultúraspecifikus formátumban lévő szám sztringképét annak megfelelőjeként BigInteger alakítja át.
Parse(String, NumberStyles, IFormatProvider)	Egy szám sztring-ábrázolását konvertálja egy megadott stílusban és kultúraspecifikus formátumban annak megfelelőjeként BigInteger .
Parse(String, NumberStyles)	Egy adott stílusban lévő szám sztringképét a megfelelőre BigInteger alakítja át.
Parse(String)	Egy szám sztringképét az azzal egyenértékűvé BigInteger alakítja.
PopCount(BigInteger)	Kiszámítja az értékben beállított bitek számát.
Pow(BigInteger, Int32)	BigInteger Egy értéket egy adott érték hatványára emel.
Remainder(BigInteger, BigInteger)	Két BigInteger érték egész számának osztását hajtja végre, a maradékot pedig visszaadja.
RotateLeft(BigInteger, Int32)	Egy adott összeggel balra hagyott érték elforgatása.
RotateRight(BigInteger, Int32)	Egy érték elforgatása egy adott összeggel jobbra.
Subtract(BigInteger, BigInteger)	Kivon egy értéket a BigInteger másikból, és visszaadja az eredményt.
ToByteArray()	BigInteger Egy értéket bájttömbté alakít át.
ToByteArray(Boolean, Boolean)	Ennek BigInteger értékét bájttömbként adja vissza a lehető legkevesebb bájtszámmal. Ha az érték nulla, egy bájtból álló tömböt ad vissza, amelynek az eleme 0x00.
ToString()	Az aktuális BigInteger objektum numerikus értékét az azzal egyenértékű sztring-ábrázolássá alakítja.
ToString(IFormatProvider)	Az aktuális BigInteger objektum numerikus értékét a megadott kultúraspecifikus formázási információk használatával konvertálja a megfelelő sztringre.
ToString(String, IFormatProvider)	Az aktuális BigInteger objektum numerikus értékét a megadott formátum- és kultúraspecifikus formátuminformációk használatával konvertálja a megfelelő sztringre.
ToString(String)	Az aktuális BigInteger objektum numerikus értékét a megadott formátummal egyenértékű sztring-ábrázolássá alakítja.
TrailingZeroCount(BigInteger)	Kiszámítja egy érték záró nulláinak számát.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Ezt a nagy egész számpéldányt karakterská alakítja.
TryParse(ReadOnlySpan<Char>, BigInteger)	Megpróbálja átalakítani a megadott írásvédett karaktertartományban lévő szám ábrázolását annak megfelelőjeként BigInteger , és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Egy karaktertartományt próbál elemezni egy értékben.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Megpróbálja átalakítani egy szám sztringképét annak BigInteger megfelelőjeként, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParse(String, BigInteger)	Megpróbálja átalakítani egy szám sztringképét annak BigInteger megfelelőjeként, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryParse(String, IFormatProvider, BigInteger)	Megpróbál egy sztringet egy értékbe elemezni.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Egy szám sztring-ábrázolását egy megadott stílusban és kultúraspecifikus formátumban próbálja átalakítani annak BigInteger megfelelőjeként, és visszaad egy értéket, amely jelzi, hogy az átalakítás sikeres volt-e.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Ennek az értéknek a másolása BigInteger kis endian kétkiegészítő bájtként, a lehető legkevesebb bájtszámmal. Ha az érték nulla, egy bájtot ad ki, amelynek az eleme 0x00.

Operátorok

Name	Description
Addition(BigInteger, BigInteger)	Két megadott BigInteger objektum értékeit adja hozzá.
BitwiseAnd(BigInteger, BigInteger)	Bitenkénti And műveletet hajt végre két BigInteger értéken.
BitwiseOr(BigInteger, BigInteger)	Bitenkénti Or műveletet hajt végre két BigInteger értéken.
Decrement(BigInteger)	Érték decresítése BigInteger 1-gyel.
Division(BigInteger, BigInteger)	A megadott BigInteger értéket egy másik megadott BigInteger értékkel osztja el egész szám osztással.
Equality(BigInteger, BigInteger)	Olyan értéket ad vissza, amely jelzi, hogy két BigInteger objektum értéke egyenlő-e.
Equality(BigInteger, Int64)	Olyan értéket ad vissza, amely jelzi, hogy egy BigInteger érték és egy aláírt hosszú egész szám egyenlő-e.
Equality(BigInteger, UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték és egy aláíratlan hosszú egész szám egyenlő-e.
Equality(Int64, BigInteger)	Olyan értéket ad vissza, amely jelzi, hogy egy aláírt hosszú egész szám és egy BigInteger érték egyenlő-e.
Equality(UInt64, BigInteger)	Olyan értéket ad vissza, amely jelzi, hogy egy aláíratlan hosszú egész szám és egy BigInteger érték egyenlő-e.
ExclusiveOr(BigInteger, BigInteger)	Bitenkénti kizárólagos Or (XOr) műveletet hajt végre két BigInteger értéken.
Explicit(BigInteger to Byte)	Egy objektum explicit konvertálását BigInteger határozza meg aláíratlan bájtértékké.
Explicit(BigInteger to Char)	Explicit módon konvertál egy nagy egész számot értékké Char .
Explicit(BigInteger to Decimal)	Egy objektum explicit átalakítását BigInteger határozza meg értékké Decimal .
Explicit(BigInteger to Double)	Egy objektum explicit átalakítását BigInteger határozza meg értékké Double .
Explicit(BigInteger to Half)	Explicit módon konvertál egy nagy egész számot értékké Half .
Explicit(BigInteger to Int128)	Explicit módon konvertál egy nagy egész számot értékké Int128 .
Explicit(BigInteger to Int16)	Egy objektum explicit konvertálását BigInteger határozza meg 16 bites aláírt egész számértékké.
Explicit(BigInteger to Int32)	Egy objektum explicit konvertálását BigInteger határozza meg 32 bites aláírt egész számértékké.
Explicit(BigInteger to Int64)	Egy objektum explicit konvertálását BigInteger határozza meg 64 bites aláírt egész számértékké.
Explicit(BigInteger to IntPtr)	Explicit módon konvertál egy nagy egész számot értékké IntPtr .
Explicit(BigInteger to SByte)	Egy objektum explicit konvertálását BigInteger határozza meg aláírt 8 bites értékké. Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Int16
Explicit(BigInteger to Single)	Egy objektum explicit konvertálását BigInteger definiálja egy pontosságú lebegőpontos értékké.
Explicit(BigInteger to UInt128)	Explicit módon konvertál egy nagy egész számot értékké UInt128 .
Explicit(BigInteger to UInt16)	Egy objektum explicit konvertálását BigInteger határozza meg aláíratlan 16 bites egész számmá. Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Int32
Explicit(BigInteger to UInt32)	Egy objektum explicit konvertálását BigInteger határozza meg aláíratlan 32 bites egész számmá. Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Int64
Explicit(BigInteger to UInt64)	Egy objektum explicit konvertálását BigInteger határozza meg aláíratlan 64 bites egész számmá. Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Double
Explicit(BigInteger to UIntPtr)	Explicit módon konvertál egy nagy egész számot értékké UIntPtr .
Explicit(Complex to BigInteger)	Explicit módon konvertál egy Complex értéket nagy egész számmá.
Explicit(Decimal to BigInteger)	Egy objektum explicit átalakítását Decimal határozza meg értékké BigInteger .
Explicit(Double to BigInteger)	Egy érték explicit átalakítását Double határozza meg értékké BigInteger .
Explicit(Half to BigInteger)	Explicit módon konvertál egy Half értéket nagy egész számmá.
Explicit(Single to BigInteger)	Egy érték explicit átalakítását Single határozza meg értékké BigInteger .
GreaterThan(BigInteger, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték nagyobb-e egy másik BigInteger értéknél.
GreaterThan(BigInteger, Int64)	Olyan értéket ad vissza, amely jelzi, hogy egy BigInteger érték nagyobb-e, mint egy 64 bites aláírt egész szám.
GreaterThan(BigInteger, UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték nagyobb-e, mint egy 64 bites aláíratlan egész szám.
GreaterThan(Int64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláírt egész szám nagyobb-e egy BigInteger értéknél.
GreaterThan(UInt64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték nagyobb-e, mint egy 64 bites aláíratlan egész szám.
GreaterThanOrEqual(BigInteger, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték nagyobb-e, mint egy másik BigInteger érték.
GreaterThanOrEqual(BigInteger, Int64)	Olyan értéket ad vissza, amely jelzi, hogy egy BigInteger érték nagyobb-e, mint egy 64 bites aláírt egész szám.
GreaterThanOrEqual(BigInteger, UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték nagyobb-e, mint egy 64 bites aláíratlan egész szám.
GreaterThanOrEqual(Int64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláírt egész szám nagyobb-e, mint egy BigInteger érték.
GreaterThanOrEqual(UInt64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláíratlan egész szám nagyobb-e, mint egy BigInteger érték.
Implicit(Byte to BigInteger)	Egy aláíratlan bájt implicit konvertálását határozza meg egy BigInteger értékké.
Implicit(Char to BigInteger)	Implicit módon konvertál egy Char értéket nagy egész számmá.
Implicit(Int128 to BigInteger)	Implicit módon konvertál egy Int128 értéket nagy egész számmá.
Implicit(Int16 to BigInteger)	Egy aláírt 16 bites egész szám implicit konvertálását határozza meg értékké BigInteger .
Implicit(Int32 to BigInteger)	Egy aláírt 32 bites egész szám implicit konvertálását határozza meg értékké BigInteger .
Implicit(Int64 to BigInteger)	Egy aláírt 64 bites egész szám implicit konvertálását határozza meg értékké BigInteger .
Implicit(IntPtr to BigInteger)	Implicit módon konvertál egy IntPtr értéket nagy egész számmá.
Implicit(SByte to BigInteger)	Egy 8 bites aláírt egész szám implicit konvertálását határozza meg értékké BigInteger . Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .BigInteger(Int32)
Implicit(UInt128 to BigInteger)	Implicit módon konvertál egy UInt128 értéket nagy egész számmá.
Implicit(UInt16 to BigInteger)	Egy 16 bites aláíratlan egész szám implicit konvertálását határozza meg egy BigInteger értékre. Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Implicit(Int32 to BigInteger)
Implicit(UInt32 to BigInteger)	Egy 32 bites aláíratlan egész szám implicit konvertálását határozza meg értékké BigInteger . Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Implicit(Int64 to BigInteger)
Implicit(UInt64 to BigInteger)	Egy 64 bites aláíratlan egész szám implicit konvertálását határozza meg értékké BigInteger . Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Double
Implicit(UIntPtr to BigInteger)	Implicit módon konvertál egy UIntPtr értéket nagy egész számmá.
Increment(BigInteger)	BigInteger 1-zel növeli az értéket.
Inequality(BigInteger, BigInteger)	Olyan értéket ad vissza, amely jelzi, hogy két BigInteger objektum eltérő értékekkel rendelkezik-e.
Inequality(BigInteger, Int64)	Olyan értéket ad vissza, amely jelzi, hogy egy BigInteger érték és egy 64 bites aláírt egész szám nem egyenlő-e.
Inequality(BigInteger, UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték és egy 64 bites nem aláírt egész szám nem egyenlő-e.
Inequality(Int64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláírt egész szám és egy BigInteger érték nem egyenlő-e.
Inequality(UInt64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláíratlan egész szám és egy BigInteger érték nem egyenlő-e.
LeftShift(BigInteger, Int32)	BigInteger A megadott számú bitet balra tolja el.
LessThan(BigInteger, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték kisebb-e egy másik BigInteger értéknél.
LessThan(BigInteger, Int64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték kisebb-e, mint egy 64 bites aláírt egész szám.
LessThan(BigInteger, UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték kisebb-e, mint egy 64 bites aláíratlan egész szám.
LessThan(Int64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláírt egész szám kisebb-e egy BigInteger értéknél.
LessThan(UInt64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláíratlan egész szám kisebb-e egy BigInteger értéknél.
LessThanOrEqual(BigInteger, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték kisebb-e, mint egy másik BigInteger érték.
LessThanOrEqual(BigInteger, Int64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték kisebb-e, mint egy 64 bites aláírt egész szám.
LessThanOrEqual(BigInteger, UInt64)	Olyan értéket ad vissza, amely azt jelzi, hogy egy BigInteger érték kisebb-e, mint egy 64 bites aláíratlan egész szám.
LessThanOrEqual(Int64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláírt egész szám kisebb-e, mint egy BigInteger érték.
LessThanOrEqual(UInt64, BigInteger)	Olyan értéket ad vissza, amely azt jelzi, hogy egy 64 bites aláíratlan egész szám kisebb-e, mint egy BigInteger érték.
Modulus(BigInteger, BigInteger)	A két megadott BigInteger értékkel való osztásból származó maradékot adja vissza.
Multiply(BigInteger, BigInteger)	Két megadott BigInteger érték szorzata.
OnesComplement(BigInteger)	Egy érték bitenkénti kiegészítését BigInteger adja vissza.
RightShift(BigInteger, Int32)	BigInteger Egy megadott számú bitet jobbra tol el.
Subtraction(BigInteger, BigInteger)	Kivon egy értéket egy BigInteger másik BigInteger értékből.
UnaryNegation(BigInteger)	Egy megadott BigInteger-értéket nem ad vissza.
UnaryPlus(BigInteger)	Az operandus értékét BigInteger adja vissza. (Az operandus jele változatlan.)
UnsignedRightShift(BigInteger, Int32)	Egy érték eltolása egy adott összeggel jobbra.

Explicit interfész-implementációk

Name	Description
IAdditiveIdentity<BigInteger,BigInteger>.AdditiveIdentity	Lekéri az aktuális típus additív identitását.
IBinaryInteger<BigInteger>.GetByteCount()	Beolvasja a program által a program részeként megírt bájtok TryWriteLittleEndian(Span<Byte>, Int32)számát.
IBinaryInteger<BigInteger>.GetShortestBitLength()	Bitben lekéri az aktuális érték legrövidebb, egymást kiegészítő ábrázolásának hosszát.
IBinaryInteger<BigInteger>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Tetszőlegesen nagy aláírt egész számot jelöl.
IBinaryInteger<BigInteger>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Tetszőlegesen nagy aláírt egész számot jelöl.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Megpróbálja az aktuális értéket big-endian formátumban megírni egy adott időtartamra.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Az aktuális értéket kis endian formátumban próbálja meg írni egy adott időtartamra.
IBinaryNumber<BigInteger>.AllBitsSet	Lekéri annak a bináris típusnak a példányát, amelyben az összes bit be van állítva.
IMultiplicativeIdentity<BigInteger,BigInteger>.MultiplicativeIdentity	Lekéri az aktuális típus többszörös identitását.
INumber<BigInteger>.MaxNumber(BigInteger, BigInteger)	Két értéket hasonlít össze a számításhoz, amely nagyobb, és a másik értéket adja vissza, ha az egyik bemenet .NaN
INumber<BigInteger>.MinNumber(BigInteger, BigInteger)	Két értéket hasonlít össze a számításhoz, amely kisebb, és a másik értéket adja vissza, ha az egyik bemenet .NaN
INumber<BigInteger>.Sign(BigInteger)	Kiszámítja egy érték jelét.
INumberBase<BigInteger>.IsCanonical(BigInteger)	Meghatározza, hogy egy érték a vesszővel ábrázolt érték-e.
INumberBase<BigInteger>.IsComplexNumber(BigInteger)	Meghatározza, hogy egy érték összetett számot jelöl-e.
INumberBase<BigInteger>.IsFinite(BigInteger)	Meghatározza, hogy egy érték véges-e.
INumberBase<BigInteger>.IsImaginaryNumber(BigInteger)	Meghatározza, hogy egy érték tiszta képzeletbeli számot jelöl-e.
INumberBase<BigInteger>.IsInfinity(BigInteger)	Meghatározza, hogy egy érték végtelen-e.
INumberBase<BigInteger>.IsInteger(BigInteger)	Meghatározza, hogy egy érték egy integrál számot jelöl-e.
INumberBase<BigInteger>.IsNaN(BigInteger)	Meghatározza, hogy egy érték naN-e.
INumberBase<BigInteger>.IsNegativeInfinity(BigInteger)	Meghatározza, hogy egy érték negatív végtelen-e.
INumberBase<BigInteger>.IsNormal(BigInteger)	Meghatározza, hogy egy érték normális-e.
INumberBase<BigInteger>.IsPositiveInfinity(BigInteger)	Meghatározza, hogy egy érték pozitív végtelen-e.
INumberBase<BigInteger>.IsRealNumber(BigInteger)	Meghatározza, hogy egy érték valós számot jelöl-e.
INumberBase<BigInteger>.IsSubnormal(BigInteger)	Meghatározza, hogy egy érték szubnormális-e.
INumberBase<BigInteger>.IsZero(BigInteger)	Meghatározza, hogy egy érték nulla-e.
INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger, BigInteger)	Két értéket hasonlít össze a nagyobb nagyságrendű számításhoz, és az egyik bemenet NaNesetén a másik értéket adja vissza.
INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger, BigInteger)	Két értéket hasonlít össze a számításhoz, amelynek kisebb a nagysága, és a másik értéket adja vissza, ha az egyik bemenet .NaN
INumberBase<BigInteger>.MultiplyAddEstimate(BigInteger, BigInteger, BigInteger)	Kiszámítja a (left * right) + addendbecslést.
INumberBase<BigInteger>.Radix	Lekéri a típus radixát vagy bázist.
INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther, BigInteger)	Tetszőlegesen nagy aláírt egész számot jelöl.
INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther, BigInteger)	Tetszőlegesen nagy aláírt egész számot jelöl.
INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther, BigInteger)	Tetszőlegesen nagy aláírt egész számot jelöl.
INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és túlcsordulási kivételt okoz az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és az aktuális típus reprezentáló tartományán kívül eső értékeket telít.
INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
ISignedNumber<BigInteger>.NegativeOne	Lekéri a típus értékét -1 .