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

 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

Parâmetros

Devoluções

Um inteiro assinado que indica a posição relativa desta instância e obj na ordem de ordenação, conforme mostrado na tabela seguinte.

Implementações

Exceções

Exemplos

O exemplo seguinte cria um conjunto de Tuple<T1,T2,T3,T4> objetos cujos componentes consistem no nome do lançador de basebol, número de entradas lançadas e número de rebatidas e corridas merecidas concedidas. Apresenta os componentes de cada tupla no array por ordem não ordenada, ordena o array e depois chama ToString para mostrar cada tupla por ordem ordenada. A saída mostra que o array foi ordenado por nome, que é o primeiro componente. Note que o exemplo não chama diretamente o IComparable.CompareTo(Object) método. Este método é chamado implicitamente pelo Sort(Array) método de cada elemento no array.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Tuple<string, decimal, int, int>[] pitchers  =  
                      { Tuple.Create("McHale, Joe", 240.1m, 221, 96),
                        Tuple.Create("Paul, Dave", 233.1m, 231, 84), 
                        Tuple.Create("Williams, Mike", 193.2m, 183, 86),
                        Tuple.Create("Blair, Jack", 168.1m, 146, 65), 
                        Tuple.Create("Henry, Walt", 140.1m, 96, 30),
                        Tuple.Create("Lee, Adam", 137.2m, 109, 45),
                        Tuple.Create("Rohr, Don", 101.0m, 110, 42) };

      // Display the array in unsorted order.
      Console.WriteLine("The values in unsorted order:");
      foreach (var pitcher in pitchers)
         Console.WriteLine(pitcher.ToString());
      Console.WriteLine();
      
      // Sort the array
      Array.Sort(pitchers);
      
      // Display the array in sorted order.
      Console.WriteLine("The values in sorted order:");
      foreach (var pitcher in pitchers)
         Console.WriteLine(pitcher.ToString());
   }
}
// The example displays the following output;
//       The values in unsorted order:
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Williams, Mike, 193.2, 183, 86)
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (Rohr, Don, 101, 110, 42)
//       
//       The values in sorted order:
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Rohr, Don, 101, 110, 42)
//       (Williams, Mike, 193.2, 183, 86)

open System

let pitchers  =  
    [| Tuple.Create("McHale, Joe", 240.1m, 221, 96)
       Tuple.Create("Paul, Dave", 233.1m, 231, 84)
       Tuple.Create("Williams, Mike", 193.2m, 183, 86)
       Tuple.Create("Blair, Jack", 168.1m, 146, 65)
       Tuple.Create("Henry, Walt", 140.1m, 96, 30)
       Tuple.Create("Lee, Adam", 137.2m, 109, 45)
       Tuple.Create("Rohr, Don", 101.0m, 110, 42) |]

// Display the array in unsorted order.
printfn "The values in unsorted order:"
for pitcher in pitchers do
    printfn $"{pitcher}"
printfn ""

// Sort the array
Array.Sort pitchers

// Display the array in sorted order.
printfn "The values in sorted order:"
for pitcher in pitchers do
    printfn $"{pitcher}"
// The example displays the following output
//       The values in unsorted order:
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Williams, Mike, 193.2, 183, 86)
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (Rohr, Don, 101, 110, 42)
//       
//       The values in sorted order:
//       (Blair, Jack, 168.1, 146, 65)
//       (Henry, Walt, 140.1, 96, 30)
//       (Lee, Adam, 137.2, 109, 45)
//       (McHale, Joe, 240.1, 221, 96)
//       (Paul, Dave, 233.1, 231, 84)
//       (Rohr, Don, 101, 110, 42)
//       (Williams, Mike, 193.2, 183, 86)

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim pitchers() =  
                { Tuple.Create("McHale, Joe", 240.1d, 221, 96),
                  Tuple.Create("Paul, Dave", 233.1d, 231, 84), 
                  Tuple.Create("Williams, Mike", 193.2d, 183, 86),
                  Tuple.Create("Blair, Jack", 168.1d, 146, 65), 
                  Tuple.Create("Henry, Walt", 140.1d, 96, 30),
                  Tuple.Create("Lee, Adam", 137.2d, 109, 45),
                  Tuple.Create("Rohr, Don", 101.0d, 110, 42) }

      ' Display the array in unsorted order.
      Console.WriteLine("The values in unsorted order:")
      For Each pitcher In pitchers
         Console.WriteLine(pitcher.ToString())
      Next
      Console.WriteLine()
      
      ' Sort the array
      Array.Sort(pitchers)
      
      ' Display the array in sorted order.
      Console.WriteLine("The values in sorted order:")
      For Each pitcher In pitchers
         Console.WriteLine(pitcher.ToString())
      Next
   End Sub
End Module
' The example displays the following output:
'       The values in unsorted order:
'       (McHale, Joe, 240.1, 221, 96)
'       (Paul, Dave, 233.1, 231, 84)
'       (Williams, Mike, 193.2, 183, 86)
'       (Blair, Jack, 168.1, 146, 65)
'       (Henry, Walt, 140.1, 96, 30)
'       (Lee, Adam, 137.2, 109, 45)
'       (Rohr, Don, 101, 110, 42)
'       
'       The values in sorted order:
'       (Blair, Jack, 168.1, 146, 65)
'       (Henry, Walt, 140.1, 96, 30)
'       (Lee, Adam, 137.2, 109, 45)
'       (McHale, Joe, 240.1, 221, 96)
'       (Paul, Dave, 233.1, 231, 84)
'       (Rohr, Don, 101, 110, 42)
'       (Williams, Mike, 193.2, 183, 86)

Observações

Este membro é uma implementação explícita de membro de interface. Só pode ser usado quando a Tuple<T1,T2,T3,T4> instância é transmitida para uma IComparable interface.

Este método fornece a IComparable.CompareTo implementação para a Tuple<T1,T2,T3,T4> classe. Embora o método possa ser chamado diretamente, é mais frequentemente chamado pelas sobrecargas padrão dos métodos de ordenação de coleções, como Array.Sort(Array) e SortedList.Add, para ordenar os membros de uma coleção.

O IComparable.CompareTo método utiliza o comparador de objetos padrão para comparar cada componente.

Ver também

• Equals(Object)