IComparable.CompareTo(Object) 方法

定義

命名空間:

System

組件:

System.Runtime.dll

比較目前實例與相同型別的另一個物件，並傳回整數，指出目前的實例是否在排序順序中與其他對象位於相同位置。

public:
 int CompareTo(System::Object ^ obj);

public int CompareTo (object? obj);

abstract member CompareTo : obj -> int

Public Function CompareTo (obj As Object) As Integer

參數

obj

Object

要與這個實例比較的物件。

傳回

Int32

值，表示要比較之對象的相對順序。 傳回值具有下列意義：

價值	意義
小於零	這個實例在排序順序中 obj 之前。
零	這個實例的排序順序與 obj相同。
大於零	這個實例會遵循排序順序 obj。

例外狀況

ArgumentException

obj 與這個實例的類型不同。

範例

下列範例說明如何使用 CompareTo，比較實作 IComparable 與另一個 物件的 Temperature 物件。 Temperature 物件只要包裝對 Int32.CompareTo 方法的呼叫，即可實作 CompareTo。

using namespace System;
using namespace System::Collections;

public ref class Temperature: public IComparable {
   /// <summary>
   /// IComparable.CompareTo implementation.
   /// </summary>
protected:
   // The value holder
   Double m_value;

public:
   virtual Int32 CompareTo( Object^ obj ) {
   
      if (obj == nullptr) return 1;
      
      if ( obj->GetType() == Temperature::typeid ) {
         Temperature^ temp = dynamic_cast<Temperature^>(obj);

         return m_value.CompareTo( temp->m_value );
      }
      throw gcnew ArgumentException(  "object is not a Temperature" );
   }

   property Double Value {
      Double get() {
         return m_value;
      }
      void set( Double value ) {
         m_value = value;
      }
   }

   property Double Celsius  {
      Double get() {
         return (m_value - 32) / 1.8;
      }
      void set( Double value ) {
         m_value = (value * 1.8) + 32;
      }
   }
};

int main()
{
   ArrayList^ temperatures = gcnew ArrayList;
   // Initialize random number generator.
   Random^ rnd = gcnew Random;

   // Generate 10 temperatures between 0 and 100 randomly.
   for (int ctr = 1; ctr <= 10; ctr++)
   {
      int degrees = rnd->Next(0, 100);
      Temperature^ temp = gcnew Temperature;
      temp->Value = degrees;
      temperatures->Add(temp);
   }

   // Sort ArrayList.
   temperatures->Sort();
      
   for each (Temperature^ temp in temperatures)
      Console::WriteLine(temp->Value);
   return 0;
}
// The example displays the following output to the console (individual
// values may vary because they are randomly generated):
//       2
//       7
//       16
//       17
//       31
//       37
//       58
//       66
//       72
//       95

using System;
using System.Collections;

public class Temperature : IComparable
{
    // The temperature value
    protected double temperatureF;

    public int CompareTo(object obj) {
        if (obj == null) return 1;

        Temperature otherTemperature = obj as Temperature;
        if (otherTemperature != null)
            return this.temperatureF.CompareTo(otherTemperature.temperatureF);
        else
           throw new ArgumentException("Object is not a Temperature");
    }

    public double Fahrenheit
    {
        get
        {
            return this.temperatureF;
        }
        set 
        {
            this.temperatureF = value;
        }
    }

    public double Celsius
    {
        get
        {
            return (this.temperatureF - 32) * (5.0/9);
        }
        set
        {
            this.temperatureF = (value * 9.0/5) + 32;
        }
    }
}

public class CompareTemperatures
{
   public static void Main()
   {
      ArrayList temperatures = new ArrayList();
      // Initialize random number generator.
      Random rnd = new Random();

      // Generate 10 temperatures between 0 and 100 randomly.
      for (int ctr = 1; ctr <= 10; ctr++)
      {
         int degrees = rnd.Next(0, 100);
         Temperature temp = new Temperature();
         temp.Fahrenheit = degrees;
         temperatures.Add(temp);
      }

      // Sort ArrayList.
      temperatures.Sort();

      foreach (Temperature temp in temperatures)
         Console.WriteLine(temp.Fahrenheit);
   }
}
// The example displays the following output to the console (individual
// values may vary because they are randomly generated):
//       2
//       7
//       16
//       17
//       31
//       37
//       58
//       66
//       72
//       95

open System
open System.Collections

type Temperature() =
    // The temperature value
    let mutable temperatureF = 0.

    interface IComparable with
        member _.CompareTo(obj) =
            match obj with 
            | null -> 1
            | :? Temperature as other -> 
                temperatureF.CompareTo other.Fahrenheit
            | _ ->
                invalidArg (nameof obj) "Object is not a Temperature"

    member _.Fahrenheit 
        with get () =
            temperatureF
        and set (value) = 
            temperatureF <- value

    member _.Celsius
        with get () =
            (temperatureF - 32.) * (5. / 9.)
        and set (value) =
            temperatureF <- (value * 9. / 5.) + 32.

let temperatures = ResizeArray()

// Initialize random number generator.
let rnd = Random()

// Generate 10 temperatures between 0 and 100 randomly.
for _ = 1 to 10 do
    let degrees = rnd.Next(0, 100)
    let temp = Temperature(Fahrenheit=degrees)
    temperatures.Add temp

// Sort ResizeArray.
temperatures.Sort()

for temp in temperatures do
    printfn $"{temp.Fahrenheit}"

// The example displays the following output to the console (individual
// values may vary because they are randomly generated):
//       2
//       7
//       16
//       17
//       31
//       37
//       58
//       66
//       72
//       95

Imports System.Collections

Public Class Temperature
    Implements IComparable
    ' The temperature value
    Protected temperatureF As Double

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo
        
        If obj Is Nothing Then Return 1

        Dim otherTemperature As Temperature = TryCast(obj, Temperature)
        If otherTemperature IsNot Nothing Then
            Return Me.temperatureF.CompareTo(otherTemperature.temperatureF)
        Else
           Throw New ArgumentException("Object is not a Temperature")
        End If   
    End Function

    Public Property Fahrenheit() As Double
        Get
            Return temperatureF
        End Get
        Set(ByVal Value As Double)
            Me.temperatureF = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (temperatureF - 32) * (5/9)
        End Get
        Set(ByVal Value As Double)
            Me.temperatureF = (Value * 9/5) + 32
        End Set
    End Property
End Class

Public Module CompareTemperatures
   Public Sub Main()
      Dim temperatures As New ArrayList
      ' Initialize random number generator.
      Dim rnd As New Random()
      
      ' Generate 10 temperatures between 0 and 100 randomly.
      For ctr As Integer = 1 To 10
         Dim degrees As Integer = rnd.Next(0, 100)
         Dim temp As New Temperature
         temp.Fahrenheit = degrees
         temperatures.Add(temp)   
      Next

      ' Sort ArrayList.
      temperatures.Sort()
      
      For Each temp As Temperature In temperatures
         Console.WriteLine(temp.Fahrenheit)
      Next      
   End Sub
End Module
' The example displays the following output to the console (individual
' values may vary because they are randomly generated):
'       2
'       7
'       16
'       17
'       31
'       37
'       58
'       66
'       72
'       95

備註

CompareTo 方法是由可排序或排序其值的類型實作。 由非泛型集合物件的方法自動呼叫，例如 Array.Sort，以排序陣列的每個成員。 如果自訂類別或結構未實作 IComparable，則無法排序其成員，而且排序作業可以擲回 InvalidOperationException。

這個方法只是定義，而且必須由特定類別或實值型別實作，才能生效。 傳回值區段中所指定的比較意義（“之前”、“發生於相同位置”，而“follows”）取決於特定實作。

根據定義，任何對象都會比較大於 （或跟隨） null，而兩個 Null 參考會彼此相等。

參數 obj必須與實作這個介面的類別或實值型別相同;否則，會擲回 ArgumentException。

給實施者的注意事項

針對物件 A、B 和 C，下列項目必須為 true：

A.CompareTo(A) 必須傳回零。

如果 A.CompareTo(B) 傳回零，則 B.CompareTo(A) 必須傳回零。

如果 A.CompareTo(B) 傳回零，且 B.CompareTo(C) 傳回零，則 A.CompareTo(C) 必須傳回零。

如果 A.CompareTo(B) 傳回零以外的值，則 B.CompareTo(A) 必須傳回相反正負號的值。

如果 A.CompareTo(B) 傳回的值 「x」 不等於零，且 B.CompareTo(C) 傳回與 「x」 相同符號的值 「y」 ，則 A.CompareTo(C) 必須傳回與 「x」 和 「y」 相同的符號值。

給呼叫者的注意事項

使用 CompareTo(Object) 方法來判斷類別實例的順序。

另請參閱

• Object