IStructuralComparable Rozhraní

  • Reference

Definice

Obor názvů:
System.Collections
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Podporuje strukturální porovnávání objektů kolekce.

public interface class IStructuralComparable
public interface IStructuralComparable
type IStructuralComparable = interface
Public Interface IStructuralComparable
Odvozené

Příklady

Následující příklad vytvoří pole Tuple<T1,T2,T3,T4,T5,T6> objektů, které obsahují data o počtu obyvatel pro tři města USA od roku 1960 do roku 2000. První součástí sextuple je název města. Zbývajících pět složek představuje populaci v desetiletých intervalech od roku 1960 do roku 2000.

Třída PopulationComparer poskytuje IComparer implementaci, která umožňuje řadit pole sextuples podle některé z jejích komponent. Ve svém konstruktoru PopulationComparer jsou třídě poskytnuty dvě hodnoty: pozice komponenty, která definuje pořadí řazení, a logická hodnota, která označuje, zda mají být objekty řazené kolekce členů seřazeny vzestupně nebo sestupně.

Příklad pak zobrazí prvky v poli v neseřazené pořadí, seřadí je podle třetí komponenty (základní soubor v roce 1970), zobrazí je a pak je seřadí podle šesté komponenty (populace v roce 2000) a zobrazí je. Všimněte si, že příklad nevolá přímo metodu CompareTo . Metoda je volána implicitně metodou Sort(Array, IComparer) pro každý objekt řazené kolekce členů v poli.

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)

Poznámky

Rozhraní IStructuralComparable umožňuje implementovat přizpůsobená porovnání pro členy kolekce. To znamená, že můžete přesně definovat, co znamená, že jeden objekt kolekce má předcházet, sledovat nebo se nacházet ve stejné pozici v pořadí řazení jako druhý objekt kolekce. Pak můžete zadat, aby se tato definice používala s typem kolekce, který přijímá IStructuralComparable rozhraní.

Rozhraní má jeden člen , který určuje, CompareTozda je aktuální objekt kolekce menší než, roven nebo větší než druhý objekt v pořadí řazení. Skutečné porovnání členů nebo prvků v aktuální instanci s prvky v druhém objektu je provedeno implementací IComparer rozhraní, která obsahuje definici vlastního porovnání.

Poznámka

Rozhraní IStructuralComparable podporuje pouze strukturální porovnání pro řazení nebo řazení. Rozhraní IStructuralEquatable podporuje vlastní porovnání pro strukturální rovnost.

Rozhraní .NET Framework poskytuje dva výchozí porovnávače. Jedna je vrácena StructuralComparisons.StructuralComparer vlastností, druhá je vrácena Comparer<T>.Default vlastností.

Obecné třídy řazené kolekce členů (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>atd.) a Array třída poskytují explicitní implementace IStructuralComparable rozhraní. Přetypováním (v jazyce C#) nebo převodem (v jazyce Visual Basic) aktuální instance pole nebo řazené kolekce členů na IStructuralComparable hodnotu rozhraní a poskytnutím IComparer implementace jako argumentu pro metodu CompareTo můžete definovat vlastní pořadí řazení pro pole nebo kolekci. Ve většině případů však nevoláte metodu CompareTo přímo. Místo toho se CompareTo metoda volá pomocí metod řazení, jako Sort(Array, IComparer)je . V tomto případě definujete implementaci IComparer a předáte ji jako argument metodě řazení nebo konstruktoru třídy objektu kolekce. Metoda CompareTo s vaším vlastním porovnávačem se pak volá automaticky při každém seřazení kolekce.

Metody

CompareTo(Object, IComparer)

Určuje, zda aktuální objekt kolekce předchází, probíhá ve stejné pozici jako, nebo za jiným objektem v pořadí řazení.

Platí pro

Viz také