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

 virtual int System.Collections.IStructuralComparable.CompareTo(System::Object ^ other, System::Collections::IComparer ^ comparer) = System::Collections::IStructuralComparable::CompareTo;

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

abstract member System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int
override this.System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int

Function CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareTo

Parâmetros

Devoluções

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

Implementações

Exceções

Exemplos

O exemplo seguinte cria um array de Tuple<T1,T2,T3> objetos que consistem no nome do aluno, a pontuação média dos testes e o número de testes. Apresenta o componente de cada tupla no array por ordem não ordenada, ordena o array e depois chama ToString para mostrar o valor de cada tupla por ordem ordenada. Para ordenar o array, o exemplo define uma classe genérica ScoreComparer que implementa a IComparer interface e ordena os Tuple<T1,T2,T3> objetos por ordem crescente pelo valor do seu segundo componente em vez do primeiro. Note que o exemplo não chama diretamente o Tuple<T1,T2,T3>.IStructuralComparable.CompareTo método. Este método é chamado implicitamente pelo Array.Sort(Array, IComparer) método de cada elemento no array.

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

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

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, new ScoreComparer<string, double, int>());

      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:
//       (Ed, 71.2, 5)
//       (Jack, 78.8, 8)
//       (Penelope, 82.9, 8)
//       (Judith, 84.3, 9)
//       (Dave, 88.3, 9)
//       (Sam, 91.7, 8)
//       (Abbey, 92.1, 9)
//       (Linda, 99, 9)

open System
open System.Collections
open System.Collections.Generic

type ScoreComparer<'T1, 'T2, 'T3>() =
    interface IComparer with
        member _.Compare(x: obj, y: obj) =
            match x with
            | :? Tuple<'T1, 'T2, 'T3> as tX -> 
                let tY = y :?> Tuple<'T1, 'T2, 'T3>
                Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2)             
            | _ -> 0

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, ScoreComparer<string, double, int>())

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:
//       (Ed, 71.2, 5)
//       (Jack, 78.8, 8)
//       (Penelope, 82.9, 8)
//       (Judith, 84.3, 9)
//       (Dave, 88.3, 9)
//       (Sam, 91.7, 8)
//       (Abbey, 92.1, 9)
//       (Linda, 99, 9)

Imports System.Collections
Imports System.Collections.Generic

Public Class ScoreComparer(Of T1, T2, T3) : Implements IComparer
   Public Function Compare(x As Object, y As Object) As Integer _
                   Implements IComparer.Compare
      Dim tX As Tuple(Of T1, T2, T3) = TryCast(x, Tuple(Of T1, T2, T3))
      If tX Is Nothing Then
         Return 0
      Else
         Dim tY As Tuple(Of T1, T2, T3) = DirectCast(y, Tuple(Of T1, T2, T3))
         Return Comparer(Of T2).Default.Compare(tx.Item2, tY.Item2)             
      End If
   End Function
End Class

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, New ScoreComparer(Of String, Double, Integer)())

      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:
'       (Ed, 71.2, 5)
'       (Jack, 78.8, 8)
'       (Penelope, 82.9, 8)
'       (Judith, 84.3, 9)
'       (Dave, 88.3, 9)
'       (Sam, 91.7, 8)
'       (Abbey, 92.1, 9)
'       (Linda, 99, 9)

Observações

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

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

Ver também

• IStructuralEquatable.Equals(Object, IEqualityComparer)