Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: Tuple.cs

Source:: Tuple.cs

Source:: Tuple.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

使用指定的比较器将当前的 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` 之前。
零	此实例在排序顺序中的位置与 `other` 相同。
正整数	此实例位于 `other` 之后。

实现

CompareTo(Object, IComparer)

例外

ArgumentException

other 不是 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> 对象。

示例

以下示例创建对象数组 Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> ，其中包含 1940 到 2000 年四个美国城市的人口数据。八进制的第一个组件是城市名称。其余6个组成部分代表从1940年到2000年每隔10年的人口。

类 PopulationComparer 提供了一个 IComparer 实现，该实现允许按其任何一个组件对八进制数数组进行排序。在其构造函数中向 PopulationComparer 类提供两个值：定义排序顺序的组件的位置，以及一个 Boolean 值，该值指示元组对象应按升序还是降序排序。

然后，该示例按未排序顺序显示数组中的元素，按 1950 年) 总体 (第三个分量进行排序并显示它们，然后按 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 参数的集合排序方法调用，以便对集合的成员进行排序。例如，它由 Array.Sort(Array, IComparer) 使用 SortedList.SortedList(IComparer) 构造函数实例化的对象的方法和 Add 方法SortedList调用。

注意

方法 IStructuralComparable.CompareTo 适用于排序操作。当比较的主要目的是确定两个对象是否相等时，不应使用它。若要确定两个对象是否相等，请调用 IStructuralEquatable.Equals 方法。

适用于

Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>.IStructuralComparable.CompareTo 方法

定义

参数

返回

实现

例外

示例

注解

适用于

反馈

其他资源