Como comparar dois elementos do mesmo, mas sem restrições de tipo genérico de igualdade? [duplicado]

Question

Duplicate possíveis:
não pode operador == ser aplicado a tipos genéricos em C #?

Eu tenho a seguinte classe genérica eo compilador reclama que "Operator '!=' cannot be applied to operands of type 'TValue' and 'TValue'" (ver CS0019 ):

public class Example<TValue>
{
    private TValue _value;
    public TValue Value
    {
        get { return _value; }
        set
        {
            if (_value != value) // <<-- ERROR
            {
                _value= value;
                OnPropertyChanged("Value");
            }
        }
    }
}

Se eu restringir TValue para class, eu poderia usar Object.Equals(). Desde que eu preciso disso para boths estruturas e classes Eu ficaria muito feliz se pudesse evitar que embora.

Então a pergunta é, como posso comparar dois elementos do mesmo, mas sem restrições de tipo genérico de igualdade?

Answer 1

Você tentou algo assim?

public class Example<TValue>
{
    private TValue _value;
    public TValue Value
    {
        get { return _value; }
        set
        {

            if (!object.Equals(_value, value))
            {
                _value = value;
                OnPropertyChanged("Value");
            }
        }
    }
}

Answer 2

Opções Três:

• Restringir TValue para implementar IEquatable<TValue> e depois chamar x.Equals(y)
• Tome um outro parâmetro do tipo IEqualityComparer<TValue> eo uso que
• Use EqualityComparer<TValue>.Default para executar as comparações

Você pode sempre misturar e opções de correspondência 2 e 3, é claro -. Padrão para o comparador padrão, mas também permitir que um específico a ser fornecido

Answer 3

• Equals () para tipos de valor
• ReferenceEquals () para tipos de referência

Answer 4

IComparable é uma opção?

public class Example<TValue> where TValue: IComparable
{
    private TValue _value;
    public TValue Value
    {
        get { return _value; }
        set
        {

            if (_value.CompareTo(value) != 0)
            {
                _value = value;
                OnPropertyChanged("Value");
            }
        }
    }
}

Answer 5

Eu acho que o operador != não pode ser aplicada aqui porque há casos em que não podem ser usados. Por exemplo, != não pode ser usado para comparar estruturas, a menos que os operadores comparam (== !=) estão sobrecarregadas.

É claro, você pode comparar estruturas de linguagem, como int != int, mas eu não sei como isso é implementado.

Assim, porque TValue pode ser um costume struct, não pode usar o operador !=.

Answer 6

public static bool operator ==(EntityBase<T> entity1, EntityBase<T> entity2)
        {
            if ((object)entity1 == null && (object)entity2 == null)
            {
                return true;
            }

            if ((object)entity1 == null || (object)entity2 == null)
            {
                return false;
            }

            if (Comparer<T>.Default.Compare(entity1.Id, entity2.Id) != 0)
            {
                return false;
            }

            return true;
        }