实现等于使引用相等还是基于键的相等？

Question

I would like to override the Equals and GetHashCode of my EntityBase class to support checking equality based on reference (as by default) or by the entity key (in case the references not matching). Here is the code:

public abstract class EntityBase
{
    protected virtual object Keys { get { return this; } }
    public override bool Equals(object obj)
    {
        if (Keys == this) return base.Equals(obj);
        var entity = obj as EntityBase;
        if (entity == null) return false;
        var re = ReferenceEquals(entity, this);
        return re || Equals(entity.Keys, Keys);
    }
    public override int GetHashCode()
    {
        if (Keys == this) return base.GetHashCode();
        return base.GetHashCode() * 17 + (Keys?.GetHashCode() ?? 0);
    }
}

Now in the derived class it can be like this:

public class Entity : EntityBase {
    protected override object Keys {
        get {
             return SomeKeyProperty;
        }
    }
}

So I expect that it should work, but the BindingSource I'm using showed that it does not work, like this:

//the myEntity here is contained (as reference) in myBindingSource  
var index = myBindingSource.IndexOf(myEntity);

The code above gives the correct result if I don't override Equals for my EntityBase class, but with that overriding, the result will be wrong, looks like it always tries to look for the item based on the Keys value. I don't really understand what's wrong here.

When debugging it does not even hit the breakpoint I set in the Equals method. The code just runs through the IndexOf call like as it's a black box.

Could you explain to me what's wrong here and give me some suggestion about a possible fix (or even let me know if what I want to achieve is possible).

Answer 1

Actually the code I posted runs just like what it should. I want that the reference equality should have higher priority, but really when finding an item (like IndexOf ) in a collection, what comes first will be the one found (if the references does not match then keys will be used).

The reason it did not work as I expect because the 2 ones compared here both have Keys equal to 0 . So if key-based equality is used, that case should be considered as unequal . I need to add another property to determine which value is considered as null or empty Keys . Here is the code working as I expected:

public abstract class EntityBase
{
    protected virtual object Keys { get { return this; } }
    protected virtual object EmptyKeys {get { return null;} }
    public override bool Equals(object obj)
    {
      if (Keys == this) return base.Equals(obj);
      var entity = obj as EntityBase;
      if (entity == null) return false;
      var re = ReferenceEquals(entity, this);
      return re || GetType() == entity.GetType() && Equals(entity.Keys, Keys) && !Equals(Keys, EmptyKeys);
    }
    public override int GetHashCode()
    {
      if (Keys == this) return base.GetHashCode();
      return base.GetHashCode() * 17 + (Keys?.GetHashCode() ?? 0);
    }
}

In the derived class, we need to override the EmptyKeys to indicate which value is considered as empty, NOTE that for numeric key (like long , ...) the value for EmptyKeys should be of the exact type with Keys , otherwise the Equals won't work.

public class Entity : EntityBase {
   protected override object Keys {
      get {
         return SomeKeyProperty;//suppose this is a long property
      }
   }
   protected override object EmptyKeys {
      get {
         return 0L;//here 0 value should also be a long value.
      }
   }
}

After that adjusting, the code works expectedly.