Tuple<T1,T2,T3,T4>.IStructuralComparable.CompareTo Método

Definição

Compara o objeto Tuple<T1,T2,T3,T4> atual com um objeto especificado usando um comparador especificado e retorna um inteiro que indica se o objeto atual está antes, depois ou na mesma posição do objeto especificado na ordem de classificação.

int IStructuralComparable.CompareTo (object other, System.Collections.IComparer comparer);

Parâmetros

other
Object

Um objeto a ser comparado com a instância atual.

comparer
IComparer

Um objeto que fornece regras personalizadas para comparação.

Retornos

Int32

Um inteiro assinado que indica a posição relativa dessa instância e other na ordem de classificação, conforme mostrado na tabela a seguir.

Valor Descrição
Um inteiro negativo Esta instância precede other.
Zero Esta instância e other têm a mesma posição na ordem de classificação.
Um inteiro positivo Esta instância segue other.

Implementações

Exceções

other não é um objeto Tuple<T1,T2,T3,T4>.

Exemplos

O exemplo a seguir cria uma matriz de Tuple<T1,T2,T3,T4> objetos que contêm dados estatísticos sobre lançadores de beisebol. Os itens de dados incluem o nome do arremessador, o número de innings lançados, a média de corridas ganhas do arremessador (o número médio de corridas que um arremessador permite por jogo), e o número de acertos que o arremessador desistiu. O exemplo exibe o componente de cada tupla na matriz em ordem não classificada, classifica a matriz e, em seguida, chama ToString para exibir o valor de cada tupla em ordem classificada. Para classificar a matriz, o exemplo define uma classe genérica PitcherComparer que implementa a IComparer interface e classifica os Tuple<T1,T2,T3,T4> objetos em ordem crescente pelo valor de seu terceiro componente (a média de execução obtida) em vez de seu primeiro componente. Observe que o exemplo não chama diretamente o IStructuralComparable.CompareTo(Object, IComparer) método. Este método é chamado implicitamente pelo método Array.Sort(Array, IComparer) para cada elemento na matriz.

using System;
using System.Collections;
using System.Collections.Generic;

public class PitcherComparer<T1, T2, T3, T4> : IComparer
{
   public int Compare(object x, object y)
   {
      Tuple<T1, T2, T3, T4> tX = x as Tuple<T1, T2, T3, T4>;
      if (tX == null)
      { 
         return 0;
      }   
      else
      {
         Tuple<T1, T2, T3, T4> tY = y as Tuple<T1, T2, T3, T4>;
         return Comparer<T3>.Default.Compare(tX.Item3, tY.Item3);             
      }
   }
}

public class Example
{
   public static void Main()
   {
      Tuple<string, double, double, int>[] pitchers = 
                    { Tuple.Create("McHale, Joe", 240.1, 3.60, 221),
                      Tuple.Create("Paul, Dave", 233.1, 3.24, 231), 
                      Tuple.Create("Williams, Mike", 193.2, 4.00, 183),
                      Tuple.Create("Blair, Jack", 168.1, 3.48, 146), 
                      Tuple.Create("Henry, Walt", 140.1, 1.92, 96),
                      Tuple.Create("Lee, Adam", 137.2, 2.94, 109),
                      Tuple.Create("Rohr, Don", 101.0, 3.74, 110) };

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

      Console.WriteLine();

      Array.Sort(pitchers, new PitcherComparer<string, double, double, int>());

      Console.WriteLine("The values sorted by earned run average (component 3):");
      foreach (var pitcher in pitchers)
         Console.WriteLine(pitcher.ToString());
   }
}
// The example displays the following output;
//       The values in unsorted order:
//       (McHale, Joe, 240.1, 3.6, 221)
//       (Paul, Dave, 233.1, 3.24, 231)
//       (Williams, Mike, 193.2, 4, 183)
//       (Blair, Jack, 168.1, 3.48, 146)
//       (Henry, Walt, 140.1, 1.92, 96)
//       (Lee, Adam, 137.2, 2.94, 109)
//       (Rohr, Don, 101, 3.74, 110)
//       
//       The values sorted by earned run average (component 3):
//       (Henry, Walt, 140.1, 1.92, 96)
//       (Lee, Adam, 137.2, 2.94, 109)
//       (Rohr, Don, 101, 3.74, 110)
//       (Blair, Jack, 168.1, 3.48, 146)
//       (McHale, Joe, 240.1, 3.6, 221)
//       (Paul, Dave, 233.1, 3.24, 231)
//       (Williams, Mike, 193.2, 4, 183)

Comentários

Este membro é uma implementação do membro de interface explícita. Ele só pode ser usado quando a instância de Tuple<T1,T2,T3,T4> é convertida em uma interface de IStructuralComparable.

Embora esse método possa ser chamado diretamente, ele é mais comumente chamado por métodos de classificação de coleção que incluem IComparer parâmetros para ordenar os membros de uma coleção. Por exemplo, ele é chamado pelo método Array.Sort(Array, IComparer) e pelo método Add de um objeto SortedList que é instanciado usando-se o construtor SortedList.SortedList(IComparer).

Atenção

O IStructuralComparable.CompareTo(Object, IComparer) método destina-se ao uso em operações de classificação. Ele não deve ser usado quando a finalidade principal de uma comparação é determinar se dois objetos são iguais. Para determinar se dois objetos são iguais, chame o IStructuralEquatable.Equals(Object, IEqualityComparer) método.

Aplica-se a

Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7
.NET Framework 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0