Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

Tuple.cs

Belirtilen bir karşılaştırıcı kullanarak geçerli Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> nesneyi belirtilen bir nesneyle karşılaştırır ve geçerli nesnenin sıralama düzeninde belirtilen nesneden önce mi, sonra mı yoksa belirtilen nesneyle aynı konumda mı olduğunu belirten bir tamsayı döndürür.

 virtual int System.Collections.IStructuralComparable.CompareTo(System::Object ^ other, System::Collections::IComparer ^ comparer) = System::Collections::IStructuralComparable::CompareTo;

int IStructuralComparable.CompareTo (object other, System.Collections.IComparer comparer);

abstract member System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int
override this.System.Collections.IStructuralComparable.CompareTo : obj * System.Collections.IComparer -> int

Function CompareTo (other As Object, comparer As IComparer) As Integer Implements IStructuralComparable.CompareTo

Parametreler

other

Object

Geçerli örnek ile karşılaştırılacak nesne.

comparer

IComparer

Karşılaştırma için özel kurallar sağlayan nesne.

Döndürülenler

Int32

Aşağıdaki tabloda gösterildiği gibi, bu örneğin göreli konumunu ve other sıralama düzeninde gösteren işaretli bir tamsayı.

Değer	Açıklama
Negatif bir tamsayı	Bu örnek öncesindedir other.
Sıfır	Bu örnek ve other sıralama düzeninde aynı konuma sahiptir.
Pozitif bir tamsayı	Bu örnek aşağıdaki gibidir other.

Uygulamalar

CompareTo(Object, IComparer)

Özel durumlar

ArgumentException

other nesne Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> değildir.

Örnekler

Aşağıdaki örnek, 1940 ile 2000 arasında dört ABD şehrinin nüfus verilerini içeren bir nesne dizisi Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> oluşturur. Sekizlinin ilk bileşeni şehir adıdır. Kalan altı bileşen, 1940 ile 2000 arasındaki 10 yıllık aralıklarla popülasyonu temsil eder.

PopulationComparer sınıfı, sekizli 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 düzende mi yoksa azalan düzende mi sıralanacağını belirten bir Boolean değer.

Örnek daha sonra dizideki öğeleri sıralanmamış düzende görüntüler, bunları üçüncü bileşene (1950'deki popülasyon) göre sıralar, görüntüler ve sonra sekizinci bileşene (2000'deki popülasyon) göre sıralar ve görüntüler.

using System;
using System.Collections;
using System.Collections.Generic;

public class PopulationComparer<T1, T2, T3, T4, T5, T6, T7, T8> : 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 > 8)
         throw new ArgumentException("The component argument is out of range.");

      itemPosition = component;
   }

   public int Compare(object x, object y)
   {
      Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> tX = x as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
      if (tX == null)
         return 0;

      Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> tY = y as Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>;
      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;
         case 7:
            return Comparer<T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier;
         case 8:
            return Comparer<T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier;
         default:
            return Comparer<T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier;
      }
   }
}

public class Example
{
   public static void Main()
   {
      // Create array of octuples with population data for three U.S. 
      // cities, 1940-2000.
      Tuple<string, int, int, int, int, int, int, Tuple<int>>[] cities  = 
          { Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
            Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),  
            Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),  
            Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) };
      // 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, int, int>(2)); 
                           
      // Display array in sorted order.
      Console.WriteLine("Sorted by population in 1950:");
      foreach (var city in cities)
         Console.WriteLine(city.ToString());
      Console.WriteLine();
      
      Array.Sort(cities, new PopulationComparer<string, int, int, int, int, int, int, int>(8));
                           
      // 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, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    
//    Sorted by population in 1950:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 2000:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)

open System
open System.Collections
open System.Collections.Generic

type PopulationComparer<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8>(itemPosition, descending) =
    let multiplier = if descending then -1 else 1

    do 
        if itemPosition <= 0 || itemPosition > 8 then
            invalidArg "itemPosition" "The component argument is out of range."
    new(itemPosition) = PopulationComparer (itemPosition, true)

    interface IComparer with
        member _.Compare(x, y) =
            match x with
            | :? Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>> as tX ->
                let tY = y :?> Tuple<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, Tuple<'T8>>
                match itemPosition with
                | 1 ->
                    Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
                | 2 ->
                    Comparer<'T2>.Default.Compare(tX.Item2, tY.Item2) * multiplier
                | 3 ->
                    Comparer<'T3>.Default.Compare(tX.Item3, tY.Item3) * multiplier
                | 4 ->
                    Comparer<'T4>.Default.Compare(tX.Item4, tY.Item4) * multiplier
                | 5 ->
                    Comparer<'T5>.Default.Compare(tX.Item5, tY.Item5) * multiplier
                | 6 ->
                    Comparer<'T6>.Default.Compare(tX.Item6, tY.Item6) * multiplier
                | 7 ->
                    Comparer<'T7>.Default.Compare(tX.Item7, tY.Item7) * multiplier
                | 8 ->
                    Comparer<'T8>.Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
                | _ ->
                    Comparer<'T1>.Default.Compare(tX.Item1, tY.Item1) * multiplier
            | _ -> 0

// Create array of octuples with population data for three U.S. 
// cities, 1940-2000.
let cities  = 
    [| Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
       Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)  
       Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)  
       Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) |]
// Display array in unsorted order.
printfn "In unsorted order:"
for city in cities do
    printfn $"{city}"
printfn ""

Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int> 2)

// Display array in sorted order.
printfn "Sorted by population in 1950:"
for city in cities do
    printfn $"{city}"
printfn ""

Array.Sort(cities, PopulationComparer<string, int, int, int, int, int, int, int>(8))
                    
// Display array in sorted order.
printfn "Sorted by population in 2000:"
for city in cities do
    printfn $"{city}"
// The example displays the following output:
//    In unsorted order:
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    
//    Sorted by population in 1950:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    
//    Sorted by population in 2000:
//    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
//    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
//    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
//    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)

Imports System.Collections
Imports System.Collections.Generic

Public Class PopulationComparer(Of T1, T2, T3, T4, T5, T6, T7, T8) : 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 > 8 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 As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = TryCast(x, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
      If tX Is Nothing Then
         Return 0
      Else
         Dim tY As Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)) = DirectCast(y, Tuple(Of T1, T2, T3, T4, T5, T6, T7, Tuple(Of T8)))
         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
            Case 7
               Return Comparer(Of T7).Default.Compare(tX.Item7, tY.Item7) * multiplier
            Case 8
               Return Comparer(Of T8).Default.Compare(tX.Rest.Item1, tY.Rest.Item1) * multiplier
         End Select      
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      ' Create array of octuples with population data for three U.S. 
      ' cities, 1940-2000.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820),
            Tuple.Create("New York", 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278),  
            Tuple.Create("Chicago", 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016),  
            Tuple.Create("Detroit", 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270) }
      ' 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, Integer, Integer)(2)) 
                           
      ' Display array in sorted order.
      Console.WriteLine("Sorted by population in 1950:")
      For Each city In cities
         Console.WriteLine(city.ToString())
      Next
      Console.WriteLine()
      
      Array.Sort(cities, New PopulationComparer(Of String, Integer, Integer, Integer, Integer, Integer, Integer, Integer)(8))
                           
      ' 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, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
'    
'    Sorted by population in 1950:
'    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)
'    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    
'    Sorted by population in 2000:
'    (New York, 7454995, 7891957, 7781984, 7894862, 7071639, 7322564, 8008278)
'    (Los Angeles, 1504277, 1970358, 2479015, 2816061, 2966850, 3485398, 3694820)
'    (Chicago, 3396808, 3620962, 3550904, 3366957, 3005072, 2783726, 2896016)
'    (Detroit, 1623452, 1849568, 1670144, 1511462, 1203339, 1027974, 951270)

Açıklamalar

Bu üye açık arabirim geliştirmesidir. Yalnızca örnek bir IStructuralComparable arabirime Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> yayınlandığında kullanılabilir.

Bu yöntem, nesnelerin özelleştirilmiş karşılaştırmalarını Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> tanımlamanızı sağlar. Örneğin, nesneleri belirli bir bileşenin değerine göre sıralamak Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> için bu yöntemi kullanabilirsiniz.

Bu yöntem doğrudan çağrılsa da, en yaygın olarak bir koleksiyonun üyelerini sıralamaya yönelik parametreleri içeren IComparer koleksiyon sıralama yöntemleri tarafından çağrılır. Örneğin, oluşturucu kullanılarak SortedList.SortedList(IComparer) örneği alınan bir SortedList nesnenin yöntemi ve Add yöntemi tarafından Array.Sort(Array, IComparer) çağrılır.

Dikkat

IStructuralComparable.CompareTo yöntemi, sıralama işlemlerinde kullanılmak üzere tasarlanmıştır. Karşılaştırmanın asıl amacı iki nesnenin eşit olup olmadığını belirlemek olduğunda kullanılmamalıdır. İki nesnenin eşit olup olmadığını belirlemek için yöntemini çağırın IStructuralEquatable.Equals .