Partage via


Tuple<T1,T2,T3>.IComparable.CompareTo(Object) Méthode

Définition

Compare l’objet Tuple<T1,T2,T3> actuel à un objet spécifié et renvoie un entier qui indique si l’objet actuel est avant, après ou à la même position que l’objet spécifié dans l’ordre de tri.

 virtual int System.IComparable.CompareTo(System::Object ^ obj) = IComparable::CompareTo;
int IComparable.CompareTo (object obj);
abstract member System.IComparable.CompareTo : obj -> int
override this.System.IComparable.CompareTo : obj -> int
Function CompareTo (obj As Object) As Integer Implements IComparable.CompareTo

Paramètres

obj
Object

Objet à comparer à l'instance actuelle.

Retours

Entier signé qui indique la position relative de cette instance et de obj dans l’ordre de tri, comme indiqué dans le tableau suivant.

Valeur Description
Entier négatif Cette instance précède obj.
Zéro Cette instance et obj ont la même position dans l'ordre de tri.
Entier positif Cette instance suit obj.

Implémente

Exceptions

obj n’est pas un objet Tuple<T1,T2,T3>.

Exemples

L’exemple suivant crée un tableau d’objets Tuple<T1,T2,T3> dont les composants se composent du nom d’un étudiant, du score moyen des tests et du nombre de tests. Il affiche les composants de chaque tuple dans le tableau dans un ordre non trié, trie le tableau, puis appelle ToString pour afficher chaque tuple dans l’ordre trié. La sortie indique que le tableau a été trié par son premier composant. Notez que l’exemple n’appelle pas directement la Tuple<T1,T2,T3>.IComparable.CompareTo méthode . Cette méthode est appelée implicitement par la Sort(Array) méthode pour chaque élément du tableau.

using System;

public class Example
{
   public static void Main()
   {
      Tuple<string, double, int>[] scores = 
                    { Tuple.Create("Jack", 78.8, 8),
                      Tuple.Create("Abbey", 92.1, 9), 
                      Tuple.Create("Dave", 88.3, 9),
                      Tuple.Create("Sam", 91.7, 8), 
                      Tuple.Create("Ed", 71.2, 5),
                      Tuple.Create("Penelope", 82.9, 8),
                      Tuple.Create("Linda", 99.0, 9),
                      Tuple.Create("Judith", 84.3, 9) };

      Console.WriteLine("The values in unsorted order:");
      foreach (var score in scores)
         Console.WriteLine(score.ToString());

      Console.WriteLine();

      Array.Sort(scores);

      Console.WriteLine("The values in sorted order:");
      foreach (var score in scores)
         Console.WriteLine(score.ToString());
   }
}
// The example displays the following output;
//    The values in unsorted order:
//    (Jack, 78.8, 8)
//    (Abbey, 92.1, 9)
//    (Dave, 88.3, 9)
//    (Sam, 91.7, 8)
//    (Ed, 71.2, 5)
//    (Penelope, 82.9, 8)
//    (Linda, 99, 9)
//    (Judith, 84.3, 9)
//    
//    The values in sorted order:
//    (Abbey, 92.1, 9)
//    (Dave, 88.3, 9)
//    (Ed, 71.2, 5)
//    (Jack, 78.8, 8)
//    (Judith, 84.3, 9)
//    (Linda, 99, 9)
//    (Penelope, 82.9, 8)
//    (Sam, 91.7, 8)
open System

let scores = 
    [| Tuple.Create("Jack", 78.8, 8)
       Tuple.Create("Abbey", 92.1, 9)
       Tuple.Create("Dave", 88.3, 9)
       Tuple.Create("Sam", 91.7, 8)
       Tuple.Create("Ed", 71.2, 5)
       Tuple.Create("Penelope", 82.9, 8)
       Tuple.Create("Linda", 99.0, 9)
       Tuple.Create("Judith", 84.3, 9) |]
 
printfn "The values in unsorted order:"
for score in scores do
    printfn $"{score}"

printfn ""

Array.Sort scores

printfn "The values in sorted order"
for score in scores do
    printfn $"{score}"
// The example displays the following output
//    The values in unsorted order:
//    (Jack, 78.8, 8)
//    (Abbey, 92.1, 9)
//    (Dave, 88.3, 9)
//    (Sam, 91.7, 8)
//    (Ed, 71.2, 5)
//    (Penelope, 82.9, 8)
//    (Linda, 99, 9)
//    (Judith, 84.3, 9)
//    
//    The values in sorted order:
//    (Abbey, 92.1, 9)
//    (Dave, 88.3, 9)
//    (Ed, 71.2, 5)
//    (Jack, 78.8, 8)
//    (Judith, 84.3, 9)
//    (Linda, 99, 9)
//    (Penelope, 82.9, 8)
//    (Sam, 91.7, 8)
Module Example
   Public Sub Main()
      Dim scores() = 
                 { Tuple.Create("Jack", 78.8, 8),
                   Tuple.Create("Abbey", 92.1, 9), 
                   Tuple.Create("Dave", 88.3, 9),
                   Tuple.Create("Sam", 91.7, 8), 
                   Tuple.Create("Ed", 71.2, 5),
                   Tuple.Create("Penelope", 82.9, 8),
                   Tuple.Create("Linda", 99.0, 9),
                   Tuple.Create("Judith", 84.3, 9) }

      Console.WriteLine("The values in unsorted order:")
      For Each score In scores
         Console.WriteLine(score.ToString())
      Next
      Console.WriteLine()

      Array.Sort(scores)

      Console.WriteLine("The values in sorted order:")
      For Each score In scores
         Console.WriteLine(score.ToString())
      Next
   End Sub
End Module
' The example displays the following output;
'    The values in unsorted order:
'    (Jack, 78.8, 8)
'    (Abbey, 92.1, 9)
'    (Dave, 88.3, 9)
'    (Sam, 91.7, 8)
'    (Ed, 71.2, 5)
'    (Penelope, 82.9, 8)
'    (Linda, 99, 9)
'    (Judith, 84.3, 9)
'    
'    The values in sorted order:
'    (Abbey, 92.1, 9)
'    (Dave, 88.3, 9)
'    (Ed, 71.2, 5)
'    (Jack, 78.8, 8)
'    (Judith, 84.3, 9)
'    (Linda, 99, 9)
'    (Penelope, 82.9, 8)
'    (Sam, 91.7, 8)

Remarques

Ce membre est une implémentation d'un membre d'interface explicite. Il peut uniquement être utilisé lorsque l'instance de Tuple<T1,T2,T3> est castée en interface IComparable.

Cette méthode fournit l’implémentation IComparable.CompareTo de la Tuple<T1,T2,T3> classe . Bien que la méthode puisse être appelée directement, elle est généralement appelée par les surcharges par défaut des méthodes de tri de collection, telles que Array.Sort(Array) et SortedList.Add, pour classer les membres d’une collection.

Attention

La Tuple<T1,T2,T3>.IComparable.CompareTo méthode est destinée à être utilisée dans les opérations de tri. Il ne doit pas être utilisé lorsque l’objectif principal d’une comparaison est de déterminer si deux objets sont égaux. Pour déterminer si deux objets sont égaux, appelez la Equals méthode .

La Tuple<T1,T2,T3>.IComparable.CompareTo méthode utilise le comparateur d’objets par défaut pour comparer chaque composant.

S’applique à

Voir aussi