BigInteger Struktura

Definice

Představuje svévolně velké celé číslo se znaménkem.Represents an arbitrarily large signed integer.

public value class 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
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Dědičnost
BigInteger
Atributy
Implementuje

Poznámky

Typ BigInteger je neměnný typ, který představuje libovolně velké celé číslo, jehož hodnota teoreticky nemá žádné horní ani dolní meze.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Členy BigInteger typu úzce Parallel s ostatními integrálními typy (Byte, Int16, Int32, Int64, SByte, UInt16, UInt32a UInt64 typy).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Tento typ se liší od ostatních integrálních typů v .NET Framework.NET Framework, které mají rozsah, který je označen vlastnostmi MinValue a 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.

Poznámka

Vzhledem k tomu, že typ BigInteger je neměnný (viz proměnlivost a BigInteger struktura) a protože nemá žádné horní ani dolní meze, může být OutOfMemoryException vyvolán pro všechny operace, které způsobí, že se hodnota BigInteger přesáhne příliš velká.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.

Vytvoření instance objektu BigIntegerInstantiating a BigInteger Object

Instance objektu BigInteger lze vytvořit několika způsoby:You can instantiate a BigInteger object in several ways:

  • Můžete použít klíčové slovo new a zadat jakoukoli hodnotu integrálního nebo plovoucího bodu jako parametr do konstruktoru BigInteger.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Hodnoty s plovoucí desetinnou čárkou se zkrátí předtím, než se přiřadí BigInteger.) Následující příklad ukazuje použití klíčového slova new pro vytvoření instance BigInteger hodnoty.(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		
    
  • Můžete deklarovat BigInteger proměnnou a přiřadit ji jako typ libovolného číselného typu, pokud je tato hodnota integrálního typu.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. Následující příklad používá přiřazení k vytvoření BigInteger hodnoty 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
    
  • Pokud převedete hodnotu nebo ji nejdříve převedete, můžete k objektu BigInteger přiřadit hodnotu typu Decimal nebo s plovoucí desetinnou čárkou.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. Následující příklad explicitně přetypování (in C#) nebo převede (v Visual Basic)Doublea hodnotuDecimalna 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      
    

Tyto metody umožňují vytvořit instanci objektu BigInteger, jehož hodnota je v rozsahu jednoho z existujících číselných typů.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. Můžete vytvořit instanci objektu BigInteger, jehož hodnota může překročit rozsah stávajících číselných typů jedním ze tří způsobů:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • Můžete použít klíčové slovo new a zadat bajtové pole libovolné velikosti konstruktoru BigInteger.BigInteger.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Příklad: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).
    
  • Můžete volat metody Parse nebo TryParse a převést řetězcové vyjádření čísla na BigInteger.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Příklad: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
    
  • Můžete zavolat static (Shared v Visual Basic) BigInteger metodu, která provádí určitou operaci s číselným výrazem a vrátí vypočtený výsledek 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. Následující příklad provede cubing UInt64.MaxValue a přiřadí výsledek 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
    

Neinicializovaná hodnota BigInteger je Zero.The uninitialized value of a BigInteger is Zero.

Provádění operací na hodnotách BigIntegerPerforming Operations on BigInteger Values

Můžete použít instanci BigInteger, protože byste použili jiný integrální typ.You can use a BigInteger instance as you would use any other integral type. BigInteger přetěžuje Standardní číselné operátory, které vám umožní provádět základní matematické operace, jako je sčítání, odčítání, dělení, násobení, odčítání, negace a unární negace.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. Standardní číselné operátory můžete použít také k porovnání dvou BigIntegerch hodnot mezi sebou.You can also use the standard numeric operators to compare two BigInteger values with each other. Stejně jako ostatní integrální typy BigInteger také podporuje bitové operátory And, Or, XOr, levý SHIFT a Right Shift.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Pro jazyky, které nepodporují vlastní operátory, BigInteger struktura také poskytuje ekvivalentní metody pro provádění matematických operací.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Mezi ně patří Add, Divide, Multiply, Negate, Subtracta několik dalších.These include Add, Divide, Multiply, Negate, Subtract, and several others.

Mnoho členů BigInteger struktury odpovídá přímo na členy jiných integrálních typů.Many members of the BigInteger structure correspond directly to members of the other integral types. Kromě toho BigInteger přidá členy, jako jsou následující:In addition, BigInteger adds members such as the following:

Mnohé z těchto dalších členů odpovídají členům třídy Math, která poskytuje funkce pro práci s primitivními číselnými typy.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Proměnlivost a struktura BigIntegerMutability and the BigInteger Structure

Následující příklad vytvoří instanci objektu BigInteger a poté zvýší jeho hodnotu o jednu.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)

I když se tento příklad zobrazí pro úpravu hodnoty existujícího objektu, nejedná se o tento případ.Although this example appears to modify the value of the existing object, this is not the case. objekty BigInteger jsou neměnné, což znamená, že interně modul CLR (Common Language Runtime) ve skutečnosti vytvoří nový objekt BigInteger a přiřadí mu hodnotu, která je větší než předchozí hodnota.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. Tento nový objekt se pak vrátí volajícímu.This new object is then returned to the caller.

Poznámka

Jiné číselné typy v .NET Framework jsou také neměnné.The other numeric types in the .NET Framework are also immutable. Vzhledem k tomu, že typ BigInteger nemá žádné horní ani dolní meze, může jeho hodnoty růst extrémně velké a mít měřitelný dopad na výkon.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

I když je tento proces pro volající transparentní, dochází ke snížení výkonu.Although this process is transparent to the caller, it does incur a performance penalty. V některých případech, zejména při opakovaném provádění operací ve smyčce na velmi velké BigInteger hodnoty, může být snížení výkonu významné.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. V následujícím příkladu se například provede operace opakovaně až milionů časů a hodnota BigInteger se při každém úspěšném provedení zvýší o jednu.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

V takovém případě můžete zvýšit výkon tím, že provedete všechna mezilehlá přiřazení k proměnné Int32.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. Až se smyčka ukončí, může být koncová hodnota proměnné přiřazená k objektu BigInteger.The final value of the variable can then be assigned to the BigInteger object when the loop exits. V následujícím příkladu je uvedena ukázka.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

Práce s bajtovými poli a hexadecimálními řetězciWorking with Byte Arrays and Hexadecimal Strings

Převedete-li BigInteger hodnoty na pole bytů nebo převedete pole bajtů na BigInteger hodnoty, je nutné vzít v úvahu pořadí bajtů.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. Struktura BigInteger očekává, že se jednotlivé bajty v poli bajtů zobrazí v pořadí s malým počtem endian (tj. bajty nižšího řádu před bajty vyššího řá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). BigInteger hodnotu můžete odvolat voláním metody ToByteArray a následně předat výsledné bajtové pole konstruktoru BigInteger(Byte[]), jak ukazuje následující příklad.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

Chcete-li vytvořit instanci BigInteger hodnoty z bajtového pole, které představuje hodnotu nějakého jiného integrálního typu, můžete celočíselnou hodnotu předat metodě BitConverter.GetBytes a pak předat výsledné bajtové pole konstruktoru BigInteger(Byte[]).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. Následující příklad vytvoří instanci BigInteger hodnoty z bajtového pole, které představuje hodnotu 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

Struktura BigInteger předpokládá, že jsou uloženy záporné hodnoty pomocí dvou reprezentace doplňku.The BigInteger structure assumes that negative values are stored by using two's complement representation. Vzhledem k tomu, že struktura BigInteger představuje číselnou hodnotu bez pevné délky, konstruktor BigInteger(Byte[]) vždy interpretuje nejvýznamnější bit posledního bajtu v poli jako bit znaménka.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 nedocházelo k tomu, aby konstruktor BigInteger(Byte[]) odmatoucí reprezentace dvou doplňku záporné hodnoty s znaménkem a rozsahem kladné hodnoty, kladné hodnoty, ve kterých nejvýznamnější bit posledního bajtu v bajtovém poli by byl obvykle je nutné nastavit další bajt, jehož hodnota je 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. Například 0xC0 0xBD 0xF0 0xFF je šestnáctkové vyjádření Little-endian buď-1 000 000 nebo 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. Vzhledem k tomu, že nejvýznamnější bit posledního bajtu v tomto poli je zapnuto, hodnota bajtového pole by byla interpretována konstruktorem BigInteger(Byte[]) 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. Chcete-li vytvořit instanci BigInteger, jehož hodnota je kladná, je nutné předat konstruktoru bajtové pole, jehož prvky jsou 0xC0 0xBD 0xF0 0xFF 0x00.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. Toto dokládá následující příklad.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      

Bajtová pole vytvořená metodou ToByteArray z kladných hodnot zahrnují tento dodatečný bajt s nulovou hodnotou.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Proto struktura BigInteger může úspěšně odzaokrouhlit hodnoty přiřazením k a jejich obnovení z polí bajtů, jak ukazuje následující příklad.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

Je však možné, že budete muset přidat tento další bajt s nulovou hodnotou do polí bajtů, které vývojář vytvoří dynamicky, nebo které jsou vráceny metodami, které převádějí celá čísla bez znaménka na pole bajtů (například BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)a 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)).

Při analýze hexadecimálního řetězce předpokládá BigInteger.Parse(String, NumberStyles) a BigInteger.Parse(String, NumberStyles, IFormatProvider) metody, že pokud je nejvýznamnější bit prvního bajtu v řetězci nastaven, nebo pokud první šestnáctková číslice řetězce představuje dolní čtyři bity hodnoty bajtu , hodnota je reprezentovaná pomocí dvojí reprezentace doplňku.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. Například "FF01" a "F01" představuje desítkovou hodnotu-255.For example, both "FF01" and "F01" represent the decimal value -255. Aby bylo možné odlišit kladné hodnoty od záporných hodnot, měly by kladné hodnoty obsahovat počáteční nuly.To differentiate positive from negative values, positive values should include a leading zero. Příslušné přetížení metody ToString, pokud jsou předány řetězec formátu "X", přidejte počáteční nulu do vráceného šestnáctkového řetězce pro kladné hodnoty.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. Díky tomu je možné BigInteger hodnoty pomocí metod ToString a Parse, jak ukazuje následující příklad.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.

Šestnáctkové řetězce vytvořené voláním ToString metod jiných integrálních typů nebo přetížení metody ToString, která obsahuje parametr toBase, neoznačují znaménko hodnoty nebo zdroj dat, ze kterého je šestnáctkový. řetězec byl odvozen.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. Instance BigInteger hodnoty z takového řetězce se úspěšně vytvořila v nějaké další logice.Successfully instantiating a BigInteger value from such a string requires some additional logic. Následující příklad poskytuje jednu možnou implementaci.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[])

Inicializuje novou instanci BigInteger struktury s použitím hodnot v bajtovém poli.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal)

Inicializuje novou instanci BigInteger struktury pomocí Decimal hodnoty.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double)

Inicializuje novou instanci BigInteger struktury pomocí hodnoty s plovoucí desetinnou čárkou s dvojitou přesností.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32)

Inicializuje novou instanci BigInteger struktury pomocí celočíselné hodnoty se znaménkem 32.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64)

Inicializuje novou instanci BigInteger struktury pomocí celočíselné hodnoty se znaménkem 64.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Inicializuje novou instanci BigInteger struktury s použitím hodnot v rozsahu bajtů jen pro čtení a volitelně označuje kódování podepisování a pořadí bajtů ve formátu 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)

Inicializuje novou instanci BigInteger struktury pomocí hodnoty s plovoucí desetinnou čárkou s jednoduchou přesností.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32)

Inicializuje novou instanci BigInteger struktury pomocí celočíselné hodnoty bez znaménka 32.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64)

Inicializuje novou instanci BigInteger struktury s celočíselnou hodnotou bez znaménka 64.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

Vlastnosti

IsEven

Určuje, zda je hodnota aktuálního objektu BigInteger sudým číslem.Indicates whether the value of the current BigInteger object is an even number.

IsOne

Určuje, zda je hodnota aktuálního objektu BigInteger One.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo

Určuje, zda je hodnota aktuálního objektu BigInteger mocninou dvou.Indicates whether the value of the current BigInteger object is a power of two.

IsZero

Určuje, zda je hodnota aktuálního objektu BigInteger Zero.Indicates whether the value of the current BigInteger object is Zero.

MinusOne

Získá hodnotu, která představuje číslo záporné (-1).Gets a value that represents the number negative one (-1).

One

Získá hodnotu, která představuje číslo One (1).Gets a value that represents the number one (1).

Sign

Získá číslo, které označuje znaménko (záporné, kladné nebo nula) aktuálního objektu BigInteger.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero

Získá hodnotu, která představuje číslo 0 (nula).Gets a value that represents the number 0 (zero).

Metody

Abs(BigInteger)

Získá absolutní hodnotu objektu BigInteger.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger)

Přidá dvě BigInteger hodnoty a vrátí výsledek.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger)

Porovná dvě BigInteger hodnoty a vrátí celé číslo, které označuje, zda je první hodnota menší než, rovna nebo větší než druhá hodnota.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)

Porovná tuto instanci s druhým BigInteger a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.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)

Porovná tuto instanci s podepsaným 64ovým celým číslem a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota nahlášeného čísla se znaménkem (64).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)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.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)

Porovná tuto instanci na celé číslo bez znaménka 64 a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota nepodepsaného 64-bit integer.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)

Vydělí jednu BigInteger hodnotu jinou hodnotou a vrátí výsledek.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger)

Vydělí jednu BigInteger hodnotu jinou hodnotou, vrátí výsledek a vrátí zbytek v parametru Output.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(BigInteger)

Vrátí hodnotu, která označuje, zda aktuální instance a zadaný BigInteger objekt mají stejnou hodnotu.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Int64)

Vrací hodnotu, která označuje, zda aktuální instance a podepsané číslo se znaménkem (64) mají stejnou hodnotu.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(Object)

Vrátí hodnotu, která označuje, zda aktuální instance a zadaný objekt mají stejnou hodnotu.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

Vrací hodnotu, která označuje, zda aktuální instance a celé číslo bez znaménka 64 mají stejnou hodnotu.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean)

Vrátí počet bajtů, které budou výstupem ToByteArray(Boolean, Boolean) a 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()

Vrátí hodnotu hash pro aktuální objekt BigInteger.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger)

Najde největší společný dělitel dvou hodnot BigInteger.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger)

Vrátí logaritmus přirozeného (základního e) zadaného čísla.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double)

Vrátí logaritmus zadaného čísla v zadaném základu.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger)

Vrátí logaritmus o základu 10 zadaného čísla.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger)

Vrátí větší ze dvou BigInteger hodnot.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger)

Vrátí menší ze dvou BigInteger hodnot.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger)

Provede dělení dělení na číslo umocněné na mocninu jiného čísla.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger)

Vrátí součin dvou hodnot BigInteger.Returns the product of two BigInteger values.

Negate(BigInteger)

Negace zadaného BigInteger hodnoty.Negates a specified BigInteger value.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentace čísla obsaženého v zadaném rozsahu znaků určených jen pro čtení v zadaném stylu na jeho BigInteger ekvivalent.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)

Převede řetězcové vyjádření čísla na jeho ekvivalent BigInteger.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho ekvivalent BigInteger.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho ekvivalent BigInteger.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na jeho BigInteger ekvivalent.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32)

Vyvolá hodnotu BigInteger na mocninu zadané hodnoty.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger)

Provádí celočíselné dělení na dvou hodnotách BigInteger a vrátí zbytek.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger)

Odečte jednu BigInteger hodnotu od druhé a vrátí výsledek.Subtracts one BigInteger value from another and returns the result.

ToByteArray()

Převede hodnotu BigInteger na bajtové pole.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean)

Vrátí hodnotu tohoto BigInteger jako bajtové pole s použitím nejmenšího možného počtu bajtů.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Pokud je hodnota nula, vrátí pole jednoho bajtu, jehož element je 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

ToString()

Převede číselnou hodnotu aktuálního objektu BigInteger na odpovídající řetězcovou reprezentaci.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider)

Převede číselnou hodnotu aktuálního objektu BigInteger na jeho ekvivalentní řetězcové vyjádření pomocí zadaných informací o formátování specifické jazykové verze.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String)

Převede číselnou hodnotu aktuálního objektu BigInteger na odpovídající řetězcovou reprezentaci pomocí zadaného formátu.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider)

Převede číselnou hodnotu aktuálního objektu BigInteger na odpovídající řetězcovou reprezentaci pomocí zadaného formátu a informací o formátu specifické jazykové verze.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)

Zformátuje tuto instanci Big Integer do rozsahu znaků.Formats this big integer instance into a span of characters.

TryParse(ReadOnlySpan<Char>, BigInteger)

Pokusí se převést reprezentace čísla obsaženého v zadaném rozsahu znaků jen pro čtení na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.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)

Pokusí se převést řetězcové vyjádření čísla na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.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)

Pokusí se převést řetězcové vyjádření čísla na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.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)

Pokusí se převést řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na jeho BigInteger ekvivalent a vrátí hodnotu, která označuje, zda byl převod úspěšný.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)

Zkopíruje hodnotu tohoto BigInteger jako Little-dvojkového bajty s použitím nejmenšího možného počtu bajtů.Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. Pokud je hodnota nula, výstupuje jeden bajt, jehož element je 0x00.If the value is zero, outputs one byte whose element is 0x00.

Operátory

Addition(BigInteger, BigInteger)

Přidá hodnoty dvou zadaných BigInteger objektů.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger)

Provede bitovou operaci And u dvou hodnot BigInteger.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger)

Provede bitovou operaci Or u dvou hodnot BigInteger.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger)

Sníží hodnotu BigInteger o 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger)

Vydělí zadanou BigInteger hodnotu jinou zadanou BigInteger hodnotou pomocí celočíselného dělení.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(BigInteger, BigInteger)

Vrátí hodnotu, která označuje, zda jsou hodnoty dvou objektů BigInteger stejné.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, Int64)

Vrací hodnotu, která označuje, zda BigInteger hodnota a hodnota Long signed integer jsou stejné.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, UInt64)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger a hodnota Long unsigned long typu Integer shodná.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(Int64, BigInteger)

Vrací hodnotu, která označuje, zda je hodnota signed Long Integer a hodnota BigInteger shodná.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(UInt64, BigInteger)

Vrátí hodnotu, která označuje, zda je hodnota unsigned Long Integer a hodnota BigInteger shodná.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger)

Provede bitovou výhradní operaci Or (XOr) na dvou BigInteger hodnotách.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(BigInteger to Byte)

Definuje explicitní převod BigInteger objektu na hodnotu bajt bez znaménka.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal)

Definuje explicitní převod BigInteger objektu na hodnotu Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double)

Definuje explicitní převod BigInteger objektu na hodnotu Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16)

Definuje explicitní převod BigInteger objektu na 16bitová celočíselnou hodnotu se znaménkem.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32)

Definuje explicitní převod objektu BigInteger na celočíselnou hodnotu se znaménkem (32).Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64)

Definuje explicitní převod objektu BigInteger na celočíselnou hodnotu se znaménkem (64).Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte)

Definuje explicitní převod BigInteger objektu na podepsanou 8bitové hodnoty.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Int16je odpovídající alternativa.The compliant alternative is Int16.

Explicit(BigInteger to Single)

Definuje explicitní převod objektu BigInteger na hodnotu s jednoduchou přesností s plovoucí desetinnou čárkou.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16)

Definuje explicitní převod BigInteger objektu na 16bitová celočíselnou hodnotu bez znaménka.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Int32je odpovídající alternativa.The compliant alternative is Int32.

Explicit(BigInteger to UInt32)

Definuje explicitní převod objektu BigInteger na celočíselnou hodnotu bez znaménka 32.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Int64je odpovídající alternativa.The compliant alternative is Int64.

Explicit(BigInteger to UInt64)

Definuje explicitní převod objektu BigInteger na celočíselnou hodnotu bez znaménka 64.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Doubleje odpovídající alternativa.The compliant alternative is Double.

Explicit(Decimal to BigInteger)

Definuje explicitní převod Decimal objektu na hodnotu BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger)

Definuje explicitní převod Double hodnoty na hodnotu BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(Single to BigInteger)

Definuje explicitní převod Single hodnoty na hodnotu BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(BigInteger, BigInteger)

Vrátí hodnotu, která označuje, zda BigInteger hodnota je větší než jiná hodnota BigInteger.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThan(BigInteger, Int64)

Vrací hodnotu, která označuje, zda je BigInteger větší než 64 hodnota se znaménkem (Integer).Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, UInt64)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger větší než 64-bit unsigned integer.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger)

Vrací hodnotu, která označuje, zda je celé číslo se znaménkem 64 je větší než hodnota BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(UInt64, BigInteger)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger větší než 64-bit unsigned integer.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThanOrEqual(BigInteger, BigInteger)

Vrátí hodnotu, která označuje, zda BigInteger hodnota je větší nebo rovna jiné hodnotě BigInteger.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, Int64)

Vrací hodnotu, která označuje, zda BigInteger hodnota je větší nebo rovna 64 celočíselné hodnotě se znaménkem.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, UInt64)

Vrátí hodnotu, která označuje, zda BigInteger hodnota je větší než nebo rovna hodnotě 64 unsigned integer bitů.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(Int64, BigInteger)

Vrací hodnotu, která označuje, zda je celé číslo se znaménkem 64, které je větší nebo rovno hodnotě BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(UInt64, BigInteger)

Vrátí hodnotu, která označuje, zda je 64 unsigned integer větší než nebo rovna hodnotě 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)

Definuje implicitní převod bajt bez znaménka na hodnotu BigInteger.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int16 to BigInteger)

Definuje implicitní převod se znaménkem 16bitového celého čísla na hodnotu BigInteger.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Int32 to BigInteger)

Definuje implicitní převod celého čísla se znaménkem (32) na hodnotu BigInteger.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int64 to BigInteger)

Definuje implicitní převod celého čísla se znaménkem (64) na hodnotu BigInteger.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Implicit(SByte to BigInteger)

Definuje implicitní převod na 8bitové celé číslo se znaménkem na hodnotu BigInteger.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. BigInteger(Int32)je odpovídající alternativa.The compliant alternative is BigInteger(Int32).

Implicit(UInt16 to BigInteger)

Definuje implicitní převod 16bitového unsigned integer na hodnotu BigInteger.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Implicit(Int32 to BigInteger)je odpovídající alternativa.The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Definuje implicitní převod 32 unsigned integer na hodnotu BigInteger.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Implicit(Int64 to BigInteger)je odpovídající alternativa.The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

Definuje implicitní převod 64 unsigned integer na hodnotu BigInteger.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Toto rozhraní API není kompatibilní se specifikací CLS.This API is not CLS-compliant. Doubleje odpovídající alternativa.The compliant alternative is Double.

Increment(BigInteger)

Zvýší hodnotu BigInteger o 1.Increments a BigInteger value by 1.

Inequality(BigInteger, BigInteger)

Vrátí hodnotu, která označuje, zda dva objekty BigInteger mají jiné hodnoty.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, Int64)

Vrátí hodnotu, která označuje, zda BigInteger hodnota a celé číslo se znaménkem 64 není rovno.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

Inequality(BigInteger, UInt64)

Vrátí hodnotu, která označuje, zda BigInteger hodnota a 64-bit unsigned integer nejsou stejné.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger)

Vrací hodnotu, která označuje, zda se nerovná celé číslo se znaménkem 64 a hodnota BigInteger.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(UInt64, BigInteger)

Vrátí hodnotu, která označuje, zda je 64 unsigned integer a hodnota BigInteger rovna.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

LeftShift(BigInteger, Int32)

Posune BigInteger hodnotu o zadaný počet bitů vlevo.Shifts a BigInteger value a specified number of bits to the left.

LessThan(BigInteger, BigInteger)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger menší než jiná hodnota BigInteger.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, Int64)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger menší než 64 celé číslo se znaménkem.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, UInt64)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger menší než 64-bit unsigned integer.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(Int64, BigInteger)

Vrací hodnotu, která označuje, zda je celé číslo se znaménkem 64 menší než hodnota BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(UInt64, BigInteger)

Vrátí hodnotu, která označuje, zda je 64 unsigned integer menší než hodnota BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger menší nebo rovna jiné hodnotě BigInteger.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, Int64)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger menší nebo rovna 64 celé číslo se znaménkem.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

LessThanOrEqual(BigInteger, UInt64)

Vrátí hodnotu, která označuje, zda je hodnota BigInteger menší nebo rovna 64. unsigned integer.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger)

Vrací hodnotu, která označuje, zda je celé číslo se znaménkem 64 menší nebo rovno hodnotě BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(UInt64, BigInteger)

Vrátí hodnotu, která označuje, zda je 64 unsigned integer menší nebo rovna hodnotě BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

Modulus(BigInteger, BigInteger)

Vrátí zbytek, který je výsledkem dělení se dvěma zadanými BigInteger hodnotami.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger)

Vynásobí dvě zadané hodnoty BigInteger.Multiplies two specified BigInteger values.

OnesComplement(BigInteger)

Vrátí hodnotu bitového prvku, který je doplňkem hodnoty BigInteger.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32)

Posune BigInteger hodnotu o zadaný počet bitů vpravo.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger)

Odečte BigInteger hodnotu z jiné hodnoty BigInteger.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger)

Negace zadané hodnoty BigInteger.Negates a specified BigInteger value.

UnaryPlus(BigInteger)

Vrátí hodnotu operandu BigInteger.Returns the value of the BigInteger operand. (Znaménko operandu není beze změny.)(The sign of the operand is unchanged.)

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrátí celé číslo, které označuje, zda je hodnota této instance menší než, rovna nebo větší než hodnota zadaného objektu.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.

Platí pro