BigInteger Yapı

Tanım

Rastgele bir büyük işaretli tamsayıyı temsil eder.Represents an arbitrarily large signed integer.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
[<System.Serializable>]
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Devralma
BigInteger
Öznitelikler
Uygulamalar

Açıklamalar

BigIntegerTürü, teorik içindeki değeri üst veya alt sınır olmadan rastgele büyük bir tamsayıyı temsil eden sabit bir türdür.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Türün üyeleri diğer integral türlerine (,,,,,, BigInteger Byte Int16 Int32 Int64 SByte UInt16 UInt32 ve UInt64 türlerine) yakın bir şekilde paraleldir.The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Bu tür, .NET Framework.NET Framework ve özellikleri tarafından belirtilen bir aralığa sahip olan içindeki diğer integral türlerinden farklıdır MinValue MaxValue .This type differs from the other integral types in the .NET Framework.NET Framework, which have a range indicated by their MinValue and MaxValue properties.

Not

BigIntegerTür sabit olduğundan (bkz . değiştirici ve BigInteger yapısınabakın) ve üst veya alt sınır içermediğinden, OutOfMemoryException BigInteger değerin çok büyük büyümesine neden olan herhangi bir işlem için bir oluşturulabilir.Because the BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large.

Bir BigInteger Nesneni ÖrneklemeInstantiating a BigInteger Object

Bir BigInteger nesneyi birkaç yolla örnek oluşturabilirsiniz:You can instantiate a BigInteger object in several ways:

  • newAnahtar sözcüğünü kullanabilir ve bir integral veya kayan nokta değerini bir parametre olarak BigInteger oluşturucuya sağlayabilirsiniz.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Kayan nokta değerleri, öğesine atanmadan önce kesilir BigInteger .) Aşağıdaki örnek, new değerlerini örneklemek için anahtar sözcüğünün nasıl kullanılacağını gösterir BigInteger .(Floating-point values are truncated before they are assigned to the BigInteger.) The following example illustrates how to use the new keyword to instantiate BigInteger values.

    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 bu değer bir tamsayı türü olduğu sürece bir değeri yalnızca herhangi bir sayısal tür olacak şekilde atayabilirsiniz.You can declare a BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. Aşağıdaki örnek, öğesinden bir değer oluşturmak için atama kullanır BigInteger Int64 .The following example uses assignment to create a BigInteger value from an Int64.

    long longValue = 6315489358112;
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • BigIntegerDeğeri atarsanız veya ilk kez dönüştürürseniz, bir nesneye bir Decimal veya kayan nokta değeri atayabilirsiniz.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. Aşağıdaki örnek, (C# ' de) veya ' de bir değeri (Visual Basic) bir olarak dönüştürür Double Decimal BigInteger .The following example explicitly casts (in C#) or converts (in Visual Basic) a Double and a Decimal value to a BigInteger.

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

Bu yöntemler, BigInteger değeri yalnızca varolan sayısal türlerden birinin aralığında olan bir nesne örneğini oluşturmaya olanak sağlar.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. BigIntegerDeğeri, mevcut sayısal türlerin aralığını üç farklı şekilde aşabileceğinden bir nesne örneğini oluşturabilirsiniz:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • newAnahtar sözcüğünü kullanabilir ve oluşturucuya herhangi bir boyutta bir bayt dizisi sağlayabilirsiniz BigInteger.BigInteger .You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Örneğin:For example:

    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).
    
  • Parse TryParse Bir sayının dize gösterimini ' a dönüştürmek için veya yöntemlerini çağırabilirsiniz BigInteger .You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Örneğin:For example:

    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
    
  • Bir static Shared BigInteger sayısal ifadede bir işlem gerçekleştiren ve hesaplanan bir sonuç döndüren bir (Visual Basic) metodunu çağırabilirsiniz BigInteger .You can call a static (Shared in Visual Basic) BigInteger method that performs some operation on a numeric expression and returns a calculated BigInteger result. Aşağıdaki örnek bunu UInt64.MaxValue odakla ve sonucu bir öğesine atamaya göre yapar BigInteger .The following example does this by cubing UInt64.MaxValue and assigning the result to a BigInteger.

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

Öğesinin başlatılmamış değeri BigInteger Zero .The uninitialized value of a BigInteger is Zero.

BigInteger Değerleri Üzerinde İşlem GerçekleştirmePerforming Operations on BigInteger Values

Bir BigInteger örneği, diğer tüm integral türlerini kullandığınız gibi kullanabilirsiniz.You can use a BigInteger instance as you would use any other integral type. BigInteger toplama, çıkarma, bölme, çarpma, çıkarma, Olumsuzlaştırma ve birli olumsuzlama gibi temel matematik işlemlerini gerçekleştirmenize olanak tanımak için standart sayısal işleçleri aşırı yükler.BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. Ayrıca, iki değeri birbirleriyle karşılaştırmak için standart sayısal işleçleri de kullanabilirsiniz BigInteger .You can also use the standard numeric operators to compare two BigInteger values with each other. Diğer integral türleri gibi BigInteger bit düzeyinde And , Or , XOr , sol SHIFT ve sağ kaydırma işleçleri de desteklenir.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Özel işleçleri desteklemeyen diller için, BigInteger Yapı ayrıca matematik işlemleri gerçekleştirmek için eşdeğer yöntemler de sağlar.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Bunlar,,,, Add Divide Multiply Negate Subtract ve diğer birkaç tane içerir.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Yapının birçok üyesi BigInteger , doğrudan diğer integral türlerinin üyelerine karşılık gelir.Many members of the BigInteger structure correspond directly to members of the other integral types. Bunlara ek BigInteger olarak, aşağıdakiler gibi üyeleri de ekler:In addition, BigInteger adds members such as the following:

Bu ek üyelerin çoğu Math , temel sayısal türlerle çalışma işlevlerini sağlayan sınıfının üyelerine karşılık gelir.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Değişebilirlik ve BigInteger YapısıMutability and the BigInteger Structure

Aşağıdaki örnek bir nesnesi başlatır BigInteger ve sonra değerini bir artırır.The following example instantiates a BigInteger object and then increments its value by one.

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, mevcut nesnenin değerini değiştirme gibi görünse de, bu durum değildir.Although this example appears to modify the value of the existing object, this is not the case. BigInteger nesneler sabittir. Bu, dahili olarak ortak dil çalışma zamanının aslında yeni bir BigInteger nesne oluşturduğu ve bu değere önceki değerden daha büyük bir değer atayan anlamına gelir.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new BigInteger object and assigns it a value one greater than its previous value. Bu yeni nesne daha sonra çağırana döndürülür.This new object is then returned to the caller.

Not

.NET Framework diğer sayısal türler de sabittir.The other numeric types in the .NET Framework are also immutable. Ancak, BigInteger türün üst veya alt sınırı olmadığından, değerleri son derece büyüyebilir ve performans üzerinde ölçülebilir bir etkiye sahip olabilir.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Bu işlem arayan tarafından saydam olsa da, bir performans cezası olur.Although this process is transparent to the caller, it does incur a performance penalty. Bazı durumlarda, özellikle de yinelenen işlemler çok büyük değerlerde bir döngüde gerçekleştirildiğinde BigInteger , bu performans cezası önemli olabilir.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Örneğin, aşağıdaki örnekte, bir işlem bir milyon kez kaldı gerçekleştirilir ve BigInteger işlem başarılı olduğunda bir değer bir artırılır.For example, in the following example, an operation is performed repetitively up to a million times, and a BigInteger value is incremented by one every time the operation succeeds.

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 değişkene tüm ara atamaları gerçekleştirerek performansı artırabilirsiniz Int32 .In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. Sonra, değişkenin son değeri, BigInteger döngü çıkış yapıldığında nesnesine atanabilir.The final value of the variable can then be assigned to the BigInteger object when the loop exits. Aşağıdaki örnek, bir gösterim sağlar.The following example provides an illustration.

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ışmaWorking with Byte Arrays and Hexadecimal Strings

BigIntegerDeğerleri bayt dizilerine dönüştürürseniz veya bayt dizilerini BigInteger değerlere dönüştürürseniz, baytların sırasını göz önünde bulundurmanız gerekir.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. BigIntegerYapı, bir bayt dizisindeki ayrı baytların küçük endian düzeninde görünmesini bekler (yani değerin alt sıra baytları daha yüksek sıra baytından önce).The BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). BigInteger ToByteArray Aşağıdaki örnekte gösterildiği gibi, yöntemini çağırarak ve sonra ortaya çıkan bayt dizisini oluşturucuya geçirerek bir değeri gidiş dönüş yapabilirsiniz BigInteger(Byte[]) .You can round-trip a BigInteger value by calling the ToByteArray method and then passing the resulting byte array to the BigInteger(Byte[]) constructor, as the following example shows.

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

BigIntegerDiğer bir integral türünün değerini temsil eden bir bayt dizisinden bir değer oluşturmak için, tamsayı değerini BitConverter.GetBytes yöntemine geçirebilir ve sonra ortaya çıkan bayt dizisini BigInteger(Byte[]) oluşturucuya geçirebilirsiniz.To instantiate a BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the BitConverter.GetBytes method, and then pass the resulting byte array to the BigInteger(Byte[]) constructor. Aşağıdaki örnek, bir BigInteger değeri temsil eden bir bayt dizisinden bir değer oluşturur Int16 .The following example instantiates a BigInteger value from a byte array that represents an Int16 value.

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

BigIntegerYapı, negatif değerlerin iki tamamlayıcı temsili kullanılarak depolandığını varsayar.The BigInteger structure assumes that negative values are stored by using two's complement representation. Yapı, BigInteger sabit uzunlukta olmayan bir sayısal değeri temsil ettiğinden, BigInteger(Byte[]) Oluşturucu her zaman dizideki son baytın en önemli bitini bir işaret biti olarak yorumlar.Because the BigInteger structure represents a numeric value with no fixed length, the BigInteger(Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. BigInteger(Byte[])Oluşturucunun, pozitif bir değerin işaret ve büyüklük gösterimiyle negatif bir değerin iki tamamlayıcı gösterimini karışmasını engellemek için, bayt dizisindeki son baytın en önemli bitinin normalde ayarlandığı pozitif değerler, değeri 0 olan ek bir bayt içermelidir.To prevent the BigInteger(Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. Örneğin, 0xC0 0xBD 0xF0 0xFF,-1.000.000 ya da 4.293.967.296 ' nin küçük endian onaltılı gösterimidir.For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Bu dizideki son baytın en önemli biti açık olduğundan, bayt dizisinin değeri BigInteger(Byte[]) Oluşturucu tarafından-1.000.000 olarak yorumlanır.Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the BigInteger(Byte[]) constructor as -1,000,000. Değeri pozitif olan bir değer örneği oluşturmak için BigInteger , öğeleri 0xC0 0xBD 0xF0 0xFF 0x00 olan bir bayt dizisi oluşturucuya geçirilmelidir.To instantiate a BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. Aşağıdaki örnek bunu göstermektedir.The following example illustrates this.

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      

Pozitif değerlerden yöntemi tarafından oluşturulan bayt dizileri, ToByteArray Bu ek sıfır değerli baytı içerir.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Bu nedenle, BigInteger Yapı, aşağıdaki örnekte gösterildiği gibi, değerleri öğesine atayarak ve sonra Bayt dizileriyle geri yükleyerek, verileri başarıyla yuvarlayabilirler.Therefore, the BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

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, bu ek sıfır değerli baytı, geliştirici tarafından dinamik olarak oluşturulan veya işaretsiz tamsayıları bayt dizilerine (, ve gibi) dönüştüren yöntemler tarafından döndürülen bayt dizilerine eklemeniz gerekebilir BitConverter.GetBytes(UInt16) BitConverter.GetBytes(UInt32) BitConverter.GetBytes(UInt64) .However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), and BitConverter.GetBytes(UInt64)).

Bir onaltılık dizeyi ayrıştırırken, BigInteger.Parse(String, NumberStyles) ve yöntemleri, BigInteger.Parse(String, NumberStyles, IFormatProvider) dizedeki ilk baytın en önemli biti ayarlandığında veya dizenin ilk onaltılı basamak bir bayt değerinin alt dört bitini temsil ediyorsa, değerin iki tamamlayıcı temsili kullanılarak temsil edildiği varsayılır.When parsing a hexadecimal string, the BigInteger.Parse(String, NumberStyles) and BigInteger.Parse(String, NumberStyles, IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. Örneğin, "FF01" ve "F01" her ikisi de # 255 ondalık değerini temsil eder.For example, both "FF01" and "F01" represent the decimal value -255. Negatif değerlerden pozitif değeri ayırt etmek için, pozitif değerler önünde sıfır içermelidir.To differentiate positive from negative values, positive values should include a leading zero. Yöntemin ilgili aşırı yüklemeleri ToString , "X" biçim dizesinin geçirildiği zaman, pozitif değerler için döndürülen onaltılık dizeye önüne sıfır ekler.The relevant overloads of the ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. Bu, BigInteger ToString Parse Aşağıdaki örnekte gösterildiği gibi, ve yöntemlerini kullanarak gidiş dönüş değerlerini de mümkün kılar.This makes it possible to round-trip BigInteger values by using the ToString and Parse methods, as the following example shows.

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, ToString diğer integral türlerinin yöntemleri veya bir parametre içeren metodun aşırı yüklerini çağırarak oluşturulan onaltılık dizeler ToString toBase değerin işaretini veya onaltılı dizenin türetildiği kaynak veri türünü göstermez.However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the ToString method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. Bu tür dizeden bir değerin başarıyla örnekleniyor, BigInteger bazı ek mantık gerektirir.Successfully instantiating a BigInteger value from such a string requires some additional logic. Aşağıdaki örnek, olası bir uygulama sağlar.The following example provides one possible implementation.

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[])

BigIntegerBir bayt dizisindeki değerleri kullanarak yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal)

BigIntegerBir değer kullanarak yapının yeni bir örneğini başlatır Decimal .Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double)

BigIntegerBir çift duyarlıklı kayan nokta değeri kullanarak yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32)

BigInteger32 bitlik işaretli bir tamsayı değeri kullanarak yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64)

BigInteger64 bitlik işaretli bir tamsayı değeri kullanarak yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

, BigInteger Bir salt okuma bayt aralığında değerleri kullanarak yapının yeni bir örneğini başlatır ve isteğe bağlı olarak imzalama kodlamasını ve bitillik bayt sırasını belirtir.Initializes a new instance of the BigInteger structure using the values in a read-only span of bytes, and optionally indicating the signing encoding and the endianness byte order.

BigInteger(Single)

BigIntegerTek duyarlıklı kayan nokta değeri kullanarak yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32)

BigIntegerİşaretsiz 32 bitlik bir tamsayı değeri kullanarak yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64)

BigIntegerİşaretsiz 64 bitlik bir tamsayı değeri ile yapının yeni bir örneğini başlatır.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

Özellikler

IsEven

Geçerli nesnenin değerinin çift sayı olup olmadığını gösterir BigInteger .Indicates whether the value of the current BigInteger object is an even number.

IsOne

Geçerli nesnenin değerinin olup olmadığını gösterir BigInteger One .Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo

Geçerli BigInteger nesne değerinin ikinin üssü olup olmadığını gösterir.Indicates whether the value of the current BigInteger object is a power of two.

IsZero

Geçerli nesnenin değerinin olup olmadığını gösterir BigInteger Zero .Indicates whether the value of the current BigInteger object is Zero.

MinusOne

Negatif sayıyı temsil eden bir değer alır (-1).Gets a value that represents the number negative one (-1).

One

Bir (1) sayısını temsil eden bir değer alır.Gets a value that represents the number one (1).

Sign

Geçerli nesnenin işaretini (negatif, pozitif veya sıfır) gösteren bir sayı alır BigInteger .Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero

0 (sıfır) sayısını temsil eden bir değer alır.Gets a value that represents the number 0 (zero).

Yöntemler

Abs(BigInteger)

Bir nesnenin mutlak değerini alır BigInteger .Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger)

İki BigInteger değer ekler ve sonucu döndürür.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger)

İki değeri karşılaştırır BigInteger ve ilk değerin ikinci değerden küçük, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares two BigInteger values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.

CompareTo(BigInteger)

Bu örneği bir ikincisine karşılaştırır BigInteger ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Int64)

Bu örneği işaretli 64 bitlik bir tamsayı ile karşılaştırır ve bu örneğin değerinin işaretli 64 bit tamsayının değerinden küçük, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

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, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64)

Bu örneği işaretsiz 64 bitlik bir tamsayı ile karşılaştırır ve bu örneğin değerinin işaretsiz 64 bit tamsayının değerinden küçük, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

Divide(BigInteger, BigInteger)

Bir BigInteger değeri diğerine böler ve sonucu döndürür.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger)

Bir BigInteger değeri başka bir değere böler, sonucu döndürür ve bir çıkış parametresindeki kalanı döndürür.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(BigInteger)

Geçerli örneğin ve belirtilen BigInteger nesnenin aynı değere sahip olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Int64)

Geçerli örneğin ve imzalı 64 bit tamsayının aynı değere sahip olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(Object)

Geçerli örneğin ve belirtilen nesnenin aynı değere sahip olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

Geçerli örneğin ve işaretsiz 64 bit tamsayının aynı değere sahip olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetBitLength()

İmza biti olmadan, geçerli örneğin en kısa iki öğesinin tamamlayıcı temsili için gereken bit sayısını alır.Gets the number of bits required for shortest two's complement representation of the current instance without the sign bit.

GetByteCount(Boolean)

Ve tarafından çıkış yapılacak bayt sayısını alır ToByteArray(Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) .Gets the number of bytes that will be output by ToByteArray(Boolean, Boolean) and TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).

GetHashCode()

Geçerli nesnenin karma kodunu döndürür BigInteger .Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger)

İki değerin en büyük ortak bölenini bulur BigInteger .Finds the greatest common divisor of two BigInteger values.

Log(BigInteger)

Belirtilen sayının doğal (taban e ) logaritmasını döndürür.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double)

Belirtilen bir tabanında belirtilen sayının logaritmasını döndürür.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger)

Belirtilen sayının 10 tabanında logaritmasını döndürür.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger)

İki değerden daha büyük bir BigInteger değer döndürür.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger)

İki değerden daha küçük bir BigInteger değer döndürür.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger)

Başka bir sayının gücünden çıkarılan bir sayı üzerinde mod bölmesi gerçekleştirir.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger)

İki değerin çarpımını döndürür BigInteger .Returns the product of two BigInteger values.

Negate(BigInteger)

Belirtilen değeri geçersiz kılar BigInteger .Negates a specified BigInteger value.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Belirtilen bir stildeki karakterlerin belirtilen salt okunurdur aralığında yer alan bir sayının gösterimini, BigInteger eşdeğerine dönüştürür.Converts the representation of a number, contained in the specified read-only span of characters, in a specified style to its BigInteger equivalent.

Parse(String)

Bir sayının dize gösterimini BigInteger eşdeğerine dönüştürür.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, IFormatProvider)

Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini BigInteger eşdeğerine dönüştürür.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(String, NumberStyles)

Belirtilen bir stildeki bir sayının dize gösterimini BigInteger eşdeğerine dönüştürür.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, NumberStyles, IFormatProvider)

Belirtilen bir stilin ve kültüre özgü biçimdeki bir sayının dize gösterimini BigInteger eşdeğerine dönüştürür.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32)

BigIntegerBelirtilen değerin kuvvetine bir değer yükseltir.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger)

İki değer üzerinde tamsayı bölme gerçekleştirir BigInteger ve kalanı döndürür.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger)

Bir BigInteger değeri diğerinden çıkarır ve sonucu döndürür.Subtracts one BigInteger value from another and returns the result.

ToByteArray()

Bir BigInteger değeri bayt dizisine dönüştürür.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean)

Mümkün olan en BigInteger az sayıda baytı kullanarak bu değerin değerini bir bayt dizisi olarak döndürür.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Değer sıfırsa, öğesi 0x00 olan bir baytlık diziyi döndürür.If the value is zero, returns an array of one byte whose element is 0x00.

ToString()

Geçerli nesnenin sayısal değerini BigInteger eşdeğer dize gösterimine dönüştürür.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider)

Geçerli nesnenin sayısal değerini, BigInteger belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String)

Geçerli nesnenin sayısal değerini, BigInteger belirtilen biçimi kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider)

Geçerli nesnenin sayısal değerini, BigInteger belirtilen biçimi ve kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format and culture-specific format information.

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

Bu büyük tamsayı örneğini bir karakter aralığında biçimlendirir.Formats this big integer instance into a span of characters.

TryParse(ReadOnlySpan<Char>, BigInteger)

, Belirtilen salt okunurdur karakter aralığında bulunan bir sayının gösterimini eşdeğerine dönüştürmeye çalışır BigInteger ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.Tries to convert the representation of a number contained in the specified read-only character span, to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

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

Bir sayının dize gösterimini eşdeğerine dönüştürmeye çalışır BigInteger ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(String, BigInteger)

Bir sayının dize gösterimini eşdeğerine dönüştürmeye çalışır BigInteger ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Belirtilen bir stil ve kültüre özgü biçimdeki bir sayının dize gösterimini eşdeğerine dönüştürmeye çalışır BigInteger ve dönüştürmenin başarılı olup olmadığını gösteren bir değer döndürür.Tries to convert the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

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

Bunun değerini, BigInteger mümkün olan en az sayıda baytı kullanarak az endian Twos-tamamlayıcı baytlar olarak kopyalar.Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. Değer sıfırsa, öğesi 0x00 olan bir bayt verir.If the value is zero, outputs one byte whose element is 0x00.

İşleçler

Addition(BigInteger, BigInteger)

Belirtilen iki nesnenin değerlerini ekler BigInteger .Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger)

Andİki değer üzerinde bit düzeyinde işlem gerçekleştirir BigInteger .Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger)

Orİki değer üzerinde bit düzeyinde işlem gerçekleştirir BigInteger .Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger)

BigIntegerDeğeri 1 azaltır.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger)

Belirtilen BigInteger bir değeri BigInteger tamsayı bölümü kullanarak belirtilen başka bir değere böler.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(BigInteger, BigInteger)

İki nesne değerinin eşit olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, Int64)

Bir BigInteger değerin ve işaretli uzun tamsayı değerinin eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, UInt64)

Bir BigInteger değerin ve işaretsiz uzun tamsayı değerinin eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(Int64, BigInteger)

İmzalanan bir uzun tamsayı değerinin ve değerinin eşit olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(UInt64, BigInteger)

İşaretsiz uzun tamsayı değerinin ve değerinin eşit olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger)

İki değer üzerinde bit tabanlı dışlamalı Or ( XOr ) işlem gerçekleştirir BigInteger .Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(BigInteger to Byte)

Bir nesnenin açıkça bir BigInteger işaretsiz bayt değerine dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal)

Bir nesnenin açık bir değere dönüştürülmesini tanımlar BigInteger Decimal .Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double)

Bir nesnenin açık bir değere dönüştürülmesini tanımlar BigInteger Double .Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16)

Bir nesnenin açıkça bir BigInteger 16 bit işaretli tamsayı değerine dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32)

Bir nesnenin açıkça bir BigInteger 32 bitlik işaretli tamsayı değerine dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64)

Bir nesnenin açıkça bir BigInteger 64 bitlik işaretli tamsayı değerine dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte)

Bir BigInteger nesnenin, imzalanmış 8 bitlik bir değere açık bir şekilde dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Int16 .The compliant alternative is Int16.

Explicit(BigInteger to Single)

BigIntegerTek duyarlıklı kayan noktalı değere nesnenin açık bir şekilde dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16)

Bir nesnenin açık bir BigInteger 16 bit tamsayı değerine açıkça dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Int32 .The compliant alternative is Int32.

Explicit(BigInteger to UInt32)

Bir nesnenin açıkça bir BigInteger işaretsiz 32 bitlik tamsayı değerine dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Int64 .The compliant alternative is Int64.

Explicit(BigInteger to UInt64)

Bir nesnenin açıkça bir BigInteger işaretsiz 64 bitlik tamsayı değerine dönüştürülmesini tanımlar.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Double .The compliant alternative is Double.

Explicit(Decimal to BigInteger)

Bir nesnenin açık bir değere dönüştürülmesini tanımlar Decimal BigInteger .Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger)

Değerin açık bir değere dönüştürülmesini tanımlar Double BigInteger .Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(Single to BigInteger)

Değerin açık bir değere dönüştürülmesini tanımlar Single BigInteger .Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(BigInteger, BigInteger)

Değerin başka bir değerden büyük olup olmadığını gösteren bir değer döndürür BigInteger BigInteger .Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThan(BigInteger, Int64)

Bir değerin BigInteger 64 bitlik işaretli tamsayı değerinden büyük olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, UInt64)

Bir BigInteger değerin 64 bitlik işaretsiz bir tamsayıdan büyük olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger)

64 bitlik işaretli bir tamsayının bir değerden büyük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(UInt64, BigInteger)

Bir BigInteger değerin 64 bitlik işaretsiz bir tamsayıdan büyük olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThanOrEqual(BigInteger, BigInteger)

BigIntegerDeğerin başka bir değerden büyük veya ona eşit olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, Int64)

Bir BigInteger değerin 64 bitlik işaretli tamsayı değerinden büyük veya ona eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, UInt64)

Bir BigInteger değerin 64 bitlik işaretsiz bir tamsayı değerinden büyük veya ona eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(Int64, BigInteger)

64 bitlik işaretli bir tamsayının değere eşit veya ondan büyük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(UInt64, BigInteger)

64 bitlik işaretsiz bir tamsayının değere eşit veya ondan büyük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(Byte to BigInteger)

İşaretsiz bir baytın bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int16 to BigInteger)

İşaretli 16 bit tamsayının bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Int32 to BigInteger)

İşaretli 32 bit tamsayının bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int64 to BigInteger)

İşaretli 64 bit tamsayının bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Implicit(SByte to BigInteger)

8 bit işaretli bir tamsayının örtük dönüşümünü bir BigInteger değere tanımlar.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif BigInteger(Int32) .The compliant alternative is BigInteger(Int32).

Implicit(UInt16 to BigInteger)

16 bit işaretsiz tamsayının bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Implicit(Int32 to BigInteger) .The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

32 bitlik işaretsiz tamsayının bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Implicit(Int64 to BigInteger) .The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

64 bitlik işaretsiz tamsayının bir değere örtük olarak dönüştürülmesini tanımlar BigInteger .Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Bu API, CLS uyumlu değildir.This API is not CLS-compliant. Uyumlu alternatif Double .The compliant alternative is Double.

Increment(BigInteger)

BigIntegerDeğeri 1 artırır.Increments a BigInteger value by 1.

Inequality(BigInteger, BigInteger)

İki nesnenin farklı değerlere sahip olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, Int64)

Bir BigInteger değerin ve 64 bitlik işaretli tamsayının eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

Inequality(BigInteger, UInt64)

Bir BigInteger değerin ve 64 bitlik işaretsiz tamsayının eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger)

64 bitlik işaretli bir tamsayı ve değerin eşit olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(UInt64, BigInteger)

64 bitlik işaretsiz bir tamsayı ve bir değerin eşit olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

LeftShift(BigInteger, Int32)

Bir BigInteger değeri belirtilen bit sayısı kadar sola kaydırır.Shifts a BigInteger value a specified number of bits to the left.

LessThan(BigInteger, BigInteger)

BigIntegerDeğerin başka bir değerden küçük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, Int64)

Bir BigInteger değerin 64 bitlik işaretli tamsayıdan daha az olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, UInt64)

Bir BigInteger değerin 64 bitlik işaretsiz bir tam sayıdan küçük olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(Int64, BigInteger)

64 bitlik işaretli bir tamsayının değerden küçük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(UInt64, BigInteger)

64 bitlik işaretsiz bir tamsayının değerden küçük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger)

BigIntegerDeğerin başka bir değere eşit veya ondan küçük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, Int64)

Bir BigInteger değerin 64 bitlik işaretli tamsayıdan küçük veya ona eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

LessThanOrEqual(BigInteger, UInt64)

Bir BigInteger değerin 64 bitlik işaretsiz bir tamsayıya eşit veya ondan küçük olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger)

64 bitlik işaretli bir tamsayının değere eşit veya ondan küçük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(UInt64, BigInteger)

64 bitlik işaretsiz bir tamsayının değere eşit veya ondan küçük olup olmadığını gösteren bir değer döndürür BigInteger .Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

Modulus(BigInteger, BigInteger)

Belirtilen iki değere sahip bölme sonucu olan kalanı döndürür BigInteger .Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger)

Belirtilen iki BigInteger değeri çarpar.Multiplies two specified BigInteger values.

OnesComplement(BigInteger)

Bit düzeyinde birinin bir değerin tamamlayıcı değerini döndürür BigInteger .Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32)

Bir BigInteger değeri belirtilen bit sayısının sağına kaydırır.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger)

Bir BigInteger değeri başka bir BigInteger değerden çıkartır.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger)

Belirtilen BigInteger değerini geçersiz kılar.Negates a specified BigInteger value.

UnaryPlus(BigInteger)

İşlenenin değerini döndürür BigInteger .Returns the value of the BigInteger operand. (İşlenenin işareti değiştirilmez.)(The sign of the operand is unchanged.)

Belirtik Arabirim Kullanımları

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, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

Şunlara uygulanır