Cómo comparar dos elementos de la misma, pero sin restricciones de tipo genérico de la igualdad?[duplicar]

Question

Posibles Duplicados:
No puede el operador == aplicarse a tipos genéricos en C#?

Tengo la siguiente clase genérica y el compilador se queja de 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");
            }
        }
    }
}

Si me limitan TValue a class, Yo podía usar Object.Equals().Ya que necesito esto para boths las estructuras de clases y yo estaría muy contento si pudiera evitar que a pesar de.

Así que la pregunta es, ¿cómo puedo comparar dos elementos de la misma, pero sin restricciones de tipo genérico de la igualdad?

Answer 1

¿Intentaste algo como esto?

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

Tres opciones:

• Restringir TValue para implementar IEquatable<TValue> y, a continuación, llamar a x.Equals(y)
• Tomar otro parámetro de tipo IEqualityComparer<TValue> y el uso que
• Uso EqualityComparer<TValue>.Default para realizar las comparaciones

Siempre se puede mezclar y combinar las opciones 2 y 3, por supuesto - de forma predeterminada el comparador predeterminado, sino que también permiten una específica para ser proporcionada.

Answer 3

• Equals () para tipos de valor
• ReferenceEquals () para tipos de referencia

Answer 4

¿Es IComparable una opción?

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

Creo que el operador != no se puede aplicar aquí porque hay casos en los que no se puede usar. Por ejemplo, == no se puede usar para comparar estructuras, a menos que los operadores de comparación (int != int <=>) estén sobrecargados.

Por supuesto, puede comparar estructuras de lenguaje, como <=>, pero no estoy seguro de cómo se implementa.

Entonces, debido a que TValue puede ser una estructura personalizada , no puede usar el 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;
        }