Tuple<T1,T2>.IComparable.CompareTo(Object) Metoda

Definicja

Porównuje bieżący Tuple<T1,T2> obiekt z określonym obiektem i zwraca liczbę całkowitą wskazującą, czy bieżący obiekt znajduje się przed, po, czy w tej samej pozycji co określony obiekt w kolejności sortowania.

 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

Parametry

obj
Object

Obiekt, który ma zostać porównany z bieżącym wystąpieniem.

Zwraca

Int32

Podpisana liczba całkowita wskazująca względną pozycję tego wystąpienia i obj w kolejności sortowania, jak pokazano w poniższej tabeli.

Wartość Opis
Ujemna liczba całkowita To wystąpienie poprzedza obj.
Zero To wystąpienie i obj mają tę samą pozycję w kolejności sortowania.
Dodatnia liczba całkowita To wystąpienie jest zgodne z .obj

Implementuje

Wyjątki

obj nie jest obiektem Tuple<T1,T2> .

Przykłady

Poniższy przykład tworzy tablicę Tuple<T1,T2> obiektów, które składają się z nazwy ucznia i wyniku testu. Wyświetla składnik każdej krotki w tablicy w kolejności niesortowanej, sortuje tablicę, a następnie wywołuje ToString metodę wyświetlania wartości każdej krotki w kolejności sortowania. Dane wyjściowe pokazują, że tablica została posortowana według jej pierwszego składnika. Zwróć uwagę, że przykład nie wywołuje IComparable.CompareTo(Object) bezpośrednio metody . Ta metoda jest wywoływana niejawnie przez metodę Sort(Array) dla każdego elementu w tablicy.

using System;

public class Example
{
   public static void Main()
   {
      Tuple<string, Nullable<int>>[] scores = 
                    { new Tuple<string, Nullable<int>>("Jack", 78),
                      new Tuple<string, Nullable<int>>("Abbey", 92), 
                      new Tuple<string, Nullable<int>>("Dave", 88),
                      new Tuple<string, Nullable<int>>("Sam", 91), 
                      new Tuple<string, Nullable<int>>("Ed", null),
                      new Tuple<string, Nullable<int>>("Penelope", 82),
                      new Tuple<string, Nullable<int>>("Linda", 99),
                      new Tuple<string, Nullable<int>>("Judith", 84) };

      Console.WriteLine("The values in unsorted order:");
      foreach (Tuple<string, Nullable<int>> score in scores)
         Console.WriteLine(score.ToString());

      Console.WriteLine();

      Array.Sort(scores);

      Console.WriteLine("The values in sorted order:");
      foreach (Tuple<string, Nullable<int>> score in scores)
         Console.WriteLine(score.ToString());
   }
}
// The example displays the following output;
//       The values in unsorted order:
//       (Jack, 78)
//       (Abbey, 92)
//       (Dave, 88)
//       (Sam, 91)
//       (Ed, )
//       (Penelope, 82)
//       (Linda, 99)
//       (Judith, 84)
//       
//       The values in sorted order:
//       (Abbey, 92)
//       (Dave, 88)
//       (Ed, )
//       (Jack, 78)
//       (Judith, 84)
//       (Linda, 99)
//       (Penelope, 82)
//       (Sam, 91)
open System

let scores = 
    [| Tuple<string, Nullable<int>>("Jack", 78)
       Tuple<string, Nullable<int>>("Abbey", 92) 
       Tuple<string, Nullable<int>>("Dave", 88)
       Tuple<string, Nullable<int>>("Sam", 91) 
       Tuple<string, Nullable<int>>("Ed", Nullable())
       Tuple<string, Nullable<int>>("Penelope", 82)
       Tuple<string, Nullable<int>>("Linda", 99)
       Tuple<string, Nullable<int>>("Judith", 84) |]

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)
//       (Abbey, 92)
//       (Dave, 88)
//       (Sam, 91)
//       (Ed, )
//       (Penelope, 82)
//       (Linda, 99)
//       (Judith, 84)
//       
//       The values in sorted order:
//       (Abbey, 92)
//       (Dave, 88)
//       (Ed, )
//       (Jack, 78)
//       (Judith, 84)
//       (Linda, 99)
//       (Penelope, 82)
//       (Sam, 91)
Module Example
   Public Sub Main()
      Dim scores() As Tuple(Of String, Nullable(Of Integer)) = 
                      { New Tuple(Of String, Nullable(Of Integer))("Jack", 78),
                        New Tuple(Of String, Nullable(Of Integer))("Abbey", 92), 
                        New Tuple(Of String, Nullable(Of Integer))("Dave", 88),
                        New Tuple(Of String, Nullable(Of Integer))("Sam", 91), 
                        New Tuple(Of String, Nullable(Of Integer))("Ed", Nothing),
                        New Tuple(Of String, Nullable(Of Integer))("Penelope", 82),
                        New Tuple(Of String, Nullable(Of Integer))("Linda", 99),
                        New Tuple(Of String, Nullable(Of Integer))("Judith", 84) }

      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)
'       (Abbey, 92)
'       (Dave, 88)
'       (Sam, 91)
'       (Ed, )
'       (Penelope, 82)
'       (Linda, 99)
'       (Judith, 84)
'       
'       The values in sorted order:
'       (Abbey, 92)
'       (Dave, 88)
'       (Ed, )
'       (Jack, 78)
'       (Judith, 84)
'       (Linda, 99)
'       (Penelope, 82)
'       (Sam, 91)

Uwagi

Ten element jest jawną implementacją członków. Można go używać tylko wtedy, gdy Tuple<T1,T2> wystąpienie jest rzutowe do interfejsu IComparable .

Ta metoda zapewnia implementację IComparable.CompareTo Tuple<T1,T2> klasy . Chociaż metoda może być wywoływana bezpośrednio, najczęściej jest wywoływana przez domyślne przeciążenia metod sortowania kolekcji, takich jak Array.Sort(Array) i SortedList.Add, w celu uporządkowania elementów członkowskich kolekcji.

Przestroga

Metoda jest przeznaczona Tuple<T1,T2>.IComparable.CompareTo do użycia w operacjach sortowania. Nie należy jej używać, gdy głównym celem porównania jest ustalenie, czy dwa obiekty są sobie równe. Aby określić, czy dwa obiekty są równe, wywołaj metodę Equals .

Metoda Tuple<T1,T2>.IComparable.CompareTo używa domyślnego modułu porównującego obiekty do porównywania każdego składnika.

Dotyczy

Zobacz też