IStructuralComparable Arabirim

Tanım

Koleksiyon nesnelerinin yapısal karşılaştırmasını destekler.

public interface class IStructuralComparable
public interface IStructuralComparable
type IStructuralComparable = interface
Public Interface IStructuralComparable
Türetilmiş

Örnekler

Aşağıdaki örnek, 1960'tan Tuple<T1,T2,T3,T4,T5,T6> 2000'e kadar üç ABD şehrinin nüfus verilerini içeren bir nesne dizisi oluşturur. Sextuple'ın ilk bileşeni şehir adıdır. Kalan beş bileşen, 1960 ile 2000 arasında on yıllık aralıklarla popülasyonu temsil eder.

sınıfı, PopulationComparer sextuples dizisinin bileşenlerinden herhangi birine göre sıralanmasına olanak tanıyan bir IComparer uygulama sağlar. Oluşturucusunda sınıfına PopulationComparer iki değer sağlanır: sıralama düzenini tanımlayan bileşenin konumu ve tanımlama grubu nesnelerinin artan veya azalan düzende sıralanıp sıralanmayacağını belirten bir Boole değeri.

Örnek daha sonra dizideki öğeleri sıralanmamış düzende görüntüler, bunları üçüncü bileşene göre sıralar (1970'teki popülasyon) ve görüntüler, sonra bunları altıncı bileşene (2000'deki popülasyon) göre sıralar ve görüntüler. Örneğin yöntemini doğrudan çağırmadığını CompareTo unutmayın. yöntemi, dizideki Sort(Array, IComparer) her tanımlama grubu nesnesi için yöntemi tarafından örtük olarak çağrılır.

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)

Açıklamalar

Arabirim, IStructuralComparable koleksiyon üyeleri için özelleştirilmiş karşılaştırmalar uygulamanıza olanak tanır. Başka bir deyişle, bir koleksiyon nesnesinin sıralama düzeninde ikinci bir koleksiyon nesnesiyle aynı konumda olmasını, izlemesini veya gerçekleşmesinin ne anlama geldiğini tam olarak tanımlayabilirsiniz. Ardından bu tanımın arabirimi kabul IStructuralComparable eden bir koleksiyon türüyle kullanılacağını belirtebilirsiniz.

Arabirimin, CompareTogeçerli koleksiyon nesnesinin sıralama düzeninde ikinci bir nesneden küçük, ona eşit veya ondan büyük olup olmadığını belirleyen tek bir üyesi vardır. Geçerli örnekteki üyelerin veya öğelerin ikinci bir nesnedekilerle gerçek karşılaştırması, özel karşılaştırmanızın tanımını içeren bir IComparer arabirim uygulaması tarafından gerçekleştirilir.

Not

Arabirim IStructuralComparable , sıralama veya sıralama için yalnızca yapısal karşılaştırmaları destekler. Arabirim, IStructuralEquatable yapısal eşitlik için özel karşılaştırmaları destekler.

.NET Framework iki varsayılan karşılaştırıcı sağlar. Biri özelliği tarafından StructuralComparisons.StructuralComparer döndürülür; diğeri özelliği tarafından Comparer<T>.Default döndürülür.

Genel tanımlama grubu sınıfları (Tuple<T1>, Tuple<T1,T2>, Tuple<T1,T2,T3>vb.) ve Array sınıfı arabirimin IStructuralComparable açık uygulamalarını sağlar. Dizi veya demetin IStructuralComparable geçerli örneğini bir arabirim değerine dönüştürerek (C#'de) veya dönüştürerek (Visual Basic'te) ve uygulamanızı yöntemin CompareTo bağımsız değişkeni olarak sağlayarakIComparer, dizi veya koleksiyon için özel bir sıralama düzeni tanımlayabilirsiniz. Ancak çoğu durumda yöntemini doğrudan çağırmazsınız CompareTo . Bunun yerine, CompareTo yöntemi gibi Sort(Array, IComparer)sıralama yöntemleri tarafından çağrılır. Bu durumda, uygulamanızı IComparer tanımlar ve bir sıralama yöntemine veya koleksiyon nesnesinin sınıf oluşturucusunda bağımsız değişken olarak geçirirsiniz. Özel CompareTo karşılaştırıcınızla yöntemi daha sonra koleksiyon her sıralandığında otomatik olarak çağrılır.

Yöntemler

CompareTo(Object, IComparer)

Geçerli koleksiyon nesnesinin önce olup olmadığını, sıralama düzenindeki başka bir nesneyle aynı konumda mı yoksa takip mi olduğunu belirler.

Şunlara uygulanır

Ayrıca bkz.