IStructuralComparable Interface

Définition

public interface class IStructuralComparable

public interface IStructuralComparable

type IStructuralComparable = interface

Public Interface IStructuralComparable

Dérivé

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

Plus…

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.

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

S’applique à

Voir aussi

• IComparable
• IStructuralEquatable
• StructuralComparer