IStructuralComparable Schnittstelle

Definition

public interface class IStructuralComparable

public interface IStructuralComparable

type IStructuralComparable = interface

Public Interface IStructuralComparable

Abgeleitet

System.Array

System.Collections.Immutable.ImmutableArray<T>

System.Tuple<T1>

System.Tuple<T1,T2>

System.Tuple<T1,T2,T3>

Mehr …

Beispiele

Im folgenden Beispiel wird ein Array von Tuple<T1,T2,T3,T4,T5,T6> -Objekten erstellt, das Bevölkerungsdaten für drei US-Städte von 1960 bis 2000 enthält. Die erste Komponente des Sextupels ist der Name der Stadt. Die restlichen fünf Komponenten stellen die Bevölkerungszahl in Zehnjahresintervallen von 1960 bis 2000 dar.

Die PopulationComparer -Klasse stellt eine IComparer -Implementierung bereit, mit der das Array von Sextupeln nach einer beliebigen ihrer Komponenten sortiert werden kann. Der Klasse in ihrem PopulationComparer Konstruktor werden zwei Werte bereitgestellt: die Position der Komponente, die die Sortierreihenfolge definiert, und ein boolescher Wert, der angibt, ob die Tupelobjekte in aufsteigender oder absteigender Reihenfolge sortiert werden sollen.

Das Beispiel zeigt dann die Elemente im Array in unsortierten Reihenfolge an, sortiert sie nach der dritten Komponente (die Auffüllung im Jahr 1970), zeigt sie an, sortiert sie dann nach der sechsten Komponente (die Auffüllung im Jahr 2000) und zeigt sie an. Beachten Sie, dass die -Methode im Beispiel nicht direkt aufgerufen CompareTo wird. Die -Methode wird implizit von der Sort(Array, IComparer) -Methode für jedes Tupelobjekt im Array aufgerufen.

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)

Hinweise

Mit IStructuralComparable der -Schnittstelle können Sie benutzerdefinierte Vergleiche für Sammlungsmember implementieren. Das heißt, Sie können genau definieren, was es bedeutet, dass ein Auflistungsobjekt an derselben Position in der Sortierreihenfolge wie ein zweites Auflistungsobjekt vorangeht, folgt oder sich befindet. Sie können dann angeben, dass diese Definition mit einem Sammlungstyp verwendet wird, der die IStructuralComparable -Schnittstelle akzeptiert.

Die Schnittstelle verfügt über einen einzelnen Member , CompareToder bestimmt, ob das aktuelle Auflistungsobjekt kleiner, gleich oder größer als ein zweites Objekt in der Sortierreihenfolge ist. Der tatsächliche Vergleich der Member oder Elemente in der aktuellen Instanz mit denen in einem zweiten Objekt wird von einer IComparer Schnittstellenimplementierung durchgeführt, die die Definition Ihres benutzerdefinierten Vergleichs enthält.

.NET Framework stellt zwei Standardvergleiche bereit. Eine wird von der StructuralComparisons.StructuralComparer -Eigenschaft zurückgegeben, die andere wird von der Comparer<T>.Default -Eigenschaft zurückgegeben.

Die generischen Tupelklassen (, , usw.) und die Array -Klasse stellen explizite Implementierungen der IStructuralComparable -Schnittstelle bereit. Tuple<T1,T2,T3>Tuple<T1,T2>Tuple<T1> Durch Umwandeln (in C#) oder Konvertieren (in Visual Basic) der aktuellen Instanz eines Arrays oder Tupels in einen IStructuralComparable Schnittstellenwert und Bereitstellen der IComparer Implementierung als Argument für die CompareTo -Methode können Sie eine benutzerdefinierte Sortierreihenfolge für das Array oder die Auflistung definieren. In den meisten Fällen rufen Sie die CompareTo -Methode jedoch nicht direkt auf. Stattdessen wird die CompareTo -Methode durch Sortiermethoden wie Sort(Array, IComparer)aufgerufen. In diesem Fall definieren Sie Ihre IComparer Implementierung und übergeben sie als Argument an den Klassenkonstruktor einer Sortiermethode oder eines Auflistungsobjekts. Die CompareTo -Methode mit Ihrem benutzerdefinierten Vergleich wird dann automatisch aufgerufen, wenn die Auflistung sortiert wird.

Methoden

Gilt für:

Weitere Informationen

• IComparable
• IStructuralEquatable
• StructuralComparer