Ler em inglês

Compartilhar via


IComparable<T> Interface

Definição

Define um método de comparação generalizado que implementa uma classe ou um tipo de valor para criar um método de comparação de tipo específico para ordenar ou classificar suas instâncias.

public interface IComparable<in T>
public interface IComparable<T>

Parâmetros de tipo

T

O tipo de objeto a ser comparado.

Este parâmetro de tipo é contravariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.
Derivado

Exemplos

O exemplo a seguir ilustra a implementação de IComparable<T> um objeto simples Temperature . O exemplo cria uma SortedList<TKey,TValue> coleção de cadeias de caracteres com Temperature chaves de objeto e adiciona vários pares de temperaturas e cadeias de caracteres à lista fora da sequência. Na chamada ao Add método, a SortedList<TKey,TValue> coleção usa a IComparable<T> implementação para classificar as entradas da lista, que são exibidas em ordem de aumento da temperatura.

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.
*/

Comentários

Essa interface é implementada por tipos cujos valores podem ser ordenados ou classificados e fornece um método de comparação fortemente tipado para ordenar membros de um objeto de coleção genérico. Por exemplo, um número pode ser maior que um segundo número e uma cadeia de caracteres pode aparecer em ordem alfabética antes da outra. Requer que a implementação de tipos defina um único método, CompareTo(T)que indica se a posição da instância atual na ordem de classificação é antes, depois ou a mesma que um segundo objeto do mesmo tipo. Normalmente, o método não é chamado diretamente do código do desenvolvedor. Em vez disso, ele é chamado automaticamente por métodos como List<T>.Sort() e Add.

Normalmente, os tipos que fornecem uma implementação IComparable<T> também implementam a IEquatable<T> interface. A IEquatable<T> interface define o Equals método, que determina a igualdade de instâncias do tipo de implementação.

A implementação do CompareTo(T) método deve retornar um Int32 que tenha um dos três valores, conforme mostrado na tabela a seguir.

Valor Significado
Menor que zero Esse objeto precede o objeto especificado pelo CompareTo método na ordem de classificação.
Zero Essa instância atual ocorre na mesma posição na ordem de classificação que o objeto especificado pelo argumento do CompareTo método.
Maior que zero Esta instância atual segue o objeto especificado pelo argumento de CompareTo método na ordem de classificação.

Todos os tipos numéricos (como Int32 e Double) implementam IComparable<T>, assim Stringcomo , Chare DateTime. Os tipos personalizados também devem fornecer sua própria implementação IComparable<T> para permitir que instâncias de objeto sejam ordenadas ou classificadas.

Notas aos Implementadores

Substitua o parâmetro de tipo da IComparable<T> interface pelo tipo que está implementando essa interface.

Se você implementarIComparable<T>, deverá sobrecarregar os op_GreaterThanop_LessThanop_GreaterThanOrEqualoperadores e op_LessThanOrEqual os operadores para retornar valores consistentes com .CompareTo(T) Além disso, você também deve implementar IEquatable<T>. Consulte o IEquatable<T> artigo para obter informações completas.

Métodos

CompareTo(T)

Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.

Aplica-se a

Produto Versões
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

Confira também