Equal but not interchangeable

Question

I have two objects that are something like this:

class Container {
    public HashSet<Item> Items { get; }
}

class Item {
    public Container Parent { get; set; }
    public string Value1 { get; set; }
    public int Value2 { get; set; }
}

Every Item instance must belong to a Container instance, and there is a one-to-many relationship between the two that is always kept in sync at both ends.

I am now faced with implementing a method that compares two instances of Item to see if their Value1 and Value2 values match. The method will not take into consideration the Parent value since each pair of instances I compare definitely differ on this value, so doing so would make the method I am implementing useless since it would then have the same result (false) as the object.ReferenceEquals method.

My question is as follows. Should I implement this method as the object's public override bool Equals( object obj ) method (along with GetHashCode)? Or does the fact that it ignores its Parent property preclude me from doing so? Why or why not? An alternative idea I have is to just implement it as public bool EqualsIgnoreParent( Item other ) which does not override anything; I could then call it from a custom comparer.

Answer 1

Thanks to mikez's comment and Eric Lippert's blog post, I found out that I shouldn't override Item's Equals or GetHashCode methods since Item's instances are mutable and added to a HashSet.

Following the suggestion here, I decided to separate the two concepts of equality.

1. Identity. I did not override Item's Equals and GetHashCode methods. I left those methods as they are in object. That's what the HashSet will use.
2. Equivalence. I created a public singleton class called ValueComparer that's nested within Item and implements IEqualityComparer<Item>. This is where I put the comparison logic that I describe in my question.

Answer 2

I guess you wanted to implement IEquatable. so i suggest you just overloads Euqals(object other) with Euqals(Item other), while overwrites Equals(object other) by calling Equals(Item other).

of course, make GetHashCode return -1 always to force the equality comparison to be done via Equals.here is an explain of why need to overwrite GetHashCode method - Why is it important to override GetHashCode when Equals method is overridden?

Answer 3

Yes, you can implement this with Equals and GetHashCode, as long as Value1 and Value2 don't change or your hash is independent from any change. (otherwise Collections using your HashCode won't work)

Additionally, you could reduce the Item class to the basic members

class Item {
    public string Value1 { get; set; }
    public int Value2 { get; set; }
}

and maintain the relation in an additional dictionary: (which would be efficient, if you implement GetHashCode correctly)

Dictionary<Item, Container> ContainersOfItems;

Answer 4

I would suggest that it might be more meaningful to split Item so it looks something like:

class Container<TContent> {
    public HashSet<Item<TContent>> Items { get; }
}

class Item<TContent> {
    public Container Parent;
    public TContent Content;
}

If you do that, then you can define a type to hold your content which has an Equals method suitable for that type, and initialize your HashSet with an IEqualityComparer<Item<TConcent>> which bases equality upon each Item<TContent>'s Content field.

Answer 5

Don't do it, unless you are 100% sure that the Parent member NEVER makes any difference. There might be many use cases you don't thought of, (what if you need to put items from 2 containers in a single Dictionary?) so i recommend to stick to the design. If by definition equality is determined only by other members, go for it. Otherwise, not.
You can always write case-specific equality logic later. Remember that Dictionary, List, HashSet and other collecctions allow you to define a custom IEqualityComparer.
There's an another option, but be very careful. Override both methods, but make GetHashCode more tolerant than Equals, that means, make unequal objects have the same hash code, and NOT the opposite. Make GetHashCode ignore the Parent member, but not Equals. it won't harm anything, and then if you want to ignore the Parent member in dictionaries, write an IEqualityComparer that compares them the same way like GetHashCode.