IStructuralComparable Interface
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.
Prend en charge la comparaison structurelle d'objets de collection.
public interface class IStructuralComparablepublic interface IStructuralComparabletype IStructuralComparable = interfacePublic Interface IStructuralComparable- Dérivé
Exemples
L’exemple suivant crée un tableau d’objets qui contient des Tuple<T1,T2,T3,T4,T5,T6> données de population pour trois villes américaines de 1960 à 2000. Le premier composant du sextuple est le nom de la ville. Les cinq autres composantes représentent la population à intervalles de dix ans, de 1960 à 2000.
La PopulationComparer classe fournit une IComparer implémentation qui permet au tableau de sextuples 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 valeur booléenne 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 par le troisième composant (la population en 1970) et les affiche, puis les trie par le sixième composant (la population en 2000) et les affiche. Notez que l’exemple n’appelle pas directement la CompareTo méthode. La méthode est appelée implicitement par la Sort(Array, IComparer) méthode pour chaque objet tuple dans le tableau.
using System;
using System.Collections;
using System.Collections.Generic;
public class PopulationComparer<T1, T2, T3, T4, T5, T6> : 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 > 6)
throw new ArgumentException("The component argument is out of range.");
itemPosition = component;
}
public int Compare(object x, object y)
{
var tX = x as Tuple<T1, T2, T3, T4, T5, T6>;
if (tX == null)
{
return 0;
}
else
{
var tY = y as Tuple<T1, T2, T3, T4, T5, T6>;
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;
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>[] cities =
{ Tuple.Create("Los Angeles", 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 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>(3));
// Display array in sorted order.
Console.WriteLine("Sorted by population in 1970:");
foreach (var city in cities)
Console.WriteLine(city.ToString());
Console.WriteLine();
Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int>(6));
// 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, 2479015, 2816061, 2966850, 3485398, 3694820)
// (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
//
// Sorted by population in 1970:
// (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
// (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
//
// Sorted by population in 2000:
// (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
// (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
// (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
Imports System.Collections
Imports System.Collections.Generic
Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6) : 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 > 6 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 = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6))
If tX Is Nothing Then
Return 0
Else
Dim tY = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6))
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
' This should never happen.
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, 1960-2000.
Dim cities() =
{ Tuple.Create("Los Angeles", 2479015, 2816061, 2966850, 3485398, 3694820),
Tuple.Create("New York", 7781984, 7894862, 7071639, 7322564, 8008278),
Tuple.Create("Chicago", 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)(3))
' Display array in sorted order.
Console.WriteLine("Sorted by population in 1970:")
For Each city In cities
Console.WriteLine(city.ToString())
Next
Console.WriteLine()
Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer)(6))
' 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, 2479015, 2816061, 2966850, 3485398, 3694820)
' (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
'
' Sorted by population in 1970:
' (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
' (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
'
' Sorted by population in 2000:
' (New York, 7781984, 7894862, 7071639, 7322564, 8008278)
' (Los Angeles, 2479015, 2816061, 2966850, 3485398, 3694820)
' (Chicago, 3550904, 3366957, 3005072, 2783726, 2896016)
Remarques
L’interface IStructuralComparable vous permet d’implémenter des comparaisons personnalisées pour les membres de la collection. Autrement dit, vous pouvez définir précisément ce que signifie qu’un objet de collection précède, suit ou se produit dans la même position dans l’ordre de tri qu’un deuxième objet de collection. Vous pouvez ensuite spécifier que cette définition soit utilisée avec un type de collection qui accepte l’interface IStructuralComparable .
L’interface a un seul membre, CompareTo, qui détermine si l’objet de collection actuel est inférieur, égal à ou supérieur à un deuxième objet dans l’ordre de tri. La comparaison réelle des membres ou éléments de l’instance actuelle avec ceux d’un deuxième objet est effectuée par une implémentation d’interface IComparer , qui contient la définition de votre comparaison personnalisée.
Notes
L’interface IStructuralComparable prend uniquement en charge les comparaisons structurelles pour le tri ou l’ordre. L’interface IStructuralEquatable prend en charge les comparaisons personnalisées pour l’égalité structurelle.
Le .NET Framework fournit deux comparateurs par défaut. L’un est retourné par la StructuralComparisons.StructuralComparer propriété ; l’autre est retourné par la Comparer<T>.Default propriété .
Les classes tuple génériques (Tuple<T1>, , Tuple<T1,T2,T3>Tuple<T1,T2>, etc.) et la Array classe fournissent des implémentations explicites de l’interfaceIStructuralComparable. En convertissant (en C#) ou en convertissant (en Visual Basic) l’instance actuelle d’un tableau ou d’un tuple en valeur d’interface IStructuralComparable et en fournissant votre IComparer implémentation comme argument à la CompareTo méthode, vous pouvez définir un ordre de tri personnalisé pour le tableau ou la collection. Toutefois, vous n’appelez pas la méthode directement dans la CompareTo plupart des cas. Au lieu de cela, la CompareTo méthode est appelée en triant des méthodes telles que Sort(Array, IComparer). Dans ce cas, vous définissez votre IComparer implémentation et passez-la en tant qu’argument au constructeur de classe d’une méthode de tri ou d’un objet de collection. La CompareTo méthode avec votre comparateur personnalisé est ensuite appelée automatiquement chaque fois que la collection est triée.
Méthodes
| CompareTo(Object, IComparer) |
Détermine si l'objet collection actuel précède, se situe à la même position que, ou suit un autre objet dans l'ordre de tri. |
