Udostępnij za pośrednictwem

IStructuralComparable Interfejs

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Collections
Zestaw:
System.Runtime.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Obsługuje porównanie strukturalne obiektów kolekcji.

public interface class IStructuralComparable
public interface IStructuralComparable
type IStructuralComparable = interface
Public Interface IStructuralComparable
Pochodne

Przykłady

Poniższy przykład tworzy tablicę Tuple<T1,T2,T3,T4,T5,T6> obiektów, która zawiera dane populacji dla trzech miast w Stanach Zjednoczonych od 1960 do 2000 roku. Pierwszy składnik sextuple jest nazwą miasta. Pozostałe pięć składników reprezentuje populację w dziesięcioletnich odstępach czasu od 1960 do 2000 roku.

Klasa PopulationComparer udostępnia implementację IComparer , która umożliwia sortowanie tablicy sekstuple według dowolnego z jego składników. Dwie wartości są dostarczane do PopulationComparer klasy w konstruktorze: pozycja składnika, który definiuje kolejność sortowania, oraz wartość logiczną wskazującą, czy obiekty krotki powinny być sortowane w kolejności rosnącej, czy malejącej.

W przykładzie zostaną wyświetlone elementy w tablicy w kolejności niesortowanej, posortowane według trzeciego składnika (populacji w 1970 r.) i ich wyświetlenie, a następnie posortowanie ich według szóstego składnika (populacja w 2000 r.) i wyświetla je. Zwróć uwagę, że przykład nie wywołuje CompareTo bezpośrednio metody . Metoda jest wywoływana niejawnie przez metodę Sort(Array, IComparer) dla każdego obiektu krotki w tablicy.

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)

Uwagi

Interfejs IStructuralComparable umożliwia implementowanie niestandardowych porównań dla elementów członkowskich kolekcji. Oznacza to, że można dokładnie zdefiniować, co oznacza, że jeden obiekt kolekcji ma poprzedzać, śledzić lub występować w tej samej kolejności sortowania co drugi obiekt kolekcji. Następnie można określić, że ta definicja ma być używana z typem kolekcji, który akceptuje IStructuralComparable interfejs.

Interfejs ma jeden element członkowski , który określa, CompareToczy bieżący obiekt kolekcji jest mniejszy niż, równy lub większy niż drugi obiekt w kolejności sortowania. Rzeczywiste porównanie elementów członkowskich lub elementów w bieżącym wystąpieniu z tymi w drugim obiekcie jest wykonywane przez implementację IComparer interfejsu, która zawiera definicję porównania niestandardowego.

Uwaga

Interfejs IStructuralComparable obsługuje tylko porównania strukturalne do sortowania lub porządkowania. Interfejs IStructuralEquatable obsługuje porównania niestandardowe pod kątem równości strukturalnej.

Program .NET Framework udostępnia dwa domyślne porównania. Jedna jest zwracana przez StructuralComparisons.StructuralComparer właściwość ; druga jest zwracana przez Comparer<T>.Default właściwość .

Ogólne klasy krotki (, , i tak dalej) i Array klasy zapewniają jawne implementacje interfejsuIStructuralComparable. Tuple<T1,T2,T3>Tuple<T1,T2>Tuple<T1> Rzutowanie (w języku C#) lub konwertowanie (w języku Visual Basic) bieżącego wystąpienia tablicy lub krotki na IStructuralComparable wartość interfejsu i podanie IComparer implementacji jako argumentu CompareTo metody można zdefiniować niestandardową kolejność sortowania dla tablicy lub kolekcji. Jednak metoda nie jest wywoływana CompareTo bezpośrednio w większości przypadków. Zamiast tego metoda jest wywoływana CompareTo przez metody sortowania, takie jak Sort(Array, IComparer). W tym przypadku należy zdefiniować implementację IComparer i przekazać ją jako argument do konstruktora klasy obiektu sortowania lub obiektu kolekcji. Metoda CompareTo z niestandardowym modułem porównującym jest następnie wywoływana automatycznie za każdym razem, gdy kolekcja zostanie posortowana.

Metody

CompareTo(Object, IComparer)

Określa, czy bieżący obiekt kolekcji poprzedza, występuje w tej samej pozycji co, czy następuje inny obiekt w kolejności sortowania.

Dotyczy

Zobacz też