# IComparable Interfejs

## Definicja

Definiuje uogólniona metoda porównania specyficzna dla typu, która implementuje typ wartości lub klasę w celu porządkowowania lub sortowania wystąpień.

``public interface class IComparable``
``public interface IComparable``
``````[System.Runtime.InteropServices.ComVisible(true)]
public interface IComparable``````
``type IComparable = interface``
``````[<System.Runtime.InteropServices.ComVisible(true)>]
type IComparable = interface``````
``Public Interface IComparable``
Pochodne
Atrybuty

Poniższy przykład ilustruje implementację IComparable metody i wymaganą CompareTo metodę.

``````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;
}

// 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;
}

// 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)

// 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
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
``````

## Uwagi

Ten interfejs jest implementowany przez typy, których wartości można porządkować lub sortować. Wymaga to, aby implementacja typów zdefiniowała pojedynczą metodę , CompareTo(Object)która wskazuje, czy pozycja bieżącego wystąpienia w kolejności sortowania jest wcześniej, po, czy też taka sama jak drugi obiekt tego samego typu. Implementacja wystąpienia jest wywoływana IComparable automatycznie przez metody, takie jak Array.Sort i ArrayList.Sort.

Implementacja CompareTo(Object) metody musi zwrócić Int32 jedną z trzech wartości, jak pokazano w poniższej tabeli.

Wartość Znaczenie
Mniej niż zero Bieżące wystąpienie poprzedza obiekt określony przez metodę CompareTo w kolejności sortowania.
Zero To bieżące wystąpienie występuje w tej samej pozycji w kolejności sortowania co obiekt określony przez metodę CompareTo .
Większe od zera To bieżące wystąpienie jest zgodne z obiektem określonym przez metodę CompareTo w kolejności sortowania.

Wszystkie typy liczbowe (takie jak Int32 i Double) implementują IComparable, jak do String, Chari DateTime. Typy niestandardowe powinny również zapewniać własną implementację, IComparable aby umożliwić porządkowenie lub sortowanie wystąpień obiektów.

## Metody

 Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.