Tuple<T1,T2>.IStructuralComparable.CompareTo(Object, IComparer) Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Compara o objeto Tuple<T1,T2> 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.
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 -> intFunction CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareToParâ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
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>.
Exemplos
O exemplo a seguir cria uma matriz de Tuple<T1,T2> objetos que consistem no nome e na pontuação de teste de um aluno. Ele 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 ScoreComparer que implementa a IComparer interface e classifica os Tuple<T1,T2> objetos em ordem crescente pelo valor de seu segundo componente em vez de seu primeiro componente. Observe que o exemplo não chama diretamente o IStructuralComparable.CompareTo 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 ScoreComparer<T1, T2> : IComparer
{
public int Compare(object x, object y)
{
Tuple<T1, T2> tX = x as Tuple<T1,T2>;
if (tX == null)
{
return 0;
}
else
{
Tuple<T1, T2> tY = y as Tuple<T1, T2>;
return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2);
}
}
}
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 (var score in scores)
Console.WriteLine(score.ToString());
Console.WriteLine();
Array.Sort(scores, new ScoreComparer<string, Nullable<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)
// (Abbey, 92)
// (Dave, 88)
// (Sam, 91)
// (Ed, )
// (Penelope, 82)
// (Linda, 99)
// (Judith, 84)
//
// The values in sorted order:
// (Ed, )
// (Jack, 78)
// (Penelope, 82)
// (Judith, 84)
// (Dave, 88)
// (Sam, 91)
// (Abbey, 92)
// (Linda, 99)
open System
open System.Collections
open System.Collections.Generic
type ScoreComparer<'T1, 'T2>() =
interface IComparer with
member _.Compare(x: obj, y: obj) =
match x with
| :? Tuple<'T1, 'T2> as tX ->
let tY = y :?> Tuple<'T1, 'T2>
Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2)
| _ -> 0
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, ScoreComparer<string, Nullable<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)
// (Abbey, 92)
// (Dave, 88)
// (Sam, 91)
// (Ed, )
// (Penelope, 82)
// (Linda, 99)
// (Judith, 84)
//
// The values in sorted order:
// (Ed, )
// (Jack, 78)
// (Penelope, 82)
// (Judith, 84)
// (Dave, 88)
// (Sam, 91)
// (Abbey, 92)
// (Linda, 99)
Imports System.Collections
Imports System.Collections.Generic
Public Class ScoreComparer(Of T1, T2) : Implements IComparer
Public Function Compare(x As Object, y As Object) As Integer _
Implements IComparer.Compare
Dim tX As Tuple(Of T1, T2) = TryCast(x, Tuple(Of T1, T2))
If tX Is Nothing Then
Return 0
Else
Dim tY As Tuple(Of T1, T2) = DirectCast(y, Tuple(Of T1, T2))
Return Comparer(Of T2).Default.Compare(tx.Item2, tY.Item2)
End If
End Function
End Class
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, New ScoreComparer(Of String, Nullable(Of 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)
' (Abbey, 92)
' (Dave, 88)
' (Sam, 91)
' (Ed, )
' (Penelope, 82)
' (Linda, 99)
' (Judith, 84)
'
' The values in sorted order:
' (Ed, )
' (Jack, 78)
' (Penelope, 82)
' (Judith, 84)
' (Dave, 88)
' (Sam, 91)
' (Abbey, 92)
' (Linda, 99)
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> é 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).
Cuidado
O IStructuralComparable.CompareTo 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 método.