ser - posible comparacion de referencias no intencionada c#

¿Cómo comparar dos elementos del mismo tipo genérico pero sin restricciones para la igualdad?

Question

Posible duplicado:
¿No se puede aplicar el operador == a los 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 restrinjo TValue a la class , podría usar Object.Equals() . Como necesito esto para ambas estructuras y clases, estaría muy feliz si pudiera evitar eso.

Entonces, la pregunta es, ¿cómo puedo comparar dos elementos del mismo tipo genérico sin restricciones para la igualdad?

Answer 1

¿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 2

¿Has probado 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 3

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

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

Entonces, como TValue puede ser una estructura personalizada , no puede usar el operador != .

Answer 4

Tres opciones:

• Constriñe TValue para implementar IEquatable<TValue> y luego llame a x.Equals(y)
• Toma otro parámetro del tipo IEqualityComparer<TValue> y usa eso
• Utilice EqualityComparer<TValue>.Default para realizar las comparaciones

Siempre puede mezclar y combinar las opciones 2 y 3, por supuesto, de forma predeterminada al comparador predeterminado, pero también permite que se proporcione uno específico.

Answer 5

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

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