BigInteger Struktura

Definicja

Reprezentuje arbitralnie dużą liczbę całkowitą ze znakiem.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
Dziedziczenie
BigInteger
Atrybuty
Implementuje

Uwagi

BigIntegerTyp jest niezmiennym typem, który reprezentuje arbitralnie dużą liczbę całkowitą, której wartość teoretyczna nie ma górnych lub dolnych granic.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Elementy członkowskie BigInteger typu ściśle równoleżnika na inne typy całkowite ( Byte ,,,,,, Int16 Int32 Int64 SByte UInt16 UInt32 i UInt64 ).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Ten typ różni się od innych typów całkowitych w .NET Framework.NET Framework , które mają zakres wskazany przez ich MinValue i MaxValue właściwości.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.

Uwaga

Ponieważ BigInteger Typ jest niezmienny (zobacz zmienność i struktura BigInteger) i ponieważ nie ma żadnych górnych lub dolnych granic, OutOfMemoryException może być zgłaszany dla każdej operacji, która powoduje, że BigInteger wartość jest zbyt duża.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.

Utworzenie wystąpienia obiektu BigIntegerInstantiating a BigInteger Object

Można utworzyć wystąpienie BigInteger obiektu na kilka sposobów:You can instantiate a BigInteger object in several ways:

  • Możesz użyć new słowa kluczowego i podać dowolną wartość całkowitą lub zmiennoprzecinkową jako parametr do BigInteger konstruktora.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Wartości zmiennoprzecinkowe są obcinane przed przypisaniem ich do BigInteger .) Poniższy przykład ilustruje sposób użycia new słowa kluczowego w celu utworzenia wystąpienia BigInteger wartości.(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		
    
  • Można zadeklarować BigInteger zmienną i przypisać ją do wartości tak samo jak dowolnego typu liczbowego, o ile ta wartość jest typem całkowitym.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. Poniższy przykład używa przypisania, aby utworzyć BigInteger wartość z 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
    
  • Można przypisać wartość dziesiętną lub zmiennoprzecinkową do BigInteger obiektu w przypadku rzutowania wartości lub jej pierwszej konwersji.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. Poniższy przykład jawnie rzutuje (w języku C#) lub konwertuje (w Visual Basic) a Double i Decimal wartość na 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      
    

Te metody umożliwiają utworzenie wystąpienia obiektu, BigInteger którego wartość należy do zakresu jednego z istniejących tylko typów liczbowych.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. Można utworzyć wystąpienie BigInteger obiektu, którego wartość może przekroczyć zakres istniejących typów liczbowych na jeden z trzech sposobów:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • Możesz użyć new słowa kluczowego i udostępnić tablicę bajtową dowolnego rozmiaru BigInteger.BigInteger konstruktorowi.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Przykład: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).
    
  • Można wywołać Parse metody lub, TryParse Aby przekonwertować ciąg reprezentujący liczbę na BigInteger .You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Przykład: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
    
  • Można wywołać static Shared metodę (w Visual Basic) BigInteger , która wykonuje kilka operacji na wyrażeniu liczbowym i zwraca obliczony BigInteger wynik.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. Poniższy przykład wykonuje to przez Cubing UInt64.MaxValue i przypisuje wynik do 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
    

Niezainicjowana wartość klasy BigInteger is Zero .The uninitialized value of a BigInteger is Zero.

Wykonywanie operacji na wartościach typu BigIntegerPerforming Operations on BigInteger Values

Można użyć BigInteger wystąpienia, jak używać dowolnego innego typu całkowitego.You can use a BigInteger instance as you would use any other integral type. BigInteger przeciążenia standardowych operatorów liczbowych, aby umożliwić wykonywanie podstawowych operacji matematycznych, takich jak dodawanie, odejmowanie, dzielenie, mnożenie, odejmowanie, Negacja i Jednoargumentowa Negacja.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. Można również użyć standardowych operatorów liczbowych, aby porównać dwie BigInteger wartości ze sobą.You can also use the standard numeric operators to compare two BigInteger values with each other. Podobnie jak w przypadku innych typów całkowitych, BigInteger obsługiwane są również And Operatory bitowe, Or , XOr , przesunięcie w lewo i przesunięcia w prawo.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. W przypadku języków, które nie obsługują operatorów niestandardowych, BigInteger Struktura zapewnia również równoważne metody wykonywania operacji matematycznych.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Należą Add do nich,,,, Divide Multiply Negate Subtract i kilka innych.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Wiele elementów członkowskich BigInteger struktury odpowiada bezpośrednio członkom innych typów całkowitych.Many members of the BigInteger structure correspond directly to members of the other integral types. Ponadto program BigInteger dodaje elementy członkowskie, takie jak następujące:In addition, BigInteger adds members such as the following:

Wiele z tych dodatkowych członków odpowiada członkom Math klasy, która zapewnia funkcjonalność do pracy z pierwotnymi typami liczbowymi.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Zmienność i struktura BigIntegerMutability and the BigInteger Structure

Poniższy przykład tworzy wystąpienie BigInteger obiektu, a następnie zwiększa jego wartość o jeden.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)

Mimo że ten przykład pojawia się, aby zmodyfikować wartość istniejącego obiektu, nie jest to przypadek.Although this example appears to modify the value of the existing object, this is not the case. BigInteger obiekty są niezmienne, co oznacza, że wewnętrznie środowisko uruchomieniowe języka wspólnego w rzeczywistości tworzy nowy BigInteger obiekt i przypisuje mu wartość większą od poprzedniej wartości.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. Ten nowy obiekt jest następnie zwracany do obiektu wywołującego.This new object is then returned to the caller.

Uwaga

Inne typy liczbowe w .NET Framework są również niezmienne.The other numeric types in the .NET Framework are also immutable. Ponieważ jednak typ nie BigInteger ma górnych lub dolnych granic, jego wartości mogą rosnąć bardzo duże i mieć wymierny wpływ na wydajność.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Mimo że ten proces jest niewidoczny dla obiektu wywołującego, wiąże się z nim spadek wydajności.Although this process is transparent to the caller, it does incur a performance penalty. W niektórych przypadkach, zwłaszcza gdy powtarzające się operacje są wykonywane w pętli na bardzo dużych BigInteger wartościach, spadek wydajności może być znaczny.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Na przykład w poniższym przykładzie operacja jest wykonywana wielokrotnie do miliona, a BigInteger wartość jest zwiększana o jeden za każdym razem, gdy operacja się powiedzie.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

W takim przypadku można poprawić wydajność, wykonując wszystkie przydziały pośrednie do Int32 zmiennej.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. Końcowa wartość zmiennej można następnie przypisać do BigInteger obiektu, gdy pętla zostanie zakończona.The final value of the variable can then be assigned to the BigInteger object when the loop exits. Poniższy przykład stanowi ilustrację.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

Praca z tablicami bajtowymi i ciągami znaków szesnastkowychWorking with Byte Arrays and Hexadecimal Strings

W przypadku konwersji BigInteger wartości na tablice typu Byte lub przekonwertowania tablic bajtowych na BigInteger wartości należy wziąć pod uwagę kolejność bajtów.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. BigIntegerStruktura oczekuje, że poszczególne bajty w tablicy bajtów mają być wyświetlane w kolejności little-endian (oznacza to, że bajty o niższej kolejności wartości poprzedzają bajty wyższego rzędu).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). Można zaokrąglić BigInteger wartość przez wywołanie ToByteArray metody, a następnie przekazanie otrzymanej tablicy bajtowej do BigInteger(Byte[]) konstruktora, jak pokazano w poniższym przykładzie.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

Aby utworzyć wystąpienie BigInteger wartości z tablicy bajtowej, która reprezentuje wartość innego typu całkowitego, można przekazać wartość całkowitą do BitConverter.GetBytes metody, a następnie przekazać uzyskaną tablicę bajtów do BigInteger(Byte[]) konstruktora.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. Poniższy przykład tworzy wystąpienie BigInteger wartości z tablicy bajtowej, która reprezentuje Int16 wartość.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

BigIntegerStruktura zakłada, że wartości ujemne są przechowywane przy użyciu reprezentacji uzupełniającej.The BigInteger structure assumes that negative values are stored by using two's complement representation. Ponieważ BigInteger Struktura reprezentuje wartość liczbową bez stałej długości, BigInteger(Byte[]) Konstruktor zawsze interpretuje najbardziej znaczący bit ostatniego bajtu w tablicy jako bit znaku.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. Aby uniemożliwić BigInteger(Byte[]) konstruktorowi mylące reprezentację uzupełniającą wartości ujemnej z reprezentacją znaku i wielkością wartości dodatniej, wartości dodatnie, w których najbardziej znaczący bit ostatniego bajtu w tablicy bajtów zwykle jest ustawiony powinien zawierać dodatkowy bajt, którego wartość wynosi 0.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. Na przykład 0xC0 0xBD 0xF0 0xFF jest reprezentacją szesnastkową w formacie-1 000 000 lub 4 293 967 296.For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Ponieważ najbardziej znaczący bit ostatniego bajtu w tej tablicy jest włączony, wartość tablicy bajtowej byłaby interpretowana przez BigInteger(Byte[]) Konstruktor jako-1 000 000.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. Aby utworzyć wystąpienie BigInteger , którego wartość jest dodatnia, tablica bajtowa, której elementy są 0XC0 0XBD 0XF0 0xFF 0x00 muszą zostać przesłane do konstruktora.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. Ilustruje to poniższy przykład.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      

Tablice bajtowe utworzone przez ToByteArray metodę z wartości dodatnich zawierają ten dodatkowy bajt o wartości zero.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. W związku z tym BigInteger Struktura może pomyślnie zaokrąglić wartości, przypisując je do, a następnie przywracając z tablic bajtowych, jak pokazano w poniższym przykładzie.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

Jednak może być konieczne dodanie tego dodatkowego bajtu wartości zerowej do tablic bajtowych, które są tworzone dynamicznie przez dewelopera lub które są zwracane przez metody, które konwertują liczby całkowite bez znaku na tablice bajtowe (takie jak BitConverter.GetBytes(UInt16) , BitConverter.GetBytes(UInt32) i 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)).

Podczas analizowania ciągu szesnastkowego w BigInteger.Parse(String, NumberStyles) BigInteger.Parse(String, NumberStyles, IFormatProvider) metodach i przyjęto, że jeśli najbardziej znaczący bit pierwszego bajtu w ciągu jest ustawiony lub jeśli Pierwsza cyfra szesnastkowa ciągu reprezentuje mniejsze cztery bity wartości Byte, wartość jest reprezentowana przy użyciu reprezentacji uzupełniającej.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. Na przykład zarówno "FF01", jak i "F01" reprezentują wartość dziesiętną-255.For example, both "FF01" and "F01" represent the decimal value -255. Aby odróżnić wartość dodatnią od wartości ujemnych, wartości dodatnie powinny zawierać zero wiodące.To differentiate positive from negative values, positive values should include a leading zero. Odpowiednie przeciążenia ToString metody, gdy są przenoszone ciągu formatu "X", Dodaj wiodące zero do zwracanego ciągu szesnastkowego dla wartości dodatnich.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. Dzięki temu można zaokrąglić BigInteger wartości przy użyciu ToString Parse metod i, jak pokazano w poniższym przykładzie.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.

Jednak ciągi szesnastkowe tworzone przez wywołanie ToString metod innych typów całkowitych lub przeciążenia ToString metody zawierającej toBase parametr nie wskazują znaku wartości ani typu danych źródłowych, z którego pochodzi ciąg szesnastkowy.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. Pomyślnie utworzono wystąpienie BigInteger wartości z takiego ciągu wymaga pewnej dodatkowej logiki.Successfully instantiating a BigInteger value from such a string requires some additional logic. W poniższym przykładzie przedstawiono jedną możliwą implementację.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.

Konstruktory

BigInteger(Byte[])

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu wartości w tablicy bajtów.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu Decimal wartości.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu wartości zmiennoprzecinkowej o podwójnej precyzji.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu 32-bitowej podpisanej wartości całkowitej.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu 64-bitowej podpisanej wartości całkowitej.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu wartości z zakresu tylko do odczytu bajtów i opcjonalnie wskazujących kodowanie podpisywania i kolejność bajtów endian.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)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu wartości zmiennoprzecinkowej o pojedynczej precyzji.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32)

Inicjuje nowe wystąpienie BigInteger struktury przy użyciu niepodpisanej 32-bitowej liczby całkowitej.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64)

Inicjuje nowe wystąpienie BigInteger struktury z niepodpisanym 64-bitową wartością całkowitą.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

Właściwości

IsEven

Wskazuje, czy wartość bieżącego BigInteger obiektu jest liczbą parzystą.Indicates whether the value of the current BigInteger object is an even number.

IsOne

Wskazuje, czy wartość bieżącego BigInteger obiektu to One .Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo

Wskazuje, czy wartość bieżącego BigInteger obiektu jest potęgą liczby dwa.Indicates whether the value of the current BigInteger object is a power of two.

IsZero

Wskazuje, czy wartość bieżącego BigInteger obiektu to Zero .Indicates whether the value of the current BigInteger object is Zero.

MinusOne

Pobiera wartość reprezentującą liczbę ujemną (-1).Gets a value that represents the number negative one (-1).

One

Pobiera wartość reprezentującą liczbę (1).Gets a value that represents the number one (1).

Sign

Pobiera liczbę wskazującą znak (ujemny, dodatni lub zero) bieżącego BigInteger obiektu.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero

Pobiera wartość reprezentującą liczbę 0 (zero).Gets a value that represents the number 0 (zero).

Metody

Abs(BigInteger)

Pobiera wartość bezwzględną BigInteger obiektu.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger)

Dodaje dwie BigInteger wartości i zwraca wynik.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger)

Porównuje dwie BigInteger wartości i zwraca liczbę całkowitą, która wskazuje, czy pierwsza wartość jest mniejsza niż, równa lub większa od drugiej wartości.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)

Porównuje to wystąpienie z drugim BigInteger i zwraca liczbę całkowitą, która wskazuje, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość określonego obiektu.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)

Porównuje to wystąpienie z podpisaną 64-bitową liczbą całkowitą i zwraca liczbę całkowitą, która wskazuje, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość podpisanej 64-bitowej liczby całkowitej.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)

Porównuje to wystąpienie do określonego obiektu i zwraca liczbę całkowitą, która wskazuje, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość określonego obiektu.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)

Porównuje to wystąpienie do niepodpisanej 64-bitowej liczby całkowitej i zwraca liczbę całkowitą, która wskazuje, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość niepodpisanej liczby całkowitej 64-bitowej.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)

Dzieli jedną BigInteger wartość przez inną i zwraca wynik.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger)

Dzieli jedną BigInteger wartość przez inną, zwraca wynik i zwraca resztę w parametrze wyjściowym.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(BigInteger)

Zwraca wartość wskazującą, czy bieżące wystąpienie i określony BigInteger obiekt mają tę samą wartość.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Int64)

Zwraca wartość wskazującą, czy bieżące wystąpienie i podpisaną 64-bitową liczbę całkowitą mają tę samą wartość.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(Object)

Zwraca wartość wskazującą, czy bieżące wystąpienie i określony obiekt mają tę samą wartość.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

Zwraca wartość wskazującą, czy bieżące wystąpienie i niepodpisane 64-bitowe liczby całkowite mają tę samą wartość.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetBitLength()

Pobiera liczbę bitów wymaganych przez najkrótszą reprezentację uzupełnienia bieżącego wystąpienia bez bitu znaku.Gets the number of bits required for shortest two's complement representation of the current instance without the sign bit.

GetByteCount(Boolean)

Pobiera liczbę bajtów, które będą wyprowadzane przez ToByteArray(Boolean, Boolean) i 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()

Zwraca kod skrótu dla bieżącego BigInteger obiektu.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger)

Znajduje największy wspólny dzielnik dwóch BigInteger wartości.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger)

Zwraca logarytm naturalny (podstawowy e ) podanej liczby.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double)

Zwraca logarytm o podanej liczbie w określonej bazie.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger)

Zwraca logarytm dziesiętny z podanej liczby.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger)

Zwraca większą liczbę dwóch BigInteger wartości.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger)

Zwraca mniejsze z dwóch BigInteger wartości.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger)

Wykonuje dzielenie modulo na liczbę podniesioną do potęgi innej liczby.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger)

Zwraca iloczyn dwóch BigInteger wartości.Returns the product of two BigInteger values.

Negate(BigInteger)

Negacja określonej BigInteger wartości.Negates a specified BigInteger value.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konwertuje reprezentację liczby zawartej w określonym zakresie tylko do odczytu, w określonym stylu do jej BigInteger równoważnej.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)

Konwertuje ciąg reprezentujący liczbę na jego BigInteger odpowiednik.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, IFormatProvider)

Konwertuje ciąg reprezentujący liczbę w określonym formacie specyficznym dla kultury na jego BigInteger odpowiednik.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(String, NumberStyles)

Konwertuje ciąg reprezentujący liczbę w określonym stylu na jego BigInteger odpowiednik.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, NumberStyles, IFormatProvider)

Konwertuje ciąg reprezentujący liczbę w określonym stylu i formacie specyficznym dla kultury na jego BigInteger odpowiednik.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32)

Podnosi BigInteger wartość do potęgi określonej wartości.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger)

Wykonuje dzielenie liczby całkowitej na dwie BigInteger wartości i zwraca resztę.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger)

Odejmuje jedną BigInteger wartość od innej i zwraca wynik.Subtracts one BigInteger value from another and returns the result.

ToByteArray()

Konwertuje BigInteger wartość na tablicę bajtów.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean)

Zwraca wartość tej wartości BigInteger jako tablicę bajtową przy użyciu możliwie najmniejszej liczby bajtów.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Jeśli wartość jest równa zero, zwraca tablicę z jednym bajtem, którego element jest 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

ToString()

Konwertuje wartość liczbową bieżącego BigInteger obiektu na jego równoważną reprezentację w postaci ciągu.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider)

Konwertuje wartość liczbową bieżącego BigInteger obiektu na jego równoważną reprezentację w postaci ciągu przy użyciu określonych informacji o formatowaniu specyficznych dla kultury.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String)

Konwertuje wartość liczbową bieżącego BigInteger obiektu na jego równoważną reprezentację w postaci ciągu przy użyciu określonego formatu.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider)

Konwertuje wartość liczbową bieżącego BigInteger obiektu na jego równoważną reprezentację w postaci ciągu przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury.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)

Formatuje to wystąpienie dużej liczby całkowitej na zakres znaków.Formats this big integer instance into a span of characters.

TryParse(ReadOnlySpan<Char>, BigInteger)

Próbuje skonwertować reprezentację liczby zawartej w określonym zakresie znaków tylko do odczytu, na jej BigInteger odpowiednik, i zwraca wartość wskazującą, czy konwersja powiodła się.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)

Próbuje przekonwertować ciąg reprezentujący liczbę na jego BigInteger odpowiednik i zwraca wartość wskazującą, czy konwersja powiodła się.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)

Próbuje przekonwertować ciąg reprezentujący liczbę na jego BigInteger odpowiednik i zwraca wartość wskazującą, czy konwersja powiodła się.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)

Próbuje przekonwertować ciąg reprezentujący liczbę w określonym stylu i formacie specyficznym dla kultury na jego BigInteger odpowiednik, a następnie zwraca wartość wskazującą, czy konwersja powiodła się.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)

Kopiuje wartość tego elementu BigInteger jako bajty parach-uzupełnienie w postaci little-endian przy użyciu najmniejszej liczby możliwych bajtów.Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. Jeśli wartość jest równa zero, wyprowadza jeden bajt, którego element jest 0x00.If the value is zero, outputs one byte whose element is 0x00.

Operatory

Addition(BigInteger, BigInteger)

Dodaje wartości dwóch określonych BigInteger obiektów.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger)

Wykonuje operację bitową And dla dwóch BigInteger wartości.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger)

Wykonuje operację bitową Or dla dwóch BigInteger wartości.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger)

Zmniejsza BigInteger wartość o 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger)

Dzieli określoną BigInteger wartość przez inną określoną BigInteger wartość przy użyciu dzielenia liczb całkowitych.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(BigInteger, BigInteger)

Zwraca wartość wskazującą, czy wartości dwóch BigInteger obiektów są równe.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, Int64)

Zwraca wartość wskazującą, czy BigInteger wartość i ze znakową wartością Long integer są równe.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, UInt64)

Zwraca wartość wskazującą, czy BigInteger wartość i niepodpisana wartość Long integer są równe.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(Int64, BigInteger)

Zwraca wartość wskazującą, czy podpisana wartość długa Long i BigInteger wartość są równe.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(UInt64, BigInteger)

Zwraca wartość wskazującą, czy wartość długa Long integer i BigInteger wartość są równe.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger)

Wykonuje bitową operację wykluczającą Or ( XOr ) dla dwóch BigInteger wartości.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(BigInteger to Byte)

Definiuje jawną konwersję BigInteger obiektu na wartość bajtu bez znaku.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal)

Definiuje jawną konwersję BigInteger obiektu na Decimal wartość.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double)

Definiuje jawną konwersję BigInteger obiektu na Double wartość.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16)

Definiuje jawną konwersję BigInteger obiektu na 16-bitową liczbę całkowitą ze znakiem.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32)

Definiuje jawną konwersję BigInteger obiektu na 32-bitową liczbę całkowitą ze znakiem.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64)

Definiuje jawną konwersję BigInteger obiektu na 64-bitową liczbę całkowitą ze znakiem.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte)

Definiuje jawną konwersję BigInteger obiektu do podpisanej wartości 8-bitowej.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Int16 .The compliant alternative is Int16.

Explicit(BigInteger to Single)

Definiuje jawną konwersję BigInteger obiektu do wartości zmiennoprzecinkowej o pojedynczej precyzji.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16)

Definiuje jawną konwersję BigInteger obiektu na 16-bitową liczbę całkowitą bez znaku.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Int32 .The compliant alternative is Int32.

Explicit(BigInteger to UInt32)

Definiuje jawną konwersję BigInteger obiektu na wartość 32-bitową liczbę całkowitą bez znaku.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Int64 .The compliant alternative is Int64.

Explicit(BigInteger to UInt64)

Definiuje jawną konwersję BigInteger obiektu na wartość 64-bitową liczbę całkowitą bez znaku.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Double .The compliant alternative is Double.

Explicit(Decimal to BigInteger)

Definiuje jawną konwersję Decimal obiektu na BigInteger wartość.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger)

Definiuje jawną konwersję Double wartości do BigInteger wartości.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(Single to BigInteger)

Definiuje jawną konwersję Single wartości do BigInteger wartości.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(BigInteger, BigInteger)

Zwraca wartość wskazującą, czy BigInteger wartość jest większa niż inna BigInteger wartość.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThan(BigInteger, Int64)

Zwraca wartość wskazującą, czy wartość BigInteger jest większa niż 64-bitowa liczba całkowita ze znakiem.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, UInt64)

Zwraca wartość wskazującą, czy BigInteger wartość jest większa niż 64-bitowa liczba całkowita bez znaku.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita ze znakiem jest większa niż BigInteger wartość.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(UInt64, BigInteger)

Zwraca wartość wskazującą, czy BigInteger wartość jest większa niż 64-bitowa liczba całkowita bez znaku.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThanOrEqual(BigInteger, BigInteger)

Zwraca wartość wskazującą, czy BigInteger wartość jest większa lub równa innej BigInteger wartości.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, Int64)

Zwraca wartość wskazującą, czy BigInteger wartość jest większa lub równa 64-bitowej podpisanej wartości całkowitej.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, UInt64)

Zwraca wartość wskazującą, czy BigInteger wartość jest większa lub równa wartości 64-bitowej nieoznaczonej liczby całkowitej.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(Int64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita ze znakiem jest większa lub równa BigInteger wartości.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(UInt64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita bez znaku jest większa lub równa BigInteger wartości.Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(Byte to BigInteger)

Definiuje niejawną konwersję bajtu bez znaku na BigInteger wartość.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int16 to BigInteger)

Definiuje niejawną konwersję 16-bitowej liczby całkowitej ze znakiem na BigInteger wartość.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Int32 to BigInteger)

Definiuje niejawną konwersję podpisanej 32-bitowej liczby całkowitej na BigInteger wartość.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int64 to BigInteger)

Definiuje niejawną konwersję podpisanej 64-bitowej liczby całkowitej na BigInteger wartość.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Implicit(SByte to BigInteger)

Definiuje niejawną konwersję 8-bitowej podpisanej liczby całkowitej na BigInteger wartość.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to BigInteger(Int32) .The compliant alternative is BigInteger(Int32).

Implicit(UInt16 to BigInteger)

Definiuje niejawną konwersję 16-bitowej liczby całkowitej bez znaku na BigInteger wartość.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Implicit(Int32 to BigInteger) .The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Definiuje niejawną konwersję 32-bitowej liczby całkowitej bez znaku na BigInteger wartość.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Implicit(Int64 to BigInteger) .The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

Definiuje niejawną konwersję 64-bitowej liczby całkowitej bez znaku na BigInteger wartość.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant. Zgodna alternatywa to Double .The compliant alternative is Double.

Increment(BigInteger)

Zwiększa BigInteger wartość o 1.Increments a BigInteger value by 1.

Inequality(BigInteger, BigInteger)

Zwraca wartość wskazującą, czy dwa BigInteger obiekty mają różne wartości.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, Int64)

Zwraca wartość wskazującą, czy BigInteger wartość i 64-bitowa liczba całkowita ze znakiem nie jest równa.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

Inequality(BigInteger, UInt64)

Zwraca wartość wskazującą, czy BigInteger wartość i 64-bitowa liczba całkowita bez znaku nie jest równa.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita ze znakiem i BigInteger wartość nie jest równa.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(UInt64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita bez znaku i BigInteger wartość nie są równe.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

LeftShift(BigInteger, Int32)

Przenosi BigInteger wartość o określoną liczbę bitów z lewej strony.Shifts a BigInteger value a specified number of bits to the left.

LessThan(BigInteger, BigInteger)

Zwraca wartość wskazującą, czy BigInteger wartość jest mniejsza od innej BigInteger wartości.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, Int64)

Zwraca wartość wskazującą, czy BigInteger wartość jest mniejsza niż 64-bitowa liczba całkowita ze znakiem.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, UInt64)

Zwraca wartość wskazującą, czy BigInteger wartość jest mniejsza niż 64-bitowa liczba całkowita bez znaku.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(Int64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita ze znakiem jest mniejsza niż BigInteger wartość.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(UInt64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita bez znaku jest mniejsza niż BigInteger wartość.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger)

Zwraca wartość wskazującą, czy BigInteger wartość jest mniejsza niż lub równa innej BigInteger wartości.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, Int64)

Zwraca wartość wskazującą, czy BigInteger wartość jest mniejsza niż lub równa 64-bitowej podpisanej liczby całkowitej.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

LessThanOrEqual(BigInteger, UInt64)

Zwraca wartość wskazującą, czy BigInteger wartość jest mniejsza niż lub równa 64-bitowej nieoznaczonej liczby całkowitej.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita ze znakiem jest mniejsza lub równa BigInteger wartości.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(UInt64, BigInteger)

Zwraca wartość wskazującą, czy 64-bitowa liczba całkowita bez znaku jest mniejsza lub równa BigInteger wartości.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

Modulus(BigInteger, BigInteger)

Zwraca resztę z dzielenia na dwie określone BigInteger wartości.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger)

Mnoży dwie określone BigInteger wartości.Multiplies two specified BigInteger values.

OnesComplement(BigInteger)

Zwraca wartość z przesunięcia bitowego z jednej BigInteger wartości.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32)

Przesuwa BigInteger wartość o określoną liczbę bitów w prawo.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger)

Odejmuje BigInteger wartość od innej BigInteger wartości.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger)

Wyklucza określoną wartość BigInteger.Negates a specified BigInteger value.

UnaryPlus(BigInteger)

Zwraca wartość BigInteger operandu.Returns the value of the BigInteger operand. (Znak operandu jest niezmieniony).(The sign of the operand is unchanged.)

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje to wystąpienie do określonego obiektu i zwraca liczbę całkowitą, która wskazuje, czy wartość tego wystąpienia jest mniejsza niż, równa lub większa niż wartość określonego obiektu.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.

Dotyczy