Tuple<T1,T2,T3,T4,T5,T6,T7>.IStructuralComparable.CompareTo 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,T3,T4,T5,T6,T7> 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,T3,T4,T5,T6,T7>.
Exemplos
O exemplo a seguir cria uma matriz de Tuple<T1,T2,T3,T4,T5,T6,T7> objetos que contém dados populacionais para três cidades dos EUA de 1950 a 2000. O primeiro componente da septupla é o nome da cidade. Os cinco componentes restantes representam a população em intervalos de 10 anos de 1950 a 2000.
A PopulationComparer classe fornece uma implementação IComparer que permite que a matriz de septuplas seja classificada por qualquer um de seus componentes. Dois valores são fornecidos à PopulationComparer classe em seu construtor: a posição do componente que define a ordem de classificação e um Boolean valor que indica se os objetos de tupla devem ser classificados em ordem crescente ou decrescente.
Em seguida, o exemplo exibe os elementos na matriz em ordem não classificada, classifica-os pelo terceiro componente (a população em 1960) e os exibe e os classifica pelo sexto componente (a população em 1990) e os exibe.
using System;
using System.Collections;
using System.Collections.Generic;
public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7> : IComparer
{
private int itemPosition;
private int multiplier = -1;
public PopulationComparer(int component) : this(component, true)
{ }
public PopulationComparer(int component, bool descending)
{
if (! descending) multiplier = 1;
if (component <= 0 || component > 7)
throw new ArgumentException("The component argument is out of range.");
itemPosition = component;
}
public int Compare(object x, object y)
{
Tuple<T1, T2, T3, T4, T5, T6, T7> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7>;
if (tX == null)
{
return 0;
}
else
{
Tuple<T1, T2, T3, T4, T5, T6, T7> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7>;
switch (itemPosition)
{
case 1:
return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
case 2:
return Comparer<T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier;
case 3:
return Comparer<T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier;
case 4:
return Comparer<T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier;
case 5:
return Comparer<T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier;
case 6:
return Comparer<T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier;
case 7:
return Comparer<T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier;
default:
return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
}
}
}
}
public class Example
{
public static void Main()
{
// Create array of sextuple with population data for three U.S.
// cities, 1960-2000.
Tuple<string, int, int, int, int, int, int>[] cities =
{ Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 3620962, 3550904, 3366957, 3005072, 2783726, 2896016) };
// Display array in unsorted order.
Console.WriteLine("In unsorted order:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
Console.WriteLine();
Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int>(3));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 1960:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
Console.WriteLine();
Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int>(6));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 1990:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
}
}
// The example displays the following output:
// In unsorted order:
// (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//
// Sorted by population in 1960:
// (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 1990:
// (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
open System
open System.Collections
open System.Collections.Generic
type PopulationComparer<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>(itemPosition, descending) =
let multiplier = if descending then -1 else 1
do
if itemPosition <= 0 || itemPosition > 7 then
invalidArg "itemPosition" "The itemPosition argument is out of range."
new (itemPosition) = PopulationComparer(itemPosition, true)
interface IComparer with
member _.Compare(x, y) =
match x with
| :? Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> as tX ->
let tY = y :?> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7>
match itemPosition with
| 1 ->
Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
| 2 ->
Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier
| 3 ->
Comparer<'T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier
| 4 ->
Comparer<'T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier
| 5 ->
Comparer<'T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier
| 6 ->
Comparer<'T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier
| 7 ->
Comparer<'T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier
| _ ->
Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
| _ -> 0
// Create array of sextuple with population data for three U.S.
// cities, 1960-2000.
let cities =
[| Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
Tuple.Create("Chicago", 3620962, 3550904, 3366957, 3005072, 2783726, 2896016) |]
// Display array in unsorted order.
printfn "In unsorted order:"
for city in cities do
printfn $"{city}"
printfn ""
Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int> 3)
// Display array in sorted order.
printfn "Sorted by population in 1960:"
for city in cities do
printfn $"{city}"
printfn ""
Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int> 6)
// Display array in sorted order.
printfn "Sorted by population in 1990:"
for city in cities do
printfn $"{city}"
// The example displays the following output ->
// In unsorted order ->
// (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//
// Sorted by population in 1960 ->
// (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 1990 ->
// (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
Imports System.Collections
Imports System.Collections.Generic
Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6, T7) : Implements IComparer
Private itemPosition As Integer
Private multiplier As Integer = -1
Public Sub New(component As Integer)
Me.New(component, True)
End Sub
Public Sub New(component As Integer, descending As Boolean)
If Not descending Then multiplier = 1
If component <= 0 Or component > 7 Then
Throw New ArgumentException("The component argument is out of range.")
End If
itemPosition = component
End Sub
Public Function Compare(x As Object, y As Object) As Integer _
Implements IComparer.Compare
Dim tX As Tuple(Of T1, T2, T3, T4, T5, T6, T7) = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6, T7))
If tX Is Nothing Then
Return 0
Else
Dim tY As Tuple(Of T1, T2, T3, T4, T5, T6, T7) = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6, T7))
Select Case itemPosition
Case 1
Return Comparer(Of T1).Default.Compare(tX.Item1, tY.Item1) * multiplier
Case 2
Return Comparer(Of T2).Default.Compare(tX.Item2, tY.Item2) * multiplier
Case 3
Return Comparer(Of T3).Default.Compare(tX.Item3, tY.Item3) * multiplier
Case 4
Return Comparer(Of T4).Default.Compare(tX.Item4, tY.Item4) * multiplier
Case 5
Return Comparer(Of T5).Default.Compare(tX.Item5, tY.Item5) * multiplier
Case 6
Return Comparer(Of T6).Default.Compare(tX.Item6, tY.Item6) * multiplier
Case 7
Return Comparer(Of T7).Default.Compare(tX.Item7, tY.Item7) * multiplier
' This should never be reached.
Case Else
Return 0
End Select
End If
End Function
End Class
Module Example
Public Sub Main()
' Create array of sextuple with population data for three U.S.
' cities, 1950-2000.
Dim cities() =
{ Tuple.Create("Los Angeles", 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 3620962, 3550904, 3366957, 3005072, 2783726, 2896016) }
' Display array in unsorted order.
Console.WriteLine("In unsorted order:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
Console.WriteLine()
Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer)(3))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 1960:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
Console.WriteLine()
Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer)(6))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 1990:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
End Sub
End Module
' The example displays the following output:
' In unsorted order:
' (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
' (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'
' Sorted by population in 1960:
' (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'
' Sorted by population in 1990:
' (New York, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Los Angeles, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
' (Chicago, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
Comentários
Este membro é uma implementação de interface explícita. Ele só pode ser usado quando a instância de Tuple<T1,T2,T3,T4,T5,T6,T7> é convertida em uma interface de IStructuralComparable.
Esse método permite definir comparações personalizadas de Tuple<T1,T2,T3,T4,T5,T6,T7> objetos. Por exemplo, você pode usar esse método para ordenar Tuple<T1,T2,T3,T4,T5,T6,T7> objetos com base no valor de um componente específico.
Embora possa ser chamado diretamente, esse método é mais comumente chamado pelos métodos de classificação de coleção que incluem parâmetros IComparer para classificar 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.