IComparable<T> 인터페이스

정의

네임스페이스:: System

어셈블리:: mscorlib.dll, System.Runtime.dll

어셈블리:: mscorlib.dll

어셈블리:: System.Runtime.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

값 형식 또는 클래스가 해당 인스턴스의 순서를 지정하거나 정렬하기 위한 형식별 비교 메서드를 만들기 위해 구현하는 일반화된 비교 메서드를 정의합니다.

generic <typename T>
public interface class IComparable

public interface IComparable<in T>

public interface IComparable<T>

type IComparable<'T> = interface

Public Interface IComparable(Of In T)

Public Interface IComparable(Of T)

형식 매개 변수

T

비교할 개체의 형식입니다.

이 형식 매개 변수는 반공변(Contravariant)입니다. 즉, 지정한 형식이나 더 적게 파생된 모든 형식을 사용할 수 있습니다. 공변성(Covariance) 및 반공변성(Contravariance)에 대한 자세한 내용은 제네릭의 공변성(Covariance) 및 반공변성(Contravariance)을 참조하세요.

파생: System.Boolean

System.Byte

System.Char

System.DateTime

System.DateTimeOffset

자세히…

예제

다음 예제에서는 단순 Temperature 개체의 IComparable<T> 구현을 보여 줍니다. 이 예제에서는 개체 키를 사용하여 SortedList<TKey,TValue> 문자열 Temperature 컬렉션을 만들고 여러 쌍의 온도와 문자열을 시퀀스 외부 목록에 추가합니다. 메서드 SortedList<TKey,TValue> 호출 Add 에서 컬렉션은 구현을 IComparable<T> 사용하여 목록 항목을 정렬한 다음 온도를 높이는 순서대로 표시됩니다.

using System;
using System.Collections.Generic;

public class Temperature : IComparable<Temperature>
{
    // Implement the generic CompareTo method with the Temperature
    // class as the Type parameter.
    //
    public int CompareTo(Temperature other)
    {
        // If other is not a valid object reference, this instance is greater.
        if (other == null) return 1;

        // The temperature comparison depends on the comparison of
        // the underlying Double values.
        return m_value.CompareTo(other.m_value);
    }

    // Define the is greater than operator.
    public static bool operator >  (Temperature operand1, Temperature operand2)
    {
       return operand1.CompareTo(operand2) > 0;
    }

    // Define the is less than operator.
    public static bool operator <  (Temperature operand1, Temperature operand2)
    {
       return operand1.CompareTo(operand2) < 0;
    }

    // Define the is greater than or equal to operator.
    public static bool operator >=  (Temperature operand1, Temperature operand2)
    {
       return operand1.CompareTo(operand2) >= 0;
    }

    // Define the is less than or equal to operator.
    public static bool operator <=  (Temperature operand1, Temperature operand2)
    {
       return operand1.CompareTo(operand2) <= 0;
    }

    // The underlying temperature value.
    protected double m_value = 0.0;

    public double Celsius
    {
        get
        {
            return m_value - 273.15;
        }
    }

    public double Kelvin
    {
        get
        {
            return m_value;
        }
        set
        {
            if (value < 0.0)
            {
                throw new ArgumentException("Temperature cannot be less than absolute zero.");
            }
            else
            {
                m_value = value;
            }
        }
    }

    public Temperature(double kelvins)
    {
        this.Kelvin = kelvins;
    }
}

public class Example
{
    public static void Main()
    {
        SortedList<Temperature, string> temps =
            new SortedList<Temperature, string>();

        // Add entries to the sorted list, out of order.
        temps.Add(new Temperature(2017.15), "Boiling point of Lead");
        temps.Add(new Temperature(0), "Absolute zero");
        temps.Add(new Temperature(273.15), "Freezing point of water");
        temps.Add(new Temperature(5100.15), "Boiling point of Carbon");
        temps.Add(new Temperature(373.15), "Boiling point of water");
        temps.Add(new Temperature(600.65), "Melting point of Lead");

        foreach( KeyValuePair<Temperature, string> kvp in temps )
        {
            Console.WriteLine("{0} is {1} degrees Celsius.", kvp.Value, kvp.Key.Celsius);
        }
    }
}
/* This example displays the following output:
      Absolute zero is -273.15 degrees Celsius.
      Freezing point of water is 0 degrees Celsius.
      Boiling point of water is 100 degrees Celsius.
      Melting point of Lead is 327.5 degrees Celsius.
      Boiling point of Lead is 1744 degrees Celsius.
      Boiling point of Carbon is 4827 degrees Celsius.
*/

open System
open System.Collections.Generic

type Temperature(kelvins: double) =
    // The underlying temperature value.
    let mutable kelvins = kelvins

    do 
        if kelvins < 0. then
            invalidArg (nameof kelvins) "Temperature cannot be less than absolute zero."

    // Define the is greater than operator.
    static member op_GreaterThan (operand1: Temperature, operand2: Temperature) =
        operand1.CompareTo operand2 > 0

    // Define the is less than operator.
    static member op_LessThan (operand1: Temperature, operand2: Temperature) =
        operand1.CompareTo operand2 < 0

    // Define the is greater than or equal to operator.
    static member op_GreaterThanOrEqual (operand1: Temperature, operand2: Temperature) =
        operand1.CompareTo operand2 >= 0

    // Define the is less than or equal to operator.
    static member op_LessThanOrEqual (operand1: Temperature, operand2: Temperature) =
        operand1.CompareTo operand2 <= 0

    member _.Celsius =
        kelvins - 273.15

    member _.Kelvin
        with get () =
            kelvins
        and set (value) =
            if value < 0. then
                invalidArg (nameof value) "Temperature cannot be less than absolute zero."
            else
                kelvins <- value

    // Implement the generic CompareTo method with the Temperature
    // class as the Type parameter.
    member _.CompareTo(other: Temperature) =
        // If other is not a valid object reference, this instance is greater.
        match box other with
        | null -> 1
        | _ ->
            // The temperature comparison depends on the comparison of
            // the underlying Double values.
            kelvins.CompareTo(other.Kelvin)

    interface IComparable<Temperature> with
        member this.CompareTo(other) = this.CompareTo other

let temps = SortedList()

// Add entries to the sorted list, out of order.
temps.Add(Temperature 2017.15, "Boiling point of Lead")
temps.Add(Temperature 0., "Absolute zero")
temps.Add(Temperature 273.15, "Freezing point of water")
temps.Add(Temperature 5100.15, "Boiling point of Carbon")
temps.Add(Temperature 373.15, "Boiling point of water")
temps.Add(Temperature 600.65, "Melting point of Lead")

for kvp in temps do
    printfn $"{kvp.Value} is {kvp.Key.Celsius} degrees Celsius."

//  This example displays the following output:
//       Absolute zero is -273.15 degrees Celsius.
//       Freezing point of water is 0 degrees Celsius.
//       Boiling point of water is 100 degrees Celsius.
//       Melting point of Lead is 327.5 degrees Celsius.
//       Boiling point of Lead is 1744 degrees Celsius.
//       Boiling point of Carbon is 4827 degrees Celsius.

Imports System.Collections.Generic

Public Class Temperature
    Implements IComparable(Of Temperature)

    ' Implement the generic CompareTo method with the Temperature class 
    ' as the type parameter. 
    '
    Public Overloads Function CompareTo(ByVal other As Temperature) As Integer _
        Implements IComparable(Of Temperature).CompareTo

        ' If other is not a valid object reference, this instance is greater.
        If other Is Nothing Then Return 1
        
        ' The temperature comparison depends on the comparison of the
        ' the underlying Double values. 
        Return m_value.CompareTo(other.m_value)
    End Function
    
    ' Define the is greater than operator.
    Public Shared Operator >  (operand1 As Temperature, operand2 As Temperature) As Boolean
       Return operand1.CompareTo(operand2) > 0
    End Operator
    
    ' Define the is less than operator.
    Public Shared Operator <  (operand1 As Temperature, operand2 As Temperature) As Boolean
       Return operand1.CompareTo(operand2) < 0
    End Operator

    ' Define the is greater than or equal to operator.
    Public Shared Operator >=  (operand1 As Temperature, operand2 As Temperature) As Boolean
       Return operand1.CompareTo(operand2) >= 0
    End Operator
    
    ' Define the is less than operator.
    Public Shared Operator <=  (operand1 As Temperature, operand2 As Temperature) As Boolean
       Return operand1.CompareTo(operand2) <= 0
    End Operator

    ' The underlying temperature value.
    Protected m_value As Double = 0.0

    Public ReadOnly Property Celsius() As Double
        Get
            Return m_value - 273.15
        End Get
    End Property

    Public Property Kelvin() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            If value < 0.0 Then 
                Throw New ArgumentException("Temperature cannot be less than absolute zero.")
            Else
                m_value = Value
            End If
        End Set
    End Property

    Public Sub New(ByVal kelvins As Double)
        Me.Kelvin = kelvins 
    End Sub
End Class

Public Class Example
    Public Shared Sub Main()
        Dim temps As New SortedList(Of Temperature, String)

        ' Add entries to the sorted list, out of order.
        temps.Add(New Temperature(2017.15), "Boiling point of Lead")
        temps.Add(New Temperature(0), "Absolute zero")
        temps.Add(New Temperature(273.15), "Freezing point of water")
        temps.Add(New Temperature(5100.15), "Boiling point of Carbon")
        temps.Add(New Temperature(373.15), "Boiling point of water")
        temps.Add(New Temperature(600.65), "Melting point of Lead")

        For Each kvp As KeyValuePair(Of Temperature, String) In temps
            Console.WriteLine("{0} is {1} degrees Celsius.", kvp.Value, kvp.Key.Celsius)
        Next
    End Sub
End Class

' The example displays the following output:
'      Absolute zero is -273.15 degrees Celsius.
'      Freezing point of water is 0 degrees Celsius.
'      Boiling point of water is 100 degrees Celsius.
'      Melting point of Lead is 327.5 degrees Celsius.
'      Boiling point of Lead is 1744 degrees Celsius.
'      Boiling point of Carbon is 4827 degrees Celsius.
'

설명

이 인터페이스는 값을 정렬하거나 정렬할 수 있는 형식에 의해 구현되며 제네릭 컬렉션 개체의 멤버를 정렬하기 위한 강력한 형식의 비교 메서드를 제공합니다. 예를 들어 한 숫자는 두 번째 숫자보다 클 수 있고 한 문자열은 사전순으로 표시될 수 있습니다. 형식을 구현하려면 정렬 순서에서 현재 인스턴스의 위치가 동일한 형식의 두 번째 개체 이전인지, 이후인지 또는 동일한지를 나타내는 단일 메서드 CompareTo(T)를 정의해야 합니다. 일반적으로 메서드는 개발자 코드에서 직접 호출되지 않습니다. 대신, 다음과 같은 List<T>.Sort() 메서드에 의해 자동으로 호출됩니다 Add.

일반적으로 구현을 IComparable<T> 제공하는 형식도 인터페이스를 구현합니다 IEquatable<T> . 인터페이스는 IEquatable<T> 구현 형식의 Equals 인스턴스의 같음을 결정하는 메서드를 정의합니다.

메서드의 CompareTo(T) 구현은 다음 표와 같이 세 가지 값 중 하나가 있는 값을 반환 Int32 해야 합니다.

Value	Meaning
0보다 작음	이 개체는 정렬 순서에서 메서드에 CompareTo 의해 지정된 개체 앞에 섰습니다.
0	이 현재 인스턴스는 메서드 인수에 지정된 CompareTo 개체와 정렬 순서에서 동일한 위치에서 발생합니다.
0보다 큼	이 현재 인스턴스는 정렬 순서에서 메서드 인수로 CompareTo 지정된 개체를 따릅니다.

모든 숫자 형식(예: Int32 및)은 , IComparable<T>및 String Char DateTime.Double 또한 사용자 지정 형식은 개체 인스턴스의 IComparable<T> 순서를 지정하거나 정렬할 수 있도록 고유한 구현을 제공해야 합니다.

구현자 참고

인터페이스의 형식 매개 변수를 IComparable<T> 이 인터페이스를 구현하는 형식으로 바꿉니다.

구현IComparable<T>하는 경우 , op_GreaterThanOrEqual및 op_LessThanop_LessThanOrEqual 연산자를 op_GreaterThan오버로드하여 일치하는 CompareTo(T)값을 반환해야 합니다. 또한 IEquatable<T>. IEquatable<T> 자세한 내용은 문서를 참조하세요.

메서드

Name	Description
CompareTo(T)	현재 인스턴스를 동일한 형식의 다른 개체와 비교하고 현재 인스턴스가 다른 개체와 정렬 순서의 동일한 위치에서 선행, 팔로우 또는 발생하는지 여부를 나타내는 정수를 반환합니다.

적용 대상

추가 정보

피드백

이 페이지가 도움이 되었나요?