Tuple<T1>.IComparable.CompareTo(Object) Tuple<T1>.IComparable.CompareTo(Object) Tuple<T1>.IComparable.CompareTo(Object) Method

定义

将当前 Tuple<T1> 对象与指定对象进行比较,并返回一个整数,该整数指示当前对象在排序顺序中的位置是位于指定对象之前、之后还是与其位置相同。Compares the current Tuple<T1> object to a specified object, and returns an integer that indicates whether the current object is before, after, or in the same position as the specified object in the sort order.

 virtual int System.IComparable.CompareTo(System::Object ^ obj) = IComparable::CompareTo;
int IComparable.CompareTo (object obj);
Function CompareTo (obj As Object) As Integer Implements IComparable.CompareTo

参数

obj
Object Object Object

要与当前实例进行比较的对象。An object to compare with the current instance.

返回

一个带符号整数,指示此实例和 obj 在排序顺序中的相对位置,如下表所示。A signed integer that indicates the relative position of this instance and obj in the sort order, as shown in the following table.

Value 说明Description
负整数A negative integer 此实例位于 obj 之前。This instance precedes obj.
Zero 此实例在排序顺序中的位置与 obj 相同。This instance and obj have the same position in the sort order.
正整数A positive integer 此实例位于 obj 之后。This instance follows obj.

实现

异常

obj 不是 Tuple<T1> 对象。obj is not a Tuple<T1> object.

示例

下面的示例创建一个单一实例数组, 其组件为Double值。The following example creates an array of singletons whose component is a Double value. 它以未排序的顺序显示每个元组组件的值, 对数组进行排序, 然后按排序顺序显示这些值。It displays the value of each tuple component in unsorted order, sorts the array, and then displays the values in sorted order. 请注意, 该示例不会直接调用Tuple<T1>.IComparable.CompareTo方法。Note that the example does not directly call the Tuple<T1>.IComparable.CompareTo method. 此方法由Sort(Array)方法为数组中的每个元素隐式调用。This method is called implicitly by the Sort(Array) method for each element in the array.

using System;

class Example
{
   static void Main()
   {
      Tuple<Double>[] values = { Tuple.Create(13.54),
                                 Tuple.Create(Double.NaN),
                                 Tuple.Create(-189.42993),
                                 Tuple.Create(Double.PositiveInfinity),
                                 Tuple.Create(Double.Epsilon),
                                 Tuple.Create(1.934E-17),
                                 Tuple.Create(Double.NegativeInfinity),
                                 Tuple.Create(-0.000000000003588),
                                 null };
      Console.WriteLine("The values in unsorted order:");
      foreach (var value in values)
         if (value != null)
            Console.WriteLine("   {0}", value.Item1);
         else
            Console.WriteLine("   <null>");
      Console.WriteLine();

      Array.Sort(values);

      Console.WriteLine("The values in sorted order:");
      foreach (var value in values)
         if (value != null)
            Console.WriteLine("   {0}", value.Item1);
         else
            Console.WriteLine("   <null>");
   }
}
// The example displays the following output:
//      The values in unsorted order:
//         13.54
//         NaN
//         -189.42993
//         Infinity
//         4.94065645841247E-324
//         1.934E-17
//         -Infinity
//         -3.588E-12
//
//      The values in sorted order:
//         NaN
//         -Infinity
//         -189.42993
//         -3.588E-12
//         4.94065645841247E-324
//         1.934E-17
//         13.54
//         Infinity
Module Example
    Sub Main()
        Dim values() = { Tuple.Create(13.54),
                         Tuple.Create(Double.NaN),
                         Tuple.Create(-189.42993),
                         Tuple.Create(Double.PositiveInfinity),
                         Tuple.Create(Double.Epsilon),
                         Tuple.Create(1.934E-17),
                         Tuple.Create(Double.NegativeInfinity),
                         Tuple.Create(-0.000000000003588),
                         Nothing}

        Console.WriteLine("The values in unsorted order:")
        For Each value In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
        Console.WriteLine()

        Array.Sort(values)

        Console.WriteLine("The values in sorted order:")
        For Each value In values
            If value IsNot Nothing Then
                Console.WriteLine("   {0}", value.Item1)
            Else
                Console.WriteLine("   <null>")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'      The values in unsorted order:
'         13.54
'         NaN
'         -189.42993
'         Infinity
'         4.94065645841247E-324
'         1.934E-17
'         -Infinity
'         -3.588E-12
'
'      The values in sorted order:
'         NaN
'         -Infinity
'         -189.42993
'         -3.588E-12
'         4.94065645841247E-324
'         1.934E-17
'         13.54
'         Infinity

注解

此成员是显式接口成员的实现。This member is an explicit interface member implementation. 它只能在 Tuple<T1> 实例被强制转换为 IComparable 接口时使用。It can be used only when the Tuple<T1> instance is cast to an IComparable interface.

此方法提供IComparable.CompareTo Tuple<T1>类的实现。This method provides the IComparable.CompareTo implementation for the Tuple<T1> class. 尽管可以直接调用方法, 但它通常由集合排序方法 (如Array.Sort(Array)SortedList.Add) 的默认重载调用, 以对集合的成员进行排序。Although the method can be called directly, it is most commonly called by the default overloads of collection sorting methods, such as Array.Sort(Array) and SortedList.Add, to order the members of a collection.

注意

Tuple<T1>.IComparable.CompareTo方法旨在用于排序操作。The Tuple<T1>.IComparable.CompareTo method is intended for use in sorting operations. 如果比较的主要目的是确定两个对象是否相等, 则不应使用此方法。It should not be used when the primary purpose of a comparison is to determine whether two objects are equal. 若要确定两个对象是否相等, 请Equals调用方法。To determine whether two objects are equal, call the Equals method.

Tuple<T1>.IComparable.CompareTo方法使用默认的对象比较器。The Tuple<T1>.IComparable.CompareTo method uses the default object comparer.

适用于

另请参阅