Why doesn't List.Contains work with my code?

Question

I'm using List.Contains to tell whether a variable is inside the list or not, but it keeps on returning that it isn't when it is.

I've looked up MSDN and I've noticed that I have to inherit from IEquatable and implement my own .Equals method. The actual class is inheriting from another one, so I've written the .Equals method in the base class.

Here's the code of the class "Actividad":

abstract public class Actividad:IEquatable<Actividad> {

    protected int codigo;

    [...]

    public bool  Equals(Actividad otra)
    {
        return this.Codigo == otra.Codigo;
    }   
}

and here's the definition of the child class "Actividad_a":

public class Actividad_a : Actividad{ [...] }

This is the code that checks whether something is inside the list:

private void loadDisponibles() {

    foreach (Actividad_a act in Program.Asignaturas) {

        if (!user1.ActAcademicas.Contains(act)) {
           doSomething();
        }
    }
}

Program.Asignaturas and user1.ActAcademicas are both defined as List<Actividad_a>.

The problem is that !user1.ActAcademicas.Contains(act) always returns true, no matter the data is in the list or not.

My first guess is that I have to inherit from IEquatable and implement .Equals method in each derived class, but I'm not really sure about it.

As far as I've checked, it has one element. Although I don't check whether it has anything. Does it matter? — vguzmanp, Apr 16 '12 at 22:13
Maybe set a breakpoint in the `Equals` method to verify `List<>` is indeed calling it. — Mike Christensen, Apr 16 '12 at 22:13
Are you setting `codigo` anywhere? Also, the equals method you've posted uses `Codigo`, which is not the same as `codigo`. — phoog, Apr 16 '12 at 22:13
I think the problem here is you have to override `Object.Equals`, not make a new one. — Mike Christensen, Apr 16 '12 at 22:14
@phoog yes, `codigo` is set. And `Codigo` is actually just a get. Sorry for not including it. — vguzmanp, Apr 16 '12 at 22:18
@MikeChristensen I've set the breakpoint, and it isn't called. But if I write it as `public override bool Equals(Actividad otra)` it says it has no suitable member to invalidate — vguzmanp, Apr 16 '12 at 22:21
Fawques: ok, I was just checking to be sure :) @MikeChristensen is suggesting to override `public override bool Equals(object otra)`, as Vadim also suggests in his answer. — phoog, Apr 16 '12 at 22:23

score 3 · Accepted Answer · edited May 23 '17 at 12:27

You're comparing Actividad_a and the Contains method is expecting it to implement IEquatable<Actividad_a> rather than IEquatable<Actividad>

Try overriding the default Equals method as well

public override bool Equals(object otra)
{
    var actividad = otra as Actividad;
    if (actividad == null) return false;
    return this.Codigo == actividad.Codigo;
}

EDIT:

Some more info: .NET 4.0 introduced flexibility for working with generics called Contravariance and Covariance http://msdn.microsoft.com/en-us/library/dd799517.aspx

Covariant and contravariant generic type parameters provide greater flexibility in assigning and using generic types. For example, covariant type parameters enable you to make assignments that look much like ordinary polymorphism. Suppose you have a base class and a derived class, named Base and Derived. Polymorphism enables you to assign an instance of Derived to a variable of type Base. Similarly, because the type parameter of the IEnumerable(Of T) interface is covariant, you can assign an instance of IEnumerable (IEnumerable(Of Derived) in Visual Basic) to a variable of type IEnumerable

In general, a covariant type parameter can be used as the return type of a delegate, and contravariant type parameters can be used as parameter types. For an interface, covariant type parameters can be used as the return types of the interface's methods, and contravariant type parameters can be used as the parameter types of the interface's methods.

For some reason IEquatable<T> was not made contravariant and why your original approach won't work

Or, as OP suspects, he could implement IEquatable on every type derived from Actividad. Overriding `object.Equals` in `Actividad` is the better approach, however, so +1. (Also, you need the override keyword in your example code.) — phoog, Apr 16 '12 at 22:21
This worked smoothly :). I also had to inherit from IEquatable — vguzmanp, Apr 16 '12 at 22:27
@Fawques, you shouldn't actually have to inherit from IEquatable — Vadim, Apr 18 '12 at 14:18
I just did a override on Equals for my object and it worked like a charm. Thanks! — pStan, Jun 24 '13 at 18:42

Why doesn't List.Contains work with my code?

1 Answers1