BigInteger.CompareTo Méthode

Référence

Définition

Espace de noms:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

Surcharges

CompareTo(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é.
CompareTo(BigInteger)	Compare cette instance à un second BigInteger et retourne un entier qui indique si la valeur de l'instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.
CompareTo(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é.
CompareTo(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é.

CompareTo(Int64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 int CompareTo(long other);

public int CompareTo (long other);

member this.CompareTo : int64 -> int

Public Function CompareTo (other As Long) As Integer

Paramètres

other: Int64

Entier 64 bits signé à comparer.

Retours

Int32

Valeur entière signée qui indique la relation de cette instance par rapport à other, comme indiqué dans le tableau suivant.

Valeur retournée	Description
Inférieure à zéro	L'instance actuelle est inférieure à `other`.
Zéro	L'instance actuelle est égale à `other`.
Supérieure à zéro	L'instance actuelle est supérieure à `other`.

Exemples

L’exemple suivant illustre le résultat de l’appel de la CompareTo(Int64) méthode avec des valeurs intégrales.

BigInteger bigIntValue = BigInteger.Parse("3221123045552");

byte byteValue = 16;
sbyte sbyteValue = -16;
short shortValue = 1233;
ushort ushortValue = 1233;
int intValue = -12233;
uint uintValue = 12233;
long longValue = 12382222;
ulong ulongValue = 1238222;

Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, byteValue,
                  bigIntValue.CompareTo(byteValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, sbyteValue,
                  bigIntValue.CompareTo(sbyteValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, shortValue,
                  bigIntValue.CompareTo(shortValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, ushortValue,
                  bigIntValue.CompareTo(ushortValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, intValue,
                  bigIntValue.CompareTo(intValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, uintValue,
                  bigIntValue.CompareTo(uintValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, longValue,
                  bigIntValue.CompareTo(longValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, ulongValue,
                  bigIntValue.CompareTo(ulongValue));
// The example displays the following output:
//       Comparing 3221123045552 with 16: 1
//       Comparing 3221123045552 with -16: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with -12233: 1
//       Comparing 3221123045552 with 12233: 1
//       Comparing 3221123045552 with 12382222: 1
//       Comparing 3221123045552 with 1238222: 1

Dim bigIntValue As BigInteger = BigInteger.Parse("3221123045552")

Dim byteValue As Byte = 16
Dim sbyteValue As SByte = -16
Dim shortValue As Short = 1233      
Dim ushortValue As UShort = 1233
Dim intValue As Integer = -12233
Dim uintValue As UInteger = 12233
Dim longValue As Long = 12382222
Dim ulongValue As Integer = 1238222

Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, byteValue, _
                  bigIntValue.CompareTo(byteValue))
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, sbyteValue, _
                  bigIntValue.CompareTo(sbyteValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, shortValue, _
                  bigIntValue.CompareTo(shortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ushortValue, _
                  bigIntValue.CompareTo(ushortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, intValue, _
                  bigIntValue.CompareTo(intValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, uintValue, _
                  bigIntValue.CompareTo(uintValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, longValue, _
                  bigIntValue.CompareTo(longValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ulongValue, _
                  bigIntValue.CompareTo(ulongValue))
' The example displays the following output:
'       Comparing 3221123045552 with 16: 1
'       Comparing 3221123045552 with -16: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with -12233: 1
'       Comparing 3221123045552 with 12233: 1
'       Comparing 3221123045552 with 12382222: 1
'       Comparing 3221123045552 with 1238222: 1

Remarques

Si other est une Bytevaleur , Int16, SByte Int32, UInt16, ou UInt32 , elle est implicitement convertie en valeur Int64 lorsque la CompareTo(Int64) méthode est appelée.

S’applique à

CompareTo(BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 virtual int CompareTo(System::Numerics::BigInteger other);

public int CompareTo (System.Numerics.BigInteger other);

abstract member CompareTo : System.Numerics.BigInteger -> int
override this.CompareTo : System.Numerics.BigInteger -> int

Public Function CompareTo (other As BigInteger) As Integer

Paramètres

other: BigInteger

Objet à comparer.

Retours

Int32

Valeur entière signée qui indique la relation de cette instance par rapport à other, comme indiqué dans le tableau suivant.

Valeur retournée	Description
Inférieure à zéro	L'instance actuelle est inférieure à `other`.
Zéro	L'instance actuelle est égale à `other`.
Supérieure à zéro	L'instance actuelle est supérieure à `other`.

Implémente

CompareTo(T)

Exemples

L’exemple suivant illustre l’utilisation de la CompareTo(BigInteger) méthode pour classer une liste d’objets StarInfo . Chaque StarInfo objet fournit des informations sur le nom d’une étoile et sa distance par rapport à la Terre en miles. StarInfo implémente l’interface IComparable<T> , qui permet StarInfo aux objets d’être triés par classes de collection génériques. Son IComparable<T>.CompareTo implémentation encapsule simplement un appel à CompareTo(BigInteger).

using System;
using System.Collections.Generic;
using System.Numerics;

public struct StarInfo : IComparable<StarInfo>
{
   // Define constructors.
   public StarInfo(string name, double lightYears)
   {
      this.Name = name;

      // Calculate distance in miles from light years.
      this.Distance = (BigInteger) Math.Round(lightYears * 5.88e12);
   }

   public StarInfo(string name, BigInteger distance)
   {
      this.Name = name;
      this.Distance = distance;
   }

   // Define public fields.
   public string Name;
   public BigInteger Distance;

   // Display name of star and its distance in parentheses.
   public override string ToString()
   {
      return String.Format("{0,-10} ({1:N0})", this.Name, this.Distance);
   }

   // Compare StarInfo objects by their distance from Earth.
   public int CompareTo(StarInfo other)
   {
      return this.Distance.CompareTo(other.Distance);
   }
}

Imports System.Collections.Generic
Imports System.Numerics

Public Structure StarInfo : Implements IComparable(Of StarInfo)
   ' Define constructors.
   Public Sub New(name As String, lightYears As Double)
      Me.Name = name
      ' Calculate distance in miles from light years.
      Me.Distance = CType(Math.Round(lightYears * 5.88e12), BigInteger)
   End Sub
   
   Public Sub New(name As String, distance As BigInteger)
      Me.Name = name
      Me.Distance = distance
   End Sub
   
   ' Define public fields.
   Public Name As String
   Public Distance As BigInteger

   ' Display name of star and its distance in parentheses.
   Public Overrides Function ToString() As String
      Return String.Format("{0,-10} ({1:N0})", Me.Name, Me.Distance)
   End Function

   ' Compare StarInfo objects by their distance from Earth.
   Public Function CompareTo(other As starInfo) As Integer _
                   Implements IComparable(Of StarInfo).CompareTo
      Return Me.Distance.CompareTo(other.Distance)
   End Function                
End Structure

Le code suivant instancie ensuite quatre StarInfo objets et les stocke dans un objet générique List<T> . Une fois la List<T>.Sort méthode appelée, StarInfo les objets sont affichés dans l’ordre de leur distance de la Terre.

public class Example
{
   public static void Main()
   {
      StarInfo star;
      List<StarInfo> stars = new List<StarInfo>();

      star = new StarInfo("Sirius", 8.6d);
      stars.Add(star);
      star = new StarInfo("Rigel", 1400d);
      stars.Add(star);
      star = new StarInfo("Castor", 49d);
      stars.Add(star);
      star = new StarInfo("Antares", 520d);
      stars.Add(star);

      stars.Sort();

      foreach (StarInfo sortedStar in stars)
         Console.WriteLine(sortedStar);
   }
}
// The example displays the following output:
//       Sirius     (50,568,000,000,000)
//       Castor     (288,120,000,000,000)
//       Antares    (3,057,600,000,000,000)
//       Rigel      (8,232,000,000,000,000)

Module Example
   Public Sub Main()
      Dim star As StarInfo
      Dim stars As New List(Of StarInfo)
      
      star = New StarInfo("Sirius", 8.6d)
      stars.Add(star)
      star = New StarInfo("Rigel", 1400d)
      stars.Add(star)
      star = New StarInfo("Castor", 49d)
      stars.Add(star)
      star = New StarInfo("Antares", 520d)
      stars.Add(star)
      
      stars.Sort()
      
      For Each star In stars
         Console.WriteLine(star)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Sirius     (50,568,000,000,000)
'       Castor     (288,120,000,000,000)
'       Antares    (3,057,600,000,000,000)
'       Rigel      (8,232,000,000,000,000)

Remarques

Cette surcharge de la CompareTo méthode implémente la IComparable<T>.CompareTo méthode . Il est utilisé par les objets de collection génériques pour classer les éléments de la collection.

Voir aussi

S’applique à

CompareTo(Object)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

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

public:
 virtual int CompareTo(System::Object ^ obj);

public int CompareTo (object? obj);

public int CompareTo (object obj);

abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int

Public Function CompareTo (obj As Object) As Integer

Paramètres

obj: Object

Objet à comparer.

Retours

Int32

Entier signé qui indique la relation de l'instance actuelle par rapport au paramètre obj, comme indiqué dans le tableau suivant.

Valeur retournée	Description
Inférieure à zéro	L'instance actuelle est inférieure à `obj`.
Zéro	L'instance actuelle est égale à `obj`.
Supérieure à zéro	L'instance actuelle est supérieure à `obj` ou le paramètre `obj` est `null`.

Implémente

CompareTo(Object)

Exceptions

ArgumentException

obj n’est pas un BigInteger.

Exemples

L’exemple suivant appelle la CompareTo(Object) méthode pour comparer une BigInteger valeur avec chaque élément d’un tableau d’objets :

object[] values = { BigInteger.Pow(Int64.MaxValue, 10), null,
                    12.534, Int64.MaxValue, BigInteger.One };
BigInteger number = UInt64.MaxValue;

foreach (object value in values)
{
   try {
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value,
                        number.CompareTo(value));
   }
   catch (ArgumentException) {
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
//    Comparing 18446744073709551615 with '': 1
//    Unable to compare the Double value 12.534 with a BigInteger.
//    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
//    Comparing 18446744073709551615 with '1': 1

Dim values() As Object = { BigInteger.Pow(Int64.MaxValue, 10), Nothing, 
                           12.534, Int64.MaxValue, BigInteger.One }
Dim number As BigInteger = UInt64.MaxValue

For Each value As Object In values
   Try
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value, 
                        number.CompareTo(value))
   Catch e As ArgumentException
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value)
   End Try                     
Next                                 
' The example displays the following output:
'    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
'    Comparing 18446744073709551615 with '': 1
'    Unable to compare the Double value 12.534 with a BigInteger.
'    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
'    Comparing 18446744073709551615 with '1': 1

Remarques

Cette surcharge de la CompareTo méthode implémente la IComparable.CompareTo méthode . Il est utilisé par les objets de collection non génériques pour classer les éléments de la collection.

Le obj paramètre doit être l’un des éléments suivants :

Objet dont le type d’exécution est BigInteger.
Variable Object dont la valeur est null. Si la valeur du obj paramètre est null, la méthode retourne 1, ce qui indique que l’instance actuelle est supérieure à obj.

Voir aussi

IComparable

S’applique à

CompareTo(UInt64)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

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

public:
 int CompareTo(System::UInt64 other);

[System.CLSCompliant(false)]
public int CompareTo (ulong other);

[<System.CLSCompliant(false)>]
member this.CompareTo : uint64 -> int

Public Function CompareTo (other As ULong) As Integer

Paramètres

other: UInt64

Entier 64 bits non signé à comparer.

Retours

Int32

Entier signé qui indique la valeur relative de cette instance et de other, comme indiqué dans le tableau suivant.

Valeur retournée	Description
Inférieure à zéro	L'instance actuelle est inférieure à `other`.
Zéro	L'instance actuelle est égale à `other`.
Supérieure à zéro	L'instance actuelle est supérieure à `other`.

Attributs: CLSCompliantAttribute

S’applique à

BigInteger.CompareTo Méthode

Définition

Surcharges

CompareTo(Int64)

Paramètres

Retours

Exemples

Remarques

S’applique à

CompareTo(BigInteger)

Paramètres

Retours

Implémente

Exemples

Remarques

Voir aussi

S’applique à

CompareTo(Object)

Paramètres

Retours

Implémente

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

CompareTo(UInt64)

Paramètres

Retours

S’applique à

Commentaires

Ressources supplémentaires