equals

Should we override both Equals and GetHashCode properties when implementing a custom class instances comparison? In the following code I have a collection of classes. The class A is compared by the ID , the class B - by Code . using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; namespace ConsoleApplication2 { class Program { static void Main(string[] args) { List<I> bars = new List<I>(); bars.Add(new A() { Id = 1, Code = "one A" }); bars.Add(new B() { Id = 1, Code = "one B" }); bars.Add(new A() { Id = 1, Code = "one A+" }); bars.Add(new B() { Id = 1,

Let's say we are testing the result of a method by asserting the equality of all the properties of the result object with properties of an expected result object. Should we implement equals method and use Assert.AreEqual(expectedResult, actualResult)... But equals may mean something different in production code. Which is the best practice? Asserting the equality of the objects through overriden equals method or Asserting the equality of all the properties I for one use custom assertions. There are two main reasons: don't force test concerns into production. This means that the meaning of

Possible Duplicate: Overriding equals and hashCode in Java If I have class A { int x = 1; } ... A a1 = new A(); A a2 = new A(); a1.equals(a2); If I compare 2 instances of A without override the equals method, will I get expected result? If I compare 2 instances of A without override the equals method, will I get expected result? That depends on what you expect :) The default implementation will give you reference equality - in other words, when you compare two references, equals will only return true if they're references to the same object. You would normally override equals to implement

Consider the following test case, is it a bad practice to use the hashCode() method inside of equals as a convenient shortcut? public class Test { public static void main(String[] args){ Test t1 = new Test(1, 2.0, 3, new Integer(4)); Test t2 = new Test(1, 2.0, 3, new Integer(4)); System.out.println(t1.hashCode() + "\r\n"+t2.hashCode()); System.out.println("t1.equals(t2) ? "+ t1.equals(t2)); } private int myInt; private double myDouble; private long myLong; private Integer myIntObj; public Test(int i, double d, long l, Integer intObj ){ this.myInt = i; this.myDouble = d; this.myLong = l; this

Hashcode() and equals() concept is 1) If two Objects are equal according to equal(), then calling the hashcode method on each of those two objects should produce same hashcode. and other one is 2) It is not required that if two objects are unequal according to the equal(), then calling the hashcode method on each of the two objects must produce distinct values. I tried and understood first one and this is the code for first point. public class Test { public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<Integer, Integer>(); map.put(1, 11); map.put(4, 11); System.out

I have a bunch of class who implement a common interface : Command. And this bunch of class goes to a Map. To get the Map working correctly, I need to each class who implements Command to override the Object.equals(Object other) method. it's fine. But i whould like to force the overriding of equals. => Have a compilation error when something who implement command dont override equals. It's that possible ? Edit : BTW , i will also need to forcing the override of hashcode... No, you can't. What you can do, however, is use an abstract base class instead of an interface, and make equals() abstract

Say I have my own class public class MyObj { /* ... */ } It has some attributes and methods. It DOES NOT implement equals, DOES NOT implement hashCode. Once we call equals and hashCode, what are the default implementations? From Object class? And what are they? How the default equals will work? How the default hashCode will work and what will return? == will just check if they reference to the same object, so it's easy, but what about equals() and hashCode() methods? Etienne de Martel Yes, the default implementation is Object's (generally speaking; if you inherit from a class that redefined

I want to understand the scenarios where IEqualityComparer<T> and IEquatable<T> should be used. The MSDN documentation for both looks very similar. IEqualityComparer<T> is an interface for an object that performs the comparison on two objects of the type T . IEquatable<T> is for an object of type T so that it can compare itself to another. When deciding whether to use IEquatable<T> or IEqualityComparer<T> , one could ask: Is there a preferred way of testing two instances of T for equality, or are there several equally valid ways? If there is only one way of testing two instances of T for