Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

BigInteger structure

 

Date de publication : novembre 2016

Représente un entier signé arbitrairement grand.

Espace de noms:   System.Numerics
Assembly:  System.Numerics (dans System.Numerics.dll)

[SerializableAttribute]
public struct BigInteger : IFormattable, IComparable, IComparable<BigInteger>, 
	IEquatable<BigInteger>

NomDescription
System_CAPS_pubmethodBigInteger(Byte[])

Initialise une nouvelle instance de la BigInteger de la structure en utilisant les valeurs dans un tableau d’octets.

System_CAPS_pubmethodBigInteger(Decimal)

Initialise une nouvelle instance de la BigInteger à l’aide de la structure un Decimal valeur.

System_CAPS_pubmethodBigInteger(Double)

Initialise une nouvelle instance de la BigInteger de la structure à l’aide d’une valeur à virgule flottante double précision.

System_CAPS_pubmethodBigInteger(Int32)

Initialise une nouvelle instance de la BigInteger de la structure à l’aide d’une valeur entière signée 32 bits.

System_CAPS_pubmethodBigInteger(Int64)

Initialise une nouvelle instance de la BigInteger de la structure à l’aide d’une valeur entière signée 64 bits.

System_CAPS_pubmethodBigInteger(Single)

Initialise une nouvelle instance de la BigInteger de la structure à l’aide d’une valeur à virgule flottante simple précision.

System_CAPS_pubmethodBigInteger(UInt32)

Initialise une nouvelle instance de la BigInteger de la structure à l’aide d’un entier non signé 32 bits.

System_CAPS_pubmethodBigInteger(UInt64)

Initialise une nouvelle instance de la BigInteger structure avec une valeur d’entier non signé 64 bits.

NomDescription
System_CAPS_pubpropertyIsEven

Indique si la valeur de la BigInteger objet est un nombre pair.

System_CAPS_pubpropertyIsOne

Indique si la valeur de la BigInteger objet est BigInteger.One.

System_CAPS_pubpropertyIsPowerOfTwo

Indique si la valeur de la BigInteger objet est une puissance de deux.

System_CAPS_pubpropertyIsZero

Indique si la valeur de la BigInteger objet est BigInteger.Zero.

System_CAPS_pubpropertySystem_CAPS_staticMinusOne

Obtient une valeur qui représente le nombre moins un (-1).

System_CAPS_pubpropertySystem_CAPS_staticOne

Obtient une valeur qui représente le nombre un (1).

System_CAPS_pubpropertySign

Obtient un nombre qui indique le signe (négatif, positif ou zéro) de l’utilisateur actuel BigInteger objet.

System_CAPS_pubpropertySystem_CAPS_staticZero

Obtient une valeur qui représente le nombre 0 (zéro).

NomDescription
System_CAPS_pubmethodSystem_CAPS_staticAbs(BigInteger)

Obtient la valeur absolue d’un BigInteger objet.

System_CAPS_pubmethodSystem_CAPS_staticAdd(BigInteger, BigInteger)

Ajoute deux BigInteger valeurs et retourne le résultat.

System_CAPS_pubmethodSystem_CAPS_staticCompare(BigInteger, BigInteger)

Compare deux BigInteger valeurs et retourne un entier qui indique si la première valeur est inférieure, égale ou supérieure à la deuxième valeur.

System_CAPS_pubmethodCompareTo(BigInteger)

Compare cette instance à un second BigInteger et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l’objet spécifié.

System_CAPS_pubmethodCompareTo(Int64)

Compare cette instance à un entier 64 bits signé et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'entier 64 bits signé.

System_CAPS_pubmethodCompareTo(Object)

Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.

System_CAPS_pubmethodCompareTo(UInt64)

Compare cette instance à un entier 64 bits non signé et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'entier 64 bits non signé.

System_CAPS_pubmethodSystem_CAPS_staticDivide(BigInteger, BigInteger)

Divise une BigInteger valeur par une autre et retourne le résultat.

System_CAPS_pubmethodSystem_CAPS_staticDivRem(BigInteger, BigInteger, BigInteger)

Divise une BigInteger valeur par une autre, retourne le résultat et retourne le reste dans un paramètre de sortie.

System_CAPS_pubmethodEquals(BigInteger)

Retourne une valeur qui indique si l’instance actuelle et un BigInteger objet ont la même valeur.

System_CAPS_pubmethodEquals(Int64)

Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits signé ont la même valeur.

System_CAPS_pubmethodEquals(Object)

Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.(Remplace ValueType.Equals(Object).)

System_CAPS_pubmethodEquals(UInt64)

Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits non signé ont la même valeur.

System_CAPS_pubmethodGetHashCode()

Retourne le code de hachage pour l’actuel BigInteger objet.(Remplace ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticGreatestCommonDivisor(BigInteger, BigInteger)

Recherche le plus grand commun diviseur de deux BigInteger valeurs.

System_CAPS_pubmethodSystem_CAPS_staticLog(BigInteger)

Retourne le logarithme naturel (base e) d'un nombre spécifié.

System_CAPS_pubmethodSystem_CAPS_staticLog(BigInteger, Double)

Retourne le logarithme d'un nombre spécifié dans une base spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticLog10(BigInteger)

Retourne le logarithme de base 10 d'un nombre spécifié.

System_CAPS_pubmethodSystem_CAPS_staticMax(BigInteger, BigInteger)

Retourne le plus grand de deux BigInteger valeurs.

System_CAPS_pubmethodSystem_CAPS_staticMin(BigInteger, BigInteger)

Retourne le plus petit de deux BigInteger valeurs.

System_CAPS_pubmethodSystem_CAPS_staticModPow(BigInteger, BigInteger, BigInteger)

Effectue une division avec coefficient sur un nombre élevé à la puissance d'un autre nombre.

System_CAPS_pubmethodSystem_CAPS_staticMultiply(BigInteger, BigInteger)

Retourne le produit de deux BigInteger valeurs.

System_CAPS_pubmethodSystem_CAPS_staticNegate(BigInteger)

Inverse une certaine BigInteger valeur.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation BigInteger équivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation BigInteger équivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent BigInteger.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation BigInteger équivalente.

System_CAPS_pubmethodSystem_CAPS_staticPow(BigInteger, Int32)

Déclenche un BigInteger valeur à la puissance d’une valeur spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticRemainder(BigInteger, BigInteger)

Effectue une division entière sur deux BigInteger valeurs et retourne le reste.

System_CAPS_pubmethodSystem_CAPS_staticSubtract(BigInteger, BigInteger)

Soustrait un BigInteger valeur d’une autre et retourne le résultat.

System_CAPS_pubmethodToByteArray()

Convertit un BigInteger valeur à un tableau d’octets.

System_CAPS_pubmethodToString()

Convertit la valeur numérique de l'objet BigInteger actuel dans sa représentation sous forme chaîne équivalente.(Remplace ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente à l’aide des informations spécifiées de mise en forme spécifiques à la culture.

System_CAPS_pubmethodToString(String)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.

System_CAPS_pubmethodToString(String, IFormatProvider)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente à l’aide du format spécifié et des informations de mise en forme spécifiques à la culture.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.

NomDescription
System_CAPS_puboperatorSystem_CAPS_staticAddition(BigInteger, BigInteger)

Ajoute les valeurs de deux spécifié BigInteger objets.

System_CAPS_puboperatorSystem_CAPS_staticBitwiseAnd(BigInteger, BigInteger)

Effectue une opération de bits And opération sur deux BigInteger valeurs.

System_CAPS_puboperatorSystem_CAPS_staticBitwiseOr(BigInteger, BigInteger)

Effectue une opération de bits Or opération sur deux BigInteger valeurs.

System_CAPS_puboperatorSystem_CAPS_staticDecrement(BigInteger)

Décrémente une BigInteger valeur par 1.

System_CAPS_puboperatorSystem_CAPS_staticDivision(BigInteger, BigInteger)

Divise un BigInteger valeur par une autre spécifié BigInteger à l’aide de division d’entier.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, BigInteger)

Retourne une valeur qui indique si les valeurs de deux BigInteger objets sont égaux.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, Int64)

Retourne une valeur qui indique si un BigInteger valeur et une valeur d’entier long signé sont égales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(BigInteger, UInt64)

Retourne une valeur qui indique si un BigInteger valeur et une valeur d’entier long non signé sont égales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(Int64, BigInteger)

Retourne une valeur qui indique si une valeur d’entier long signé et une BigInteger sont égales.

System_CAPS_puboperatorSystem_CAPS_staticEquality(UInt64, BigInteger)

Retourne une valeur qui indique si une valeur d’entier long non signé et une BigInteger sont égales.

System_CAPS_puboperatorSystem_CAPS_staticExclusiveOr(BigInteger, BigInteger)

Effectue une opération de bits exclusive Or (XOr) opération sur deux BigInteger valeurs.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Byte)

Définit une conversion explicite d’un BigInteger objet à une valeur d’octet non signé.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Decimal)

Définit une conversion explicite d’un BigInteger de l’objet à un Decimal valeur.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Double)

Définit une conversion explicite d’un BigInteger de l’objet à un Double valeur.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int16)

Définit une conversion explicite d’un BigInteger objet à une valeur entière signée 16 bits.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int32)

Définit une conversion explicite d’un BigInteger objet à une valeur entière signée 32 bits.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Int64)

Définit une conversion explicite d’un BigInteger objet à une valeur entière signée 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to SByte)

Définit une conversion explicite d’un BigInteger objet en valeur 8 bits signée.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Single)

Définit une conversion explicite d’un BigInteger objet à une valeur à virgule flottante simple précision.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt16)

Définit une conversion explicite d’un BigInteger objet à une valeur d’entier non signé 16 bits.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt32)

Définit une conversion explicite d’un BigInteger objet à une valeur d’entier non signé 32 bits.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to UInt64)

Définit une conversion explicite d’un BigInteger objet à une valeur d’entier non signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Decimal to BigInteger)

Définit une conversion explicite d’un Decimal de l’objet à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Double to BigInteger)

Définit une conversion explicite d’un Double de valeur pour un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Single to BigInteger)

Définit une conversion explicite d’un Single de l’objet à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, BigInteger)

Retourne une valeur qui indique si un BigInteger est supérieure à un autre BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, Int64)

Retourne une valeur qui indique si un BigInteger est supérieure à une valeur entière signée 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(BigInteger, UInt64)

Retourne une valeur qui indique si un BigInteger est supérieure à un entier non signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(Int64, BigInteger)

Retourne une valeur qui indique si un entier signé 64 bits est supérieur à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(UInt64, BigInteger)

Retourne une valeur qui indique si un BigInteger est supérieure à un entier non signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, BigInteger)

Retourne une valeur qui indique si un BigInteger valeur est supérieure ou égale à un autre BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, Int64)

Retourne une valeur qui indique si un BigInteger valeur est supérieure ou égale à une valeur entière signée 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(BigInteger, UInt64)

Retourne une valeur qui indique si un BigInteger valeur est supérieure ou égale à une valeur d’entier non signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(Int64, BigInteger)

Retourne une valeur qui indique si un entier signé 64 bits est supérieur ou égal à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(UInt64, BigInteger)

Retourne une valeur qui indique si un entier non signé 64 bits est supérieur ou égal à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Byte to BigInteger)

Définit une conversion implicite d’un octet non signé à une BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int16 to BigInteger)

Définit une conversion implicite d’un entier signé de 16 bits à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int32 to BigInteger)

Définit une conversion implicite d’un entier 32 bits signé à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int64 to BigInteger)

Définit une conversion implicite d’un entier 64 bits signé à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(SByte to BigInteger)

Définit une conversion implicite d’un entier signé 8 bits à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt16 to BigInteger)

Définit une conversion implicite d’un entier non signé 16 bits à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt32 to BigInteger)

Définit une conversion implicite d’un entier non signé 32 bits à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt64 to BigInteger)

Définit une conversion implicite d’un entier non signé 64 bits à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticIncrement(BigInteger)

Incrémente une BigInteger valeur par 1.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, BigInteger)

Retourne une valeur qui indique si deux objets BigInteger ont des valeurs différentes.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, Int64)

Retourne une valeur qui indique si un BigInteger valeur et un entier signé 64 bits ne sont pas égaux.

System_CAPS_puboperatorSystem_CAPS_staticInequality(BigInteger, UInt64)

Retourne une valeur qui indique si un BigInteger valeur et un entier non signé 64 bits ne sont pas égaux.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Int64, BigInteger)

Retourne une valeur qui indique si un entier signé 64 bits et une BigInteger valeur ne sont pas égales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(UInt64, BigInteger)

Retourne une valeur qui indique si un entier non signé 64 bits et une BigInteger valeur ne sont pas égales.

System_CAPS_puboperatorSystem_CAPS_staticLeftShift(BigInteger, Int32)

Décale une BigInteger valeur un certain nombre de bits vers la gauche.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, BigInteger)

Retourne une valeur qui indique si un BigInteger valeur est inférieure à une autre BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, Int64)

Retourne une valeur qui indique si un BigInteger valeur est inférieure à un entier signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(BigInteger, UInt64)

Retourne une valeur qui indique si un BigInteger valeur est inférieure à un entier non signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(Int64, BigInteger)

Retourne une valeur qui indique si un entier signé 64 bits est inférieur à une BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(UInt64, BigInteger)

Retourne une valeur qui indique si un entier non signé 64 bits est inférieur à une BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, BigInteger)

Retourne une valeur qui indique si un BigInteger valeur est inférieure ou égale à un autre BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, Int64)

Retourne une valeur qui indique si un BigInteger valeur est inférieure ou égale à un entier signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(BigInteger, UInt64)

Retourne une valeur qui indique si un BigInteger valeur est inférieure ou égale à un entier non signé 64 bits.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(Int64, BigInteger)

Retourne une valeur qui indique si un entier signé 64 bits est inférieur ou égal à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(UInt64, BigInteger)

Retourne une valeur qui indique si un entier non signé 64 bits est inférieur ou égal à un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticModulus(BigInteger, BigInteger)

Retourne le reste de la division avec deux spécifié BigInteger valeurs.

System_CAPS_puboperatorSystem_CAPS_staticMultiply(BigInteger, BigInteger)

Multiplie deux valeurs BigInteger spécifiées.

System_CAPS_puboperatorSystem_CAPS_staticOnesComplement(BigInteger)

Retourne l’opération de bits de complément d’un BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticRightShift(BigInteger, Int32)

Décale une valeur BigInteger d’un certain nombre de bits vers la droite.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(BigInteger, BigInteger)

Soustrait un BigInteger valeur d’une autre BigInteger valeur.

System_CAPS_puboperatorSystem_CAPS_staticUnaryNegation(BigInteger)

Inverse la valeur BigInteger spécifiée.

System_CAPS_puboperatorSystem_CAPS_staticUnaryPlus(BigInteger)

Retourne la valeur de la BigInteger opérande. (Le signe de l’opérande est inchangé.)

The T:System.Numerics.BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. The members of the T:System.Numerics.BigInteger type closely parallel those of other integral types (the T:System.Byte, T:System.Int16, T:System.Int32, T:System.Int64, T:System.SByte, T:System.UInt16, T:System.UInt32, and T:System.UInt64 types). This type differs from the other integral types in the dnprdnshort, which have a range indicated by their MinValue and MaxValue properties.

System_CAPS_noteRemarque

Because the T:System.Numerics.BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an T:System.OutOfMemoryException can be thrown for any operation that causes a T:System.Numerics.BigInteger value to grow too large.

You can instantiate a T:System.Numerics.BigInteger object in several ways:

  • You can use the new keyword and provide any integral or floating-point value as a parameter to the T:System.Numerics.BigInteger constructor. (Floating-point values are truncated before they are assigned to the T:System.Numerics.BigInteger.) The following example illustrates how to use the new keyword to instantiate T:System.Numerics.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		
    
  • You can declare a T:System.Numerics.BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. The following example uses assignment to create a T:System.Numerics.BigInteger value from an T:System.Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
  • You can assign a decimal or floating-point value to a T:System.Numerics.BigInteger object if you cast the value or convert it first. The following example explicitly casts (in C#) or converts (in Visual Basic) a T:System.Double and a T:System.Decimal value to a T:System.Numerics.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      
    

These methods enable you to instantiate a T:System.Numerics.BigInteger object whose value is in the range of one of the existing numeric types only. You can instantiate a T:System.Numerics.BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • You can use the new keyword and provide a byte array of any size to the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor. 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).
    
  • You can call the Overload:System.Numerics.BigInteger.Parse or Overload:System.Numerics.BigInteger.TryParse methods to convert the string representation of a number to a T:System.Numerics.BigInteger. 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
    
  • You can call a static (Shared in Visual Basic) T:System.Numerics.BigInteger method that performs some operation on a numeric expression and returns a calculated T:System.Numerics.BigInteger result. The following example does this by cubing F:System.UInt64.MaxValue and assigning the result to a T:System.Numerics.BigInteger.

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

The uninitialized value of a T:System.Numerics.BigInteger is P:System.Numerics.BigInteger.Zero.

You can use a T:System.Numerics.BigInteger instance as you would use any other integral type. T:System.Numerics.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. You can also use the standard numeric operators to compare two T:System.Numerics.BigInteger values with each other. Like the other integral types, T:System.Numerics.BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. For languages that do not support custom operators, the T:System.Numerics.BigInteger structure also provides equivalent methods for performing mathematical operations. These include M:System.Numerics.BigInteger.Add(System.Numerics.BigInteger,System.Numerics.BigInteger), M:System.Numerics.BigInteger.Divide(System.Numerics.BigInteger,System.Numerics.BigInteger), M:System.Numerics.BigInteger.Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger), M:System.Numerics.BigInteger.Negate(System.Numerics.BigInteger), M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger), and several others.

Many members of the T:System.Numerics.BigInteger structure correspond directly to members of the other integral types. In addition, T:System.Numerics.BigInteger adds members such as the following:

  • Sign, which returns a value that indicates the sign of a BigInteger value.

  • Abs, which returns the absolute value of a BigInteger value.

  • DivRem, which returns both the quotient and remainder of a division operation.

  • GreatestCommonDivisor, which returns the greatest common divisor of two BigInteger values.

Many of these additional members correspond to the members of the T:System.Math class, which provides the functionality to work with the primitive numeric types.

The following example instantiates a T:System.Numerics.BigInteger object and then increments its value by one.

BigInteger number = BigInteger.Multiply(Int64.MaxValue, 3);
number++;
Console.WriteLine(number);

Although this example appears to modify the value of the existing object, this is not the case. T:System.Numerics.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new T:System.Numerics.BigInteger object and assigns it a value one greater than its previous value. This new object is then returned to the caller.

System_CAPS_noteRemarque

The other numeric types in the .NET Framework are also immutable. However, because the T:System.Numerics.BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Although this process is transparent to the caller, it does incur a performance penalty. In some cases, especially when repeated operations are performed in a loop on very large T:System.Numerics.BigInteger values, that performance penalty can be significant. For example, in the following example, an operation is performed repetitively up to a million times, and a T:System.Numerics.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++;
}

In such a case, you can improve performance by performing all intermediate assignments to an T:System.Int32 variable. The final value of the variable can then be assigned to the T:System.Numerics.BigInteger object when the loop exits. 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;

If you convert T:System.Numerics.BigInteger values to byte arrays, or if you convert byte arrays to T:System.Numerics.BigInteger values, you must consider the order of bytes. The T:System.Numerics.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). You can round-trip a T:System.Numerics.BigInteger value by calling the M:System.Numerics.BigInteger.ToByteArray method and then passing the resulting byte array to the M:System.Numerics.BigInteger.#ctor(System.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

To instantiate a T:System.Numerics.BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the M:System.BitConverter.GetBytes(System.UInt16) method, and then pass the resulting byte array to the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor. The following example instantiates a T:System.Numerics.BigInteger value from a byte array that represents an T:System.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

The T:System.Numerics.BigInteger structure assumes that negative values are stored by using two's complement representation. Because the T:System.Numerics.BigInteger structure represents a numeric value with no fixed length, the M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. To prevent the M:System.Numerics.BigInteger.#ctor(System.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. For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. 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 M:System.Numerics.BigInteger.#ctor(System.Byte[]) constructor as -1,000,000. To instantiate a T:System.Numerics.BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. 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      

Byte arrays created by the M:System.Numerics.BigInteger.ToByteArray method from positive values include this extra zero-value byte. Therefore, the T:System.Numerics.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

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 M:System.BitConverter.GetBytes(System.UInt16), M:System.BitConverter.GetBytes(System.UInt32), and M:System.BitConverter.GetBytes(System.UInt64)).

When parsing a hexadecimal string, the M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles) and M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles,System.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. For example, both "FF01" and "F01" represent the decimal value -255. To differentiate positive from negative values, positive values should include a leading zero. The relevant overloads of the M:System.Numerics.BigInteger.ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. This makes it possible to round-trip T:System.Numerics.BigInteger values by using the M:System.Numerics.BigInteger.ToString and M:System.Numerics.BigInteger.Parse(System.String) 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.

However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the M:System.Convert.ToString(System.Int32) 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. Successfully instantiating a T:System.Numerics.BigInteger value from such a string requires some additional logic. 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.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 4.0
Windows Phone
Disponible depuis 8.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: