Int32.CompareTo Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Compare cette instance à un entier 32 bits signé et retourne une indication de leurs valeurs relatives.

Surcharges

CompareTo(Int32)	Compare cette instance à un entier 32 bits signé et retourne une indication de leurs valeurs relatives.
CompareTo(Object)	Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.

CompareTo(Int32)

Source:

Int32.cs

Compare cette instance à un entier 32 bits signé et retourne une indication de leurs valeurs relatives.

public:
 virtual int CompareTo(int value);

public int CompareTo (int value);

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

Public Function CompareTo (value As Integer) As Integer

Paramètres

value

Int32

Entier à comparer.

Retours

Int32

Nombre signé indiquant les valeurs relatives de cette instance et value.

Valeur de retour	Description
Inférieure à zéro	Cette instance est inférieure à value.
Zéro	Cette instance est égale à value.
Supérieure à zéro	Cette instance est supérieure à value.

Implémente

CompareTo(T)

Exemples

L’exemple suivant illustre la Int32.CompareTo(Int32) méthode. En plus d’afficher la valeur retournée par la méthode pour quatre comparaisons différentes, elle convertit la valeur de retour en membre de l’énumération personnalisée Comparison , dont elle affiche également la valeur.

using System;

enum Comparison {
   LessThan=-1, Equal=0, GreaterThan=1};

public class ValueComparison
{
   public static void Main()
   {
      int mainValue = 16325;
      int zeroValue = 0;
      int negativeValue = -1934;
      int positiveValue = 903624;
      int sameValue = 16325;

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, zeroValue,
                        mainValue.CompareTo(zeroValue),
                        (Comparison) mainValue.CompareTo(zeroValue));

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, sameValue,
                        mainValue.CompareTo(sameValue),
                        (Comparison) mainValue.CompareTo(sameValue));

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, negativeValue,
                        mainValue.CompareTo(negativeValue),
                        (Comparison) mainValue.CompareTo(negativeValue));

      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
                        mainValue, positiveValue,
                        mainValue.CompareTo(positiveValue),
                        (Comparison) mainValue.CompareTo(positiveValue));
   }
}
// The example displays the following output:
//       Comparing 16325 and 0: 1 (GreaterThan).
//       Comparing 16325 and 16325: 0 (Equal).
//       Comparing 16325 and -1934: 1 (GreaterThan).
//       Comparing 16325 and 903624: -1 (LessThan).

open System

type Comparison =
    | LessThan = -1 
    | Equal = 0
    | GreaterThan = 1

let mainValue = 16325
let zeroValue = 0
let negativeValue = -1934
let positiveValue = 903624
let sameValue = 16325

printfn $"Comparing {mainValue} and {zeroValue}: {mainValue.CompareTo zeroValue} ({enum<Comparison>(mainValue.CompareTo zeroValue)})."

printfn $"Comparing {mainValue} and {sameValue}: {mainValue.CompareTo sameValue} ({enum<Comparison>(mainValue.CompareTo sameValue)})."

printfn $"Comparing {mainValue} and {negativeValue}: {mainValue.CompareTo negativeValue} ({enum<Comparison>(mainValue.CompareTo negativeValue)})." 

printfn $"Comparing {mainValue} and {positiveValue}: {mainValue.CompareTo positiveValue} ({enum<Comparison>(mainValue.CompareTo positiveValue)})."

// The example displays the following output:
//       Comparing 16325 and 0: 1 (GreaterThan).
//       Comparing 16325 and 16325: 0 (Equal).
//       Comparing 16325 and -1934: 1 (GreaterThan).
//       Comparing 16325 and 903624: -1 (LessThan).

Public Enum Comparison As Integer
   LessThan = -1
   Equal = 0
   GreaterThan = 1
End Enum

Module ValueComparison
   Public Sub Main()
      Dim mainValue As Integer = 16325
      Dim zeroValue As Integer = 0
      Dim negativeValue As Integer = -1934
      Dim positiveValue As Integer = 903624
      Dim sameValue As Integer = 16325
      
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, zeroValue, _
                        mainValue.CompareTo(zeroValue), _
                        CType(mainValue.CompareTo(zeroValue), Comparison))
                        
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, sameValue, _
                        mainValue.CompareTo(sameValue), _
                        CType(mainValue.CompareTo(sameValue), Comparison))
                        
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, negativeValue, _
                        mainValue.CompareTo(negativeValue), _
                        CType(mainValue.CompareTo(negativeValue), Comparison))
                        
      Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _ 
                        mainValue, positiveValue, _
                        mainValue.CompareTo(positiveValue), _
                        CType(mainValue.CompareTo(positiveValue), Comparison))
   End Sub
End Module
' The example displays the following output:
'       Comparing 16325 and 0: 1 (GreaterThan).
'       Comparing 16325 and 16325: 0 (Equal).
'       Comparing 16325 and -1934: 1 (GreaterThan).
'       Comparing 16325 and 903624: -1 (LessThan).

Remarques

Cette méthode implémente l’interface System.IComparable<T> et fonctionne légèrement mieux que la Int32.CompareTo méthode, car elle n’a pas besoin de convertir le value paramètre en objet .

Selon votre langage de programmation, il peut être possible de coder une CompareTo méthode où le type de paramètre a moins de bits (est plus étroit) que le type d’instance. Cela est possible, car certains langages de programmation effectuent une conversion étendue implicite qui représente le paramètre en tant que type avec autant de bits que l’instance.

Par exemple, supposons que le type d’instance est Int32 et que le type de paramètre est Byte. Le compilateur C# Microsoft génère des instructions pour représenter la valeur du paramètre sous la forme d’un Int32, puis génère une Int32.CompareTo méthode qui compare les valeurs de l’instance Int32 et la représentation du Int32 paramètre.

Consultez la documentation de votre langage de programmation pour déterminer si son compilateur effectue des conversions étendues implicites sur des types numériques.

Voir aussi

• UInt32
• Equals(Object)

CompareTo(Object)

Source:

Int32.cs

Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.

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

public int CompareTo (object? value);

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

Public Function CompareTo (value As Object) As Integer

Paramètres

value

Object

Objet à comparer ou null.

Retours

Int32

Nombre signé indiquant les valeurs relatives de cette instance et value.

Valeur de retour	Description
Inférieure à zéro	Cette instance est inférieure à value.
Zéro	Cette instance est égale à value.
Supérieure à zéro	Cette instance est supérieure à value, ou value est null.

Implémente

CompareTo(Object)

Exceptions

ArgumentException

value n'est pas Int32.

Remarques

Toute instance de Int32, quelle que soit sa valeur, est considérée comme supérieure à null.

value doit être null ou une instance de Int32; sinon, une exception est levée.

Voir aussi

• UInt32
• Equals(Object)