1

is there a straight forward way in .NET to compare two objects of same types.

Is there something like Compare(Object1, Object2) that can return a bool based on equality of the object properties values?

I have read about the IComparable and IComparer interfaces but I am looking at comparision of all the properties instead of just one or two.

Regards.

Improve this question
1
  • More on the implementation part can be found here link Commented Nov 23, 2012 at 6:48

2 Answers 2

Reset to default
2

In general, what you describe is part of the contract of the Equals() method, depending on the particulars of the class in question.

Each class where it is relevant should implement Equals based on its own semantics.

Formally, per the Microsoft article

http://msdn.microsoft.com/en-us/library/vstudio/336aedhh(v=vs.100).aspx

the contract is:

x.Equals(x) returns true.

x.Equals(y) returns the same value as y.Equals(x).

(x.Equals(y) && y.Equals(z)) returns true if and only if x.Equals(z) returns true.

Successive invocations of x.Equals(y) return the same value as long as the objects referenced by x and y are not modified.

x.Equals(null) returns false.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Since that article brought up a good point that you should override the HashTable as well what is the recommended process for this?
That is a very complex subject, and googling will quickly overwhelm you with data. One common practice, when the type is essentially the sum of its members, is to sum in some manner (such as xor) their individual hashcodes. Remember, a constant hashcode of 1 for a class is legal, just grossly inefficient. So the most crucial thing is to avoid violating any of the hashcode contracts.
For a simple two-member test class, the Rescharper tool did this, which is the idea with a prime number mod: return ((x != null ? x.GetHashCode() : 0)*397) ^ y;
0

if I could also expand on that you can override the == and != operators of a particular class. I usually override all 3 (the equals, and the 2 operator) so that I can use unit tests to do somethign like

CustomClass customClass1 = new CustomClass("Robert");
CustomClass customClass2 = new CustomClass("Robert");

Assert.IsTrue(customClass1 == customClass2);
Assert.AreEqual(customClass1, customClass2);

comes in handy to have all options available if you ask me.

Improve this answer

3 Comments

This is a personal opinion, but I think overriding operators is a very dangerous game, especially when you change the semantics of == and != which other programmers will expect to respect the reference semantics, and not value-of semantics if your code ever has to be used or maintained by someone other than yourself. While operator override is great in certain narrow cases (such as arithmetic operators on a Complex data type) to reduce the wordiness of code, it can be a maintainability nightmare. The problem is that it is an invisible non-local effect.
@SAJ14SAJ interesting, i never considered that impact by overriding those operators. My feelings on this come from the standpoint that I have unit tests, so if you change my code, then run my unit tests and see if you broke anything. You are 100% correct though about not using it all the time. My rule of thumb is that if there are multiple points in a class that you have to check for to determine if they are equal, then override them, if not just check the one field outside of the class.
I am flattered that my mini-rant was worth thinking about. C# programmers should expect different semantics from == and Equals. If nothing else, the string class teaches us that!

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.