Tuple<T1,T2,T3,T4,T5,T6,T7>.IStructuralComparable.CompareTo Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Confronta l'oggetto corrente Tuple<T1,T2,T3,T4,T5,T6,T7> con un oggetto specificato utilizzando un operatore di confronto specificato e restituisce un intero che indica se l'oggetto corrente è precedente, successivo o nella stessa posizione dell'oggetto specificato nell'ordinamento.
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.CompareToParametri
- other
- Object
Oggetto da confrontare con l'istanza corrente.
- comparer
- IComparer
Oggetto che fornisce regole personalizzate per il confronto.
Valori restituiti
Intero con segno che indica la posizione relativa di questa istanza e other nell'ordinamento, come illustrato nella tabella seguente.
| Valore | Descrizione |
|---|---|
| Intero negativo | Questa istanza precede other.
|
| Zero | Questa istanza e other ha la stessa posizione nell'ordinamento.
|
| Intero positivo | Questa istanza segue other.
|
Implementazioni
Eccezioni
other non è un Tuple<T1,T2,T3,T4,T5,T6,T7> oggetto .
Esempio
L'esempio seguente crea una matrice di oggetti che contiene i dati sulla Tuple<T1,T2,T3,T4,T5,T6,T7> popolazione per tre città degli Stati Uniti dal 1950 al 2000. Il primo componente del setuple è il nome della città. I cinque componenti rimanenti rappresentano la popolazione a intervalli di 10 anni dal 1950 al 2000.
La PopulationComparer classe fornisce un'implementazione IComparer che consente di ordinare la matrice di setti in base a uno dei relativi componenti. Due valori vengono forniti alla PopulationComparer classe nel relativo costruttore: la posizione del componente che definisce l'ordinamento e un Boolean valore che indica se gli oggetti tupla devono essere ordinati in ordine crescente o decrescente.
L'esempio visualizza quindi gli elementi nella matrice in ordine non ordinato, li ordina in base al terzo componente (popolazione nel 1960) e li visualizza e li ordina in base al sesto componente (popolazione nel 1990) e li visualizza.
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)
Commenti
Questo membro è un'implementazione esplicita dell'interfaccia. Può essere usato solo quando viene eseguito il cast dell'istanza a un'interfaccia Tuple<T1,T2,T3,T4,T5,T6,T7>IStructuralComparable .
Questo metodo consente di definire confronti personalizzati di Tuple<T1,T2,T3,T4,T5,T6,T7> oggetti. Ad esempio, è possibile utilizzare questo metodo per ordinare Tuple<T1,T2,T3,T4,T5,T6,T7> gli oggetti in base al valore di un componente specifico.
Anche se questo metodo può essere chiamato direttamente, viene comunemente chiamato dai metodi di ordinamento delle raccolte che includono IComparer parametri per ordinare i membri di una raccolta. Ad esempio, viene chiamato dal Array.Sort(Array, IComparer) metodo e dal Add metodo di un oggetto di cui viene creata un'istanza SortedList usando il SortedList.SortedList(IComparer) costruttore .
Attenzione
Il IStructuralComparable.CompareTo metodo è destinato all'uso nelle operazioni di ordinamento. Non deve essere usato quando lo scopo principale di un confronto è determinare se due oggetti sono uguali. Per determinare se due oggetti sono uguali, chiamare il IStructuralEquatable.Equals metodo .
