Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Compare l'objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> actif à un objet spécifié à l'aide d'un comparateur spécifié et retourne un entier qui indique si l'objet actif précède, suit ou se trouve à la même position que l'objet spécifié dans l'ordre de tri.
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.CompareToParamètres
- other
- Object
Objet à comparer à l'instance actuelle.
- comparer
- IComparer
Un objet qui fournit des règles personnalisées pour la comparaison.
Retours
Entier signé qui indique la position relative de cette instance et de other dans l’ordre de tri, comme indiqué dans le tableau suivant.
| Valeur | Description |
|---|---|
| Entier négatif | Cette instance précède other.
|
| Zéro | Cette instance et other ont la même position dans l'ordre de tri.
|
| Entier positif | Cette instance suit other.
|
Implémente
Exceptions
other n’est pas un objet Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.
Exemples
L’exemple suivant crée un tableau d’objets qui contient des Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> données de population pour quatre villes américaines de 1940 à 2000. Le premier composant de l’octuple est le nom de la ville. Les six autres composantes représentent la population à des intervalles de 10 ans, de 1940 à 2000.
La PopulationComparer classe fournit une IComparer implémentation qui permet au tableau d’octuples d’être trié par l’un de ses composants. Deux valeurs sont fournies à la PopulationComparer classe dans son constructeur : la position du composant qui définit l’ordre de tri et une Boolean valeur qui indique si les objets tuple doivent être triés dans l’ordre croissant ou décroissant.
L’exemple affiche ensuite les éléments du tableau dans un ordre non trié, les trie selon le troisième composant (la population en 1950) et les affiche, puis les trie selon le huitième composant (la population en 2000) et les affiche.
using System;
using System.Collections;
using System.Collections.Generic;
public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7, T8> : 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 > 8)
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, Tuple<T8>> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
if (tX == null)
return 0;
Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
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;
case 8:
return Comparer<T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier;
default:
return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
}
}
}
public class Example
{
public static void Main()
{
// Create array of octuples with population data for three U.S.
// cities, 1940-2000.
Tuple<string, int, int, int, int, int, int, Tuple<int>>[] cities =
{ Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),
Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) };
// 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, int>(2));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 1950:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
Console.WriteLine();
Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int, int>(8));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 2000:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
}
}
// The example displays the following output:
// In unsorted order:
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//
// Sorted by population in 1950:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 2000:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
open System
open System.Collections
open System.Collections.Generic
type PopulationComparer<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>(itemPosition, descending) =
let multiplier = if descending then -1 else 1
do
if itemPosition <= 0 || itemPosition > 8 then
invalidArg "itemPosition" "The component 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, Tuple<'T8>> as tX ->
let tY = y :?> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>>
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
| 8 ->
Comparer<'T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
| _ ->
Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
| _ -> 0
// Create array of octuples with population data for three U.S.
// cities, 1940-2000.
let cities =
[| Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) |]
// 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, int> 2)
// Display array in sorted order.
printfn "Sorted by population in 1950:"
for city in cities do
printfn $"{city}"
printfn ""
Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int>(8))
// Display array in sorted order.
printfn "Sorted by population in 2000:"
for city in cities do
printfn $"{city}"
// The example displays the following output:
// In unsorted order:
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//
// Sorted by population in 1950:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 2000:
// (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
Imports System.Collections
Imports System.Collections.Generic
Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6, T7, T8) : 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 > 8 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, Tuple(Of T8)) = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
If tX Is Nothing Then
Return 0
Else
Dim tY As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
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
Case 8
Return Comparer(Of T8).Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
End Select
End If
End Function
End Class
Module Example
Public Sub Main()
' Create array of octuples with population data for three U.S.
' cities, 1940-2000.
Dim cities() = _
{ Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),
Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) }
' 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, Integer)(2))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 1950:")
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, Integer)(8))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 2000:")
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, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
' (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
'
' Sorted by population in 1950:
' (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
' (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'
' Sorted by population in 2000:
' (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
' (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
Remarques
Ce membre est une implémentation d'interface explicite. Il peut uniquement être utilisé lorsque l'instance de Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> est castée en interface IStructuralComparable.
Cette méthode vous permet de définir des comparaisons personnalisées d’objets Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> . Par exemple, vous pouvez utiliser cette méthode pour classer Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> les objets en fonction de la valeur d’un composant spécifique.
Bien que cette méthode puisse être appelée directement, elle est généralement appelée par des méthodes de tri de collection qui incluent des IComparer paramètres pour classer les membres d’une collection. Par exemple, elle est appelée par la Array.Sort(Array, IComparer) méthode et la Add méthode d’un SortedList objet instancié à l’aide du SortedList.SortedList(IComparer) constructeur .
Attention
La IStructuralComparable.CompareTo méthode est destinée à être utilisée dans les opérations de tri. Il ne doit pas être utilisé lorsque l’objectif principal d’une comparaison est de déterminer si deux objets sont égaux. Pour déterminer si deux objets sont égaux, appelez la IStructuralEquatable.Equals méthode .
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour