BigInteger Yapı

Başvuru

Tanım

Ad Alanı:: System.Numerics

Bütünleştirilmiş Kod:: System.Runtime.Numerics.dll

Bütünleştirilmiş Kod:: System.Numerics.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Rastgele olarak büyük bir işaretli tamsayıyı temsil eder.

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)

Devralma: Object

ValueType
BigInteger

Öznitelikler: SerializableAttribute

Uygulamalar: 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>

Açıklamalar

Tür BigInteger , teoride değeri üst veya alt sınırları olmayan rastgele büyük bir tamsayıyı temsil eden sabit bir türdür. Türün BigInteger üyeleri, diğer tam sayı türlerine ( Byte, , Int16, Int32, Int64, SByte, UInt16, UInt32ve UInt64 türleri) yakından paraleldir. Bu tür, ve MaxValue özellikleriyle belirtilen bir aralığa sahip .NET Framework diğer tam sayı türlerinden MinValue farklıdır.

Not

BigInteger Tür sabit olduğundan (bkz. Mutability ve BigInteger Yapısı) ve üst veya alt sınırları olmadığından, OutOfMemoryException değerin çok fazla büyümesine neden olan herhangi bir işlem için bir BigInteger oluşturulabilir.

Bir BigInteger Nesneni Örnekleme

Bir BigInteger nesnenin örneğini çeşitli yollarla oluşturabilirsiniz:

anahtar sözcüğünü kullanabilir ve oluşturucuya new parametre BigInteger olarak tüm integral veya kayan nokta değerlerini sağlayabilirsiniz. (Kayan nokta değerleri değerine atanmadan BigIntegerönce kesilir.) Aşağıdaki örnekte, anahtar sözcüğünü new kullanarak değerlerin örneğini BigInteger oluşturma işlemi gösterilmektedir.

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

Bir BigInteger değişken bildirebilir ve değer tam sayı türünde olduğu sürece herhangi bir sayısal türde olduğu gibi bir değer atayabilirsiniz. Aşağıdaki örnek atamayı kullanarak bir Int64değerinden bir BigInteger değer oluşturur.

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

Değeri atarsanız veya önce dönüştürürseniz nesneye BigInteger ondalık veya kayan nokta değeri atayabilirsiniz. Aşağıdaki örnek açıkça yayınlar (C#'de) veya bir ve Decimal değerini (Visual Basic'te) Double değerine BigIntegerdönüştürür.

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

Bu yöntemler, değeri yalnızca mevcut sayısal türlerden birinin aralığında olan bir BigInteger nesnenin örneğini oluşturmanızı sağlar. Değeri mevcut sayısal türlerin aralığını aşabilen bir BigInteger nesnenin örneğini oluşturmak için üç yoldan birini kullanabilirsiniz:

anahtar sözcüğünü new kullanabilir ve oluşturucuya BigInteger.BigInteger herhangi bir boyutta bayt dizisi sağlayabilirsiniz. Örnek:

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

Bir sayının Parse dize gösterimini öğesine dönüştürmek için BigIntegerveya TryParse yöntemlerini çağırabilirsiniz. Örnek:

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

Sayısal ifade static üzerinde bazı işlemler gerçekleştiren ve hesaplanan BigInteger bir sonuç döndüren bir (Shared Visual Basic'te) BigInteger yöntemini çağırabilirsiniz. Aşağıdaki örnek bunu, sonucu bir öğesine ayarlayıp UInt64.MaxValue atayarak BigIntegeryapar.

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

öğesinin BigInteger başlatılmamış değeri şeklindedir Zero.

BigInteger Değerleri Üzerinde İşlem Gerçekleştirme

Bir örneği, diğer tüm integral türlerini kullandığınız gibi kullanabilirsiniz BigInteger . BigInteger toplama, çıkarma, bölme, çarpma ve tekli olumsuzlama gibi temel matematiksel işlemleri gerçekleştirmenizi sağlamak için standart sayısal işleçleri aşırı yükler. İki değeri birbiriyle karşılaştırmak BigInteger için standart sayısal işleçleri de kullanabilirsiniz. Diğer integral türleri gibi bit BigInteger tabanlı And, Or, , XOrsol shift ve sağ kaydırma işleçlerini de destekler. Özel işleçleri desteklemeyen diller için yapı, BigInteger matematiksel işlemleri gerçekleştirmek için eşdeğer yöntemler de sağlar. Bunlar , , Divide, Multiply, Negateve Subtractdiğer birkaçıdırAdd.

Yapının birçok üyesi BigInteger doğrudan diğer integral türlerinin üyelerine karşılık gelir. Ayrıca, BigInteger aşağıdakiler gibi üyeler ekler:

Sign, bir değerin işaretini gösteren bir BigInteger değer döndürür.
Abs, bir BigInteger değerin mutlak değerini döndürür.
DivRem, bir bölme işleminin hem bölümünü hem de kalanını döndürür.
GreatestCommonDivisor, iki BigInteger değerin en büyük ortak böleni döndürür.

Bu ek üyelerin çoğu, ilkel sayısal türlerle çalışma işlevselliği sağlayan sınıfın üyelerine Math karşılık gelir.

Değişebilirlik ve BigInteger Yapısı

Aşağıdaki örnek bir BigInteger nesnesinin örneğini oluşturur ve değerini bir artırır.

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)

Bu örnek, var olan nesnenin değerini değiştirmek için görünse de, bu durum geçerli değildir. BigInteger nesneleri sabittir, yani ortak dil çalışma zamanı aslında yeni BigInteger bir nesne oluşturur ve önceki değerinden daha büyük bir değer atar. Bu yeni nesne daha sonra çağırana döndürülür.

Not

.NET'teki diğer sayısal türler de sabittir. Ancak, türün BigInteger üst veya alt sınırları olmadığından değerleri son derece büyüyebilir ve performans üzerinde ölçülebilir bir etkiye sahip olabilir.

Bu işlem çağıran için saydam olsa da, bir performans cezasına neden olur. Bazı durumlarda, özellikle çok büyük BigInteger değerler üzerinde bir döngüde yinelenen işlemler gerçekleştirildiğinde, bu performans cezası önemli olabilir. Örneğin, aşağıdaki örnekte, bir işlem tekrar tekrar bir milyon kez gerçekleştirilir ve işlem her başarılı olduğunda bir BigInteger değer artırılır.

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

Böyle bir durumda, bir Int32 değişkene tüm ara atamaları gerçekleştirerek performansı geliştirebilirsiniz. Daha sonra döngü çıktığında değişkenin BigInteger son değeri nesnesine atanabilir. Aşağıdaki örnek, bir gösterim sağlar.

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

Bayt Dizileri ve Onaltılık Dizeler ile Çalışma

Değerleri bayt dizilerine dönüştürürseniz BigInteger veya bayt dizilerini değerlere dönüştürürseniz bayt sırasını dikkate BigInteger almanız gerekir. Yapı, BigInteger bayt dizisindeki tek tek baytların küçük endian sırada görünmesini bekler (yani, değerin alt sıralı baytları daha yüksek sıralı baytlardan önce gelir). Aşağıdaki örnekte gösterildiği gibi, yöntemini çağırıp ToByteArray sonuçta elde edilen bayt dizisini oluşturucuya BigInteger(Byte[]) geçirerek bir BigInteger değeri gidiş dönüş yapabilirsiniz.

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

Başka bir BigInteger integral türünün değerini temsil eden bir bayt dizisinden bir değerin örneğini oluşturmak için, integral değerini yöntemine BitConverter.GetBytes geçirebilir ve ardından sonuçta elde edilen bayt dizisini oluşturucuya BigInteger(Byte[]) geçirebilirsiniz. Aşağıdaki örnek, bir BigInteger değeri temsil eden bayt dizisinden bir değerin örneğini Int16 oluşturur.

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

Yapı, BigInteger negatif değerlerin ikinin tamamlayıcı gösterimi kullanılarak depolandığını varsayar. BigInteger Yapı sabit uzunluğu olmayan sayısal bir değeri temsil ettiğindenBigInteger(Byte[]), oluşturucu her zaman dizideki son baytın en önemli bitini bir işaret biti olarak yorumlar. Oluşturucunun BigInteger(Byte[]) negatif bir değerin tamamlayıcı gösterimini pozitif değerin işareti ve büyüklük gösterimiyle karıştırmasını önlemek için, bayt dizisindeki son baytın en önemli bitinin normalde ayarlanacağı pozitif değerler, değeri 0 olan ek bir bayt içermelidir. Örneğin, 0xC0 0xBD 0xF0 0xFF -1.000.000 veya 4.293.967.296'nın küçük endian onaltılık gösterimidir. Bu dizideki son baytın en önemli biti açık olduğundan, bayt dizisinin değeri oluşturucu tarafından BigInteger(Byte[]) -1.000.000 olarak yorumlanır. Değeri pozitif olan bir BigInteger örneği oluşturmak için öğeleri 0xC0 0xBD 0xF0 0xFF 0x00 olan bir bayt dizisi oluşturucuya geçirilmelidir. Aşağıdaki örnek bunu göstermektedir.

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

Yöntemi tarafından ToByteArray pozitif değerlerden oluşturulan bayt dizileri bu fazladan sıfır değerli bayt içerir. Bu nedenle yapı, BigInteger değerleri aşağıdaki örnekte gösterildiği gibi bayt dizilerine atayarak ve sonra bayt dizilerinden geri yükleyerek başarıyla gidiş dönüş yapabilir.

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

Ancak, geliştirici tarafından dinamik olarak oluşturulan veya imzalanmamış tamsayıları bayt dizilerine (, ve BitConverter.GetBytes(UInt64)gibiBitConverter.GetBytes(UInt16)BitConverter.GetBytes(UInt32)) dönüştüren yöntemler tarafından döndürülen bayt dizilerine bu ek sıfır değerli bayt değerini eklemeniz gerekebilir.

Bir onaltılık dize ayrıştırılırken ve BigInteger.Parse(String, NumberStyles, IFormatProvider) yöntemleri, BigInteger.Parse(String, NumberStyles) dizedeki ilk baytın en önemli biti ayarlanırsa veya dizenin ilk onaltılık basaması bir bayt değerinin alt dört bitini temsil ederse, değerin ikinin tamamlayıcı gösterimi kullanılarak temsil edilir olduğunu varsayar. Örneğin, hem "FF01" hem de "F01" ondalık değeri -255'i temsil eder. Pozitifi negatif değerlerden ayırmak için pozitif değerler baştaki sıfırı içermelidir. Yönteminin ToString ilgili aşırı yüklemeleri, "X" biçim dizesi geçirildiğinde, pozitif değerler için döndürülen onaltılık dizeye baştaki sıfırı ekler. Bu, aşağıdaki örnekte gösterildiği gibi ve Parse yöntemlerini kullanarak ToString gidiş dönüş BigInteger değerlerinin mümkün olmasını sağlar.

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.

Ancak, diğer integral türlerinin ToString yöntemlerini çağırarak oluşturulan onaltılık dizeler veya parametre toBase içeren yöntemin ToString aşırı yüklemeleri, değerin işaretini veya onaltılık dizenin türetildiği kaynak veri türünü göstermez. Böyle bir dizeden bir BigInteger değerin başarıyla örneğini oluşturmak için ek mantık gerekir. Aşağıdaki örnek olası bir uygulama sağlar.

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.

Oluşturucular

BigInteger(Byte[])	Bayt dizisindeki BigInteger değerleri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(Decimal)	Bir değer kullanarak yapının yeni bir Decimal örneğini BigInteger başlatır.
BigInteger(Double)	Çift duyarlıklı kayan BigInteger nokta değeri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(Int32)	32 bit imzalı bir tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.
BigInteger(Int64)	64 bit imzalı bir tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Salt okunur bayt aralığındaki değerleri kullanarak ve isteğe bağlı olarak imzalama kodlamasını ve endianness bayt sırasını belirterek yapının yeni bir örneğini BigInteger başlatır.
BigInteger(Single)	Tek duyarlıklı kayan BigInteger nokta değeri kullanarak yapının yeni bir örneğini başlatır.
BigInteger(UInt32)	İmzasız bir 32 bit tamsayı değeri kullanarak yapının yeni bir örneğini BigInteger başlatır.
BigInteger(UInt64)	İmzasız bir 64 bit tamsayı değeriyle yapının yeni bir örneğini BigInteger başlatır.

Özellikler

IsEven	Geçerli BigInteger nesnenin değerinin çift sayı olup olmadığını gösterir.
IsOne	Geçerli BigInteger nesnenin değerinin olup Oneolmadığını gösterir.
IsPowerOfTwo	Geçerli BigInteger nesnenin değerinin iki üssü olup olmadığını gösterir.
IsZero	Geçerli BigInteger nesnenin değerinin olup Zeroolmadığını gösterir.
MinusOne	Negatif bir sayıyı (-1) temsil eden bir değer alır.
One	Bir sayısını (1) temsil eden bir değer alır.
Sign	Geçerli BigInteger nesnenin işaretini (negatif, pozitif veya sıfır) gösteren bir sayı alır.
Zero	0 (sıfır) sayısını temsil eden bir değer alır.

Yöntemler

Abs(BigInteger)	Bir BigInteger nesnenin mutlak değerini alır.
Add(BigInteger, BigInteger)	İki BigInteger değer ekler ve sonucu döndürür.
Clamp(BigInteger, BigInteger, BigInteger)	Bir değeri kapsayıcı bir minimum ve maksimum değere kelepçeler.
Compare(BigInteger, BigInteger)	İki BigInteger değeri karşılaştırır ve ilk değerin ikinci değerden küçük, buna eşit veya daha büyük olduğunu belirten bir tamsayı döndürür.
CompareTo(BigInteger)	Bu örneği bir saniyeyle BigInteger karşılaştırır ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, buna eşit veya ondan büyük olup olmadığını gösteren bir tamsayı döndürür.
CompareTo(Int64)	Bu örneği işaretli bir 64 bit tamsayıyla karşılaştırır ve bu örneğin değerinin imzalı 64 bit tamsayı değerinden küçük, buna eşit veya ondan büyük olup olmadığını gösteren bir tamsayı döndürür.
CompareTo(Object)	Bu örneği belirtilen nesneyle karşılaştırır ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, buna eşit veya ondan büyük olup olmadığını belirten bir tamsayı döndürür.
CompareTo(UInt64)	Bu örneği işaretsiz bir 64 bit tamsayıyla karşılaştırır ve bu örneğin değerinin işaretsiz 64 bit tamsayı değerinden küçük, buna eşit veya ondan büyük olup olmadığını gösteren bir tamsayı döndürür.
CopySign(BigInteger, BigInteger)	Bir değerin işaretini başka bir değerin işaretine kopyalar.
Divide(BigInteger, BigInteger)	Bir değeri diğerine BigInteger böler ve sonucu döndürür.
DivRem(BigInteger, BigInteger)	İki değerin bölümünü ve kalanını hesaplar.
DivRem(BigInteger, BigInteger, BigInteger)	Bir değeri başka bir BigInteger değere böler, sonucu döndürür ve kalan değeri bir çıkış parametresinde döndürür.
Equals(BigInteger)	Geçerli örnekle belirtilen BigInteger nesnenin aynı değere sahip olup olmadığını gösteren bir değer döndürür.
Equals(Int64)	Geçerli örnekle imzalı 64 bitlik tamsayının aynı değere sahip olup olmadığını gösteren bir değer döndürür.
Equals(Object)	Geçerli örnekle belirtilen nesnenin aynı değere sahip olup olmadığını gösteren bir değer döndürür.
Equals(UInt64)	Geçerli örnekle işaretsiz 64 bitlik tamsayının aynı değere sahip olup olmadığını gösteren bir değer döndürür.
GetBitLength()	İşaret biti olmadan geçerli örneğin en kısa ikisinin tamamlayıcı gösterimi için gereken bit sayısını alır.
GetByteCount(Boolean)	ve TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)tarafından ToByteArray(Boolean, Boolean) çıkış yapılacak bayt sayısını alır.
GetHashCode()	Geçerli BigInteger nesnenin karma kodunu döndürür.
GreatestCommonDivisor(BigInteger, BigInteger)	İki BigInteger değerin en büyük ortak böleni bulur.
IsEvenInteger(BigInteger)	Bir değerin çift tam sayı olup olmadığını belirler.
IsNegative(BigInteger)	Bir değerin negatif olup olmadığını belirler.
IsOddInteger(BigInteger)	Bir değerin tek integralli bir sayıyı temsil eder olup olmadığını belirler.
IsPositive(BigInteger)	Bir değerin pozitif olup olmadığını belirler.
IsPow2(BigInteger)	Bir değerin ikinin gücü olup olmadığını belirler.
LeadingZeroCount(BigInteger)	Bir değerdeki baştaki sıfırların sayısını hesaplar.
Log(BigInteger)	Belirtilen sayının doğal (temel `e`) logaritması döndürür.
Log(BigInteger, Double)	Belirtilen bir tabandaki belirtilen sayının logaritması döndürür.
Log10(BigInteger)	Belirtilen sayının 10 tabanındaki logaritması döndürür.
Log2(BigInteger)	Bir değerin log2'sini hesaplar.
Max(BigInteger, BigInteger)	İki BigInteger değerin büyük olanını döndürür.
MaxMagnitude(BigInteger, BigInteger)	İki değeri daha büyük olan işlemle karşılaştırır.
Min(BigInteger, BigInteger)	İki BigInteger değerin küçük olanını döndürür.
MinMagnitude(BigInteger, BigInteger)	daha küçük olan iki değeri işlemle karşılaştırır.
ModPow(BigInteger, BigInteger, BigInteger)	Başka bir sayının gücüne yükseltilmiş bir sayı üzerinde modül bölme gerçekleştirir.
Multiply(BigInteger, BigInteger)	İki BigInteger değerin çarpımını döndürür.
Negate(BigInteger)	Belirtilen BigInteger değeri geçersiz verir.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Belirtilen salt okunur karakter aralığında bulunan bir sayının gösterimini, belirtilen stildeki eşdeğerine BigInteger dönüştürür.
Parse(String)	Bir sayının dize gösterimini eşdeğerine BigInteger dönüştürür.
Parse(String, IFormatProvider)	Belirtilen kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine BigInteger dönüştürür.
Parse(String, NumberStyles)	Belirtilen stildeki bir sayının dize gösterimini eşdeğerine BigInteger dönüştürür.
Parse(String, NumberStyles, IFormatProvider)	Belirtilen stildeki ve kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine BigInteger dönüştürür.
PopCount(BigInteger)	Bir değerde ayarlanan bit sayısını hesaplar.
Pow(BigInteger, Int32)	Değeri BigInteger belirtilen değerin gücüne yükseltir.
Remainder(BigInteger, BigInteger)	İki BigInteger değer üzerinde tamsayı bölme gerçekleştirir ve kalanı döndürür.
RotateLeft(BigInteger, Int32)	Değeri belirli bir miktar sola döndürür.
RotateRight(BigInteger, Int32)	Değeri belirli bir miktar sağa döndürür.
Subtract(BigInteger, BigInteger)	Bir değeri diğerinden BigInteger çıkarır ve sonucu döndürür.
ToByteArray()	Bir BigInteger değeri bayt dizisine dönüştürür.
ToByteArray(Boolean, Boolean)	Bunun değerini BigInteger mümkün olan en az bayt sayısını kullanarak bayt dizisi olarak döndürür. Değer sıfırsa, öğesi 0x00 olan bir baytlık bir dizi döndürür.
ToString()	Geçerli BigInteger nesnenin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak geçerli BigInteger nesnenin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String)	Belirtilen biçimi kullanarak geçerli BigInteger nesnenin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Belirtilen biçimi ve kültüre özgü biçim bilgilerini kullanarak geçerli BigInteger nesnenin sayısal değerini eşdeğer dize gösterimine dönüştürür.
TrailingZeroCount(BigInteger)	Bir değerdeki sondaki sıfırların sayısını hesaplar.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Bu büyük tamsayı örneğini bir karakter aralığına dönüştürür.
TryParse(ReadOnlySpan<Char>, BigInteger)	Belirtilen salt okunur karakter aralığında bulunan bir sayının gösterimini eşdeğerine BigInteger dönüştürmeye çalışır ve dönüştürmenin başarılı olup olmadığını belirten bir değer döndürür.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Bir karakter aralığını bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Bir sayının dize gösterimini eşdeğerine BigInteger dönüştürmeyi dener ve dönüştürmenin başarılı olup olmadığını belirten bir değer döndürür.
TryParse(String, BigInteger)	Bir sayının dize gösterimini eşdeğerine BigInteger dönüştürmeyi dener ve dönüştürmenin başarılı olup olmadığını belirten bir değer döndürür.
TryParse(String, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Belirtilen stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine BigInteger dönüştürmeyi dener ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Bunun BigInteger değerini, mümkün olan en az bayt sayısını kullanarak küçük endian twos-complement bayt olarak kopyalar. Değer sıfırsa, öğesi 0x00 olan bir bayt verir.

İşleçler

Addition(BigInteger, BigInteger)	Belirtilen BigInteger iki nesnenin değerlerini ekler.
BitwiseAnd(BigInteger, BigInteger)	İki BigInteger değer üzerinde bit düzeyinde `And` bir işlem gerçekleştirir.
BitwiseOr(BigInteger, BigInteger)	İki BigInteger değer üzerinde bit düzeyinde `Or` bir işlem gerçekleştirir.
Decrement(BigInteger)	Bir BigInteger değeri 1'e kadar azaltma.
Division(BigInteger, BigInteger)	Tamsayı bölmeyi kullanarak belirtilen BigInteger değeri belirtilen BigInteger başka bir değere böler.
Equality(BigInteger, BigInteger)	İki BigInteger nesnenin değerlerinin eşit olup olmadığını gösteren bir değer döndürür.
Equality(BigInteger, Int64)	Bir değerin ve imzalı uzun tamsayı değerinin eşit olup olmadığını BigInteger gösteren bir değer döndürür.
Equality(BigInteger, UInt64)	Bir değerin ve işaretsiz bir uzun tamsayı değerinin eşit olup olmadığını BigInteger gösteren bir değer döndürür.
Equality(Int64, BigInteger)	İmzalı uzun tamsayı değeriyle değerin eşit olup olmadığını gösteren bir BigInteger değer döndürür.
Equality(UInt64, BigInteger)	İşaretsiz bir uzun tamsayı değeriyle değerin eşit olup olmadığını gösteren bir BigInteger değer döndürür.
ExclusiveOr(BigInteger, BigInteger)	İki BigInteger değer üzerinde bit düzeyinde özel `Or` kullanım (`XOr`) işlemi gerçekleştirir.
Explicit(BigInteger to Byte)	Bir BigInteger nesnenin işaretsiz bayt değerine açık bir dönüştürmesini tanımlar.
Explicit(BigInteger to Char)	Büyük bir tamsayıyı açıkça bir Char değere dönüştürür.
Explicit(BigInteger to Decimal)	Nesnenin BigInteger bir değere açık dönüştürmesini Decimal tanımlar.
Explicit(BigInteger to Double)	Nesnenin BigInteger bir değere açık dönüştürmesini Double tanımlar.
Explicit(BigInteger to Half)	Büyük bir tamsayıyı açıkça bir Half değere dönüştürür.
Explicit(BigInteger to Int128)	Büyük bir tamsayıyı açıkça bir Int128 değere dönüştürür.
Explicit(BigInteger to Int16)	Bir BigInteger nesnenin 16 bit imzalı tamsayı değerine açık dönüştürmesini tanımlar.
Explicit(BigInteger to Int32)	Bir BigInteger nesnenin 32 bit imzalı tamsayı değerine açık dönüştürmesini tanımlar.
Explicit(BigInteger to Int64)	Bir BigInteger nesnenin 64 bit imzalı tamsayı değerine açık dönüştürmesini tanımlar.
Explicit(BigInteger to IntPtr)	Büyük bir tamsayıyı açıkça bir IntPtr değere dönüştürür.
Explicit(BigInteger to SByte)	Bir BigInteger nesnenin imzalı 8 bit değere açık bir dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatif: Int16.
Explicit(BigInteger to Single)	Bir BigInteger nesnenin tek duyarlıklı kayan nokta değerine açık dönüştürmesini tanımlar.
Explicit(BigInteger to UInt128)	Büyük bir tamsayıyı açıkça bir UInt128 değere dönüştürür.
Explicit(BigInteger to UInt16)	Bir BigInteger nesnenin işaretsiz 16 bit tamsayı değerine açık bir dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Int32.
Explicit(BigInteger to UInt32)	Bir BigInteger nesnenin işaretsiz 32 bit tamsayı değerine açık bir dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Int64.
Explicit(BigInteger to UInt64)	Bir BigInteger nesnenin işaretsiz 64 bit tamsayı değerine açık bir dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatiftir Double.
Explicit(BigInteger to UIntPtr)	Büyük bir tamsayıyı açıkça bir UIntPtr değere dönüştürür.
Explicit(Complex to BigInteger)	Bir değeri açıkça büyük bir tamsayıya dönüştürür Complex .
Explicit(Decimal to BigInteger)	Nesnenin Decimal bir değere açık dönüştürmesini BigInteger tanımlar.
Explicit(Double to BigInteger)	Bir değerin değere açık bir Double BigInteger dönüştürmesini tanımlar.
Explicit(Half to BigInteger)	Bir değeri açıkça büyük bir tamsayıya dönüştürür Half .
Explicit(Single to BigInteger)	Bir değerin değere açık bir Single BigInteger dönüştürmesini tanımlar.
GreaterThan(BigInteger, BigInteger)	Bir değerin başka BigInteger bir değerden büyük olup olmadığını gösteren bir BigInteger değer döndürür.
GreaterThan(BigInteger, Int64)	değerinin 64 bit imzalı bir tamsayı değerinden büyük olup olmadığını BigInteger gösteren bir değer döndürür.
GreaterThan(BigInteger, UInt64)	Bir değerin 64 bit işaretsiz tamsayıdan büyük olup olmadığını BigInteger gösteren bir değer döndürür.
GreaterThan(Int64, BigInteger)	64 bit imzalı tamsayının bir değerden büyük olup olmadığını gösteren bir BigInteger değer döndürür.
GreaterThan(UInt64, BigInteger)	Bir değerin 64 bit işaretsiz tamsayıdan büyük olup olmadığını BigInteger gösteren bir değer döndürür.
GreaterThanOrEqual(BigInteger, BigInteger)	Bir değerin başka bir değerden büyük mü yoksa başka BigInteger bir değere eşit mi olduğunu belirten bir BigInteger değer döndürür.
GreaterThanOrEqual(BigInteger, Int64)	Bir değerin 64 bit imzalı bir tamsayı değerinden büyük veya buna eşit olup olmadığını BigInteger gösteren bir değer döndürür.
GreaterThanOrEqual(BigInteger, UInt64)	Bir değerin 64 bit işaretsiz tamsayı değerinden büyük veya buna eşit olup olmadığını BigInteger gösteren bir değer döndürür.
GreaterThanOrEqual(Int64, BigInteger)	64 bit işaretli bir tamsayının bir değerden büyük veya buna eşit olup olmadığını gösteren bir BigInteger değer döndürür.
GreaterThanOrEqual(UInt64, BigInteger)	64 bit işaretsiz tamsayının bir değerden büyük veya buna eşit olup olmadığını gösteren bir BigInteger değer döndürür.
Implicit(Byte to BigInteger)	İmzalanmamış bayt değerinin bir değere örtük dönüştürmesini BigInteger tanımlar.
Implicit(Char to BigInteger)	Bir değeri örtük olarak büyük bir tamsayıya dönüştürür Char .
Implicit(Int128 to BigInteger)	Bir değeri örtük olarak büyük bir tamsayıya dönüştürür Int128 .
Implicit(Int16 to BigInteger)	İmzalı bir 16 bit tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar.
Implicit(Int32 to BigInteger)	İmzalı bir 32 bit tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar.
Implicit(Int64 to BigInteger)	İmzalı bir 64 bit tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar.
Implicit(IntPtr to BigInteger)	Bir değeri örtük olarak büyük bir tamsayıya dönüştürür IntPtr .
Implicit(SByte to BigInteger)	8 bit imzalı tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatif: BigInteger(Int32).
Implicit(UInt128 to BigInteger)	Bir değeri örtük olarak büyük bir tamsayıya dönüştürür UInt128 .
Implicit(UInt16 to BigInteger)	16 bit işaretsiz tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatif: Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	32 bit işaretsiz tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatif: Implicit(Int64 to BigInteger).
Implicit(UInt64 to BigInteger)	64 bit işaretsiz tamsayının bir değere örtük dönüştürmesini BigInteger tanımlar. Bu API, CLS uyumlu değildir. Uyumlu alternatif: Double.
Implicit(UIntPtr to BigInteger)	Bir değeri örtük olarak büyük bir tamsayıya dönüştürür UIntPtr .
Increment(BigInteger)	Bir BigInteger değeri 1 artırır.
Inequality(BigInteger, BigInteger)	İki BigInteger nesnenin farklı değerlere sahip olup olmadığını gösteren bir değer döndürür.
Inequality(BigInteger, Int64)	Değerin ve 64 bit imzalı tamsayının eşit olup olmadığını BigInteger gösteren bir değer döndürür.
Inequality(BigInteger, UInt64)	Bir değerin ve 64 bit işaretsiz tamsayının eşit olup BigInteger olmadığını gösteren bir değer döndürür.
Inequality(Int64, BigInteger)	64 bit işaretli bir tamsayı ile değerin eşit olup olmadığını gösteren bir BigInteger değer döndürür.
Inequality(UInt64, BigInteger)	64 bit işaretsiz tamsayı ile değerin eşit olup olmadığını gösteren bir BigInteger değer döndürür.
LeftShift(BigInteger, Int32)	Belirtilen sayıda biti sola kaydıran bir BigInteger değer.
LessThan(BigInteger, BigInteger)	Bir değerin başka BigInteger bir değerden küçük olup olmadığını gösteren bir BigInteger değer döndürür.
LessThan(BigInteger, Int64)	Bir değerin 64 bit imzalı tamsayıdan küçük olup olmadığını BigInteger gösteren bir değer döndürür.
LessThan(BigInteger, UInt64)	Bir değerin 64 bit işaretsiz tamsayıdan küçük olup olmadığını BigInteger gösteren bir değer döndürür.
LessThan(Int64, BigInteger)	64 bit imzalı tamsayının bir değerden küçük olup olmadığını gösteren bir BigInteger değer döndürür.
LessThan(UInt64, BigInteger)	64 bit işaretsiz tamsayının bir değerden küçük olup olmadığını gösteren bir BigInteger değer döndürür.
LessThanOrEqual(BigInteger, BigInteger)	Bir değerin başka bir değerden küçük veya başka BigInteger bir değere eşit olup olmadığını belirten bir BigInteger değer döndürür.
LessThanOrEqual(BigInteger, Int64)	Bir değerin 64 bit imzalı bir BigInteger tamsayıdan küçük veya buna eşit olup olmadığını gösteren bir değer döndürür.
LessThanOrEqual(BigInteger, UInt64)	Bir değerin 64 bit işaretsiz tamsayıdan küçük veya buna eşit olup olmadığını BigInteger gösteren bir değer döndürür.
LessThanOrEqual(Int64, BigInteger)	64 bit imzalı tamsayının bir değerden küçük veya buna eşit olup olmadığını gösteren bir BigInteger değer döndürür.
LessThanOrEqual(UInt64, BigInteger)	64 bit işaretsiz tamsayının bir değerden küçük veya buna eşit olup olmadığını gösteren bir BigInteger değer döndürür.
Modulus(BigInteger, BigInteger)	Belirtilen BigInteger iki değerle bölme sonucu elde eden kalanı döndürür.
Multiply(BigInteger, BigInteger)	Belirtilen BigInteger iki değeri çarpar.
OnesComplement(BigInteger)	Bit düzeyindeki değerin tamamlayıcısını BigInteger döndürür.
RightShift(BigInteger, Int32)	Belirtilen sayıda biti sağa kaydıran bir BigInteger değer.
Subtraction(BigInteger, BigInteger)	Bir değeri başka BigInteger bir BigInteger değerden çıkarır.
UnaryNegation(BigInteger)	Belirtilen BigInteger değerini geçersiz verir.
UnaryPlus(BigInteger)	İşlenenin BigInteger değerini döndürür. (İşlenenin işareti değiştirilmez.)
UnsignedRightShift(BigInteger, Int32)	Değeri belirli bir tutara göre sağa kaydırıyor.

Belirtik Arabirim Kullanımları

IBinaryInteger<BigInteger>.GetByteCount()	bir parçası TryWriteLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IBinaryInteger<BigInteger>.GetShortestBitLength()	Geçerli değerin en kısa ikisinin tamamlayıcı gösteriminin bit cinsinden uzunluğunu alır.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Geçerli değeri büyük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Geçerli değeri küçük endian biçiminde belirli bir span'a yazmaya çalışır.
IComparable.CompareTo(Object)	Bu örneği belirtilen bir nesneyle karşılaştırır ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, buna eşit veya ondan büyük olup olmadığını belirten bir tamsayı döndürür.

Şunlara uygulanır