Why is the == operator (defined for the concrete type) not used?

I have a list defined as:

var Items = new List<IItem>();

Now there are a number of different classes that have that interface and one of them is Consumable. The Consumab开发者_运维百科le class also has the == operator overloaded. Now I have the following code and is not working:

if(item1 == item2)
{
    //code...
}

This does not work. I put a break point in the == operator overload and it never gets to it. When I go through line-by-line debugging, both item1 and item2 are of type Consumable, both GetType returns Consumable. I even try this code:

var temp = item1.GetType();
var temp2 = item2.GetType();
if (temp == temp2)
{
    //code...
}

and this equality results is true. Now if I try this:

if(((Consumable)item1) == ((Consumable)item2))
{
    //code...
}

and this triggers the break point in the == operator overload. Why would I have to manually cast the variable if when line-by-line debugging show it already thinks they are both consumable? Is it because I am pulling them from a list of IItems?

Since your list is List<IItem>, I'm assuming you have something like:

var item1 = Items[0];

or whatever; here item1 the variable is typed as IItem. Operator resolution happens during build via static analysis (not at runtime via polymorphism/RTTI), so the only == available is the default for any object, i.e. reference equality.

To support your custom operator, the variables must be typed accordingly, for example:

Consumable item1 = ..., item2 = ...;

Your cast achieves a similar thing.

Another option would be to make sure that == and Equals (and GetHashCode()) are in agreement, and use:

if(Equals(item1, item2)) {...}

which will do null checks and then use your overridden Equals method. This then supports polymorphism, so it doesn't matter what the types are.

The common langauge runtime does only know that your two objects implement the interface IItem. The smallest common part in object hierarchy is System.Object. And you did not overload the == operator of System.Object.

To use the correct overload you have to state the type of the object.

== does not check type equality, but for classes it checks reference equality. So if the variables are pointing to the same object it will be true. For example like this:

var temp = item1;
var temp2 = item1;

if( temp == temp2 )
{
  //this code will execute
}

Shouldn't be the IItem IComparable?