다음을 통해 공유


Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo 메서드

정의

지정된 비교자를 사용하여 현재 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 개체와 지정된 개체를 비교하고 정렬 순서에서 현재 개체의 위치가 지정된 개체보다 앞인지, 뒤인지 또는 동일한지를 나타내는 정수를 반환합니다.

 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

매개 변수

other
Object

현재 인스턴스와 비교할 개체입니다.

comparer
IComparer

비교를 위한 사용자 지정 규칙을 제공하는 개체입니다.

반환

Int32

다음 표와 같이 정렬 순서에서 이 인스턴스와 other의 상대적 위치를 나타내는 부호 있는 정수입니다.

설명
음의 정수 이 인스턴스가 other 앞에 오는 경우
0 이 인스턴스와 other의 위치가 정렬 순서에서 같은 경우
양의 정수 이 인스턴스가 other 다음에 오는 경우

구현

예외

otherTuple<T1,T2,T3,T4,T5,T6,T7,TRest> 개체가 아닙니다.

예제

다음 예제에서는 1940년부터 2000년까지 미국 4개 도시에 대한 인구 데이터를 포함하는 개체 배열 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 을 만듭니다. 8진수의 첫 번째 구성 요소는 도시 이름입니다. 나머지 6개 구성 요소는 1940년부터 2000년까지 10년 간격으로 모집단을 나타냅니다.

클래스는 PopulationComparer 8진수 배열을 해당 구성 요소 중 하나로 정렬할 수 있는 구현을 제공합니다 IComparer . 생성자의 클래스에는 정렬 순서를 PopulationComparer 정의하는 구성 요소의 위치와 튜플 개체를 오름차순 또는 내림차순으로 Boolean 정렬해야 하는지 여부를 나타내는 값의 두 값이 제공됩니다.

그런 다음 배열의 요소를 정렬되지 않은 순서로 표시하고, 세 번째 구성 요소(1950년 모집단)를 기준으로 정렬한 다음, 8번째 구성 요소(2000년 모집단)로 정렬하여 표시합니다.

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)

설명

이 멤버는 명시적 인터페이스 구현이며, Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 인스턴스가 IStructuralComparable 인터페이스로 캐스팅된 경우에만 사용할 수 있습니다.

이 메서드를 사용하면 개체의 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 사용자 지정된 비교를 정의할 수 있습니다. 예를 들어 이 메서드를 사용하여 특정 구성 요소의 값에 따라 개체를 정렬 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 할 수 있습니다.

이 메서드는 직접 호출할 수 있지만 컬렉션의 멤버를 정렬하는 매개 변수를 포함하는 IComparer 컬렉션 정렬 메서드에서 가장 일반적으로 호출됩니다. 예를 들어 생성자를 사용하여 SortedList.SortedList(IComparer) 인스턴스화되는 개체의 SortedList 메서드 및 Add 메서드에 의해 호출 Array.Sort(Array, IComparer) 됩니다.

주의

IStructuralComparable.CompareTo 메서드는 정렬 작업에 사용하기 위한 것입니다. 비교의 주요 목적이 두 개체가 같은지 여부를 확인하는 경우에는 사용하지 않아야 합니다. 두 개체가 같은지 여부를 확인하려면 메서드를 호출합니다 IStructuralEquatable.Equals .

적용 대상