Int32.CompareTo, méthode (Int32) (System)

Changer de vue:

ScriptFree

Bibliothèque de classes .NET Framework

Int32.CompareTo, méthode (Int32)

Cet article a fait l'objet d'une traduction manuelle. Pour afficher simultanément cette page et le contenu source en anglais, choisissez le paramètre d'affichage Basse densité.

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

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

Syntaxe

Visual Basic

Public Function CompareTo ( _
	value As Integer _
) As Integer

public int CompareTo(
	int value
)

VisualC++

public:
virtual int CompareTo(
	int value
) sealed

abstract CompareTo : 
        value:int -> int 
override CompareTo : 
        value:int -> int

Paramètres

value: Type : System.Int32
Entier à comparer.

Valeur de retour

Type : System.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émentations

IComparable<T>.CompareTo(T)

Notes

Cette méthode implémente l'interface System.IComparable<T> et présente des performances légèrement meilleures que la méthode Int32.CompareTo, car elle n'a pas à convertir le paramètre value en objet.

Selon votre langage de programmation, vous avez peut-être la possibilité de coder une méthode CompareTo dans laquelle le type de paramètre comporte moins de bits (est plus restreint) que le type d'instance. C'est possible, car certains langages de programmation effectuent une conversion étendue implicite qui représente le paramètre comme un type comportant autant de bits que l'instance.

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

Consultez la documentation de votre langage de programmation pour savoir si son compilateur exécute des conversions étendues implicites sur les types numériques.

Exemples

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

Visual Basic


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


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));
   }
}

Informations de version

.NET Framework

Pris en charge dans : 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Pris en charge dans :

Plateformes

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Voir aussi

Référence

Int32 Structure

CompareTo, surcharge

System, espace de noms

UInt32

Equals