Int32.CompareTo Méthode

Compare cette instance à un entier 32 bits signé et retourne une indication de leurs valeurs relatives.Compares this instance to a specified 32-bit signed integer and returns an indication of their relative values.

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

Retours

Implémente

Exemples

L’exemple suivant illustre la méthode Int32.CompareTo(Int32).The following example demonstrates the Int32.CompareTo(Int32) method. Outre l’affichage de la valeur retournée par la méthode pour quatre comparaisons différentes, elle convertit la valeur de retour en un membre de l’énumération Comparison personnalisée, dont la valeur est également affichée.In addition to displaying the value returned by the method for four different comparisons, it converts the return value to a member of the custom Comparison enumeration, whose value it also displays.

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

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 s’exécute légèrement mieux que la méthode Int32.CompareTo, car elle n’a pas besoin de convertir le paramètre value en objet.This method implements the System.IComparable<T> interface and performs slightly better than the Int32.CompareTo method because it does not have to convert the value parameter to an object.

En fonction de votre langage de programmation, il peut être possible de coder une méthode CompareTo dans laquelle le type de paramètre a moins de bits (est plus étroit) que le type d’instance.Depending on your programming language, it might be possible to code a CompareTo method where the parameter type has fewer bits (is narrower) than the instance type. Cela est possible parce que 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.This is possible because some programming languages perform an implicit widening conversion that represents the parameter as a type with as many bits as the instance.

Par exemple, supposez que le type d’instance est Int32 et que le type de paramètre est Byte.For example, suppose the instance type is Int32 and the parameter type is 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 méthode Int32.CompareTo qui compare les valeurs de l’instance Int32 et la représentation du paramètre Int32.The Microsoft C# compiler generates instructions to represent the value of the parameter as an Int32, then generates a Int32.CompareTo method that compares the values of the Int32 instance and the Int32 parameter representation.

Consultez la documentation de votre langage de programmation pour déterminer si son compilateur effectue des conversions étendues implicites sur des types numériques.Consult your programming language's documentation to determine whether its compiler performs implicit widening conversions on numeric types.

Voir aussi

• UInt32
• Equals(Object)

Compare cette instance à un objet spécifié et retourne une indication de leurs valeurs relatives.Compares this instance to a specified object and returns an indication of their relative values.

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

Retours

Implémente

Exceptions

Remarques

Toute instance de Int32, quelle que soit sa valeur, est considérée comme supérieure à null.Any instance of Int32, regardless of its value, is considered greater than null.

value doit être null ou une instance de Int32; dans le cas contraire, une exception est levée.value must be null or an instance of Int32; otherwise, an exception is thrown.

Voir aussi

• UInt32
• Equals(Object)