iequatable

both the interfaces seem to compare objects for equality, so what's the major differences between them? IEquatable tests whether two objects are equal. IComparable imposes a total ordering on the objects being compared. For example, IEquatable would tell you that 5 is not equal to 7. IComparable would tell you that 5 comes before 7. IEquatable<T> for equality. IComparable<T> for ordering. In addition to Greg D's answer: You might implement IComparable without implementing IEquatable for a class where a partial ordering makes sense, and where very definitely you wish the consumer to draw the

When I implement objects that I want to compare using the IEquatable<T> interface : Why do I have to override Equals(object) method if I already implemented Equals(T) ? Can I use == and != operators once I implement IEquatable<T> ? Ray Booysen From MS Docs article on IEquatable<T> : If you implement IEquatable<T> , you should also override the base class implementations of Equals(Object) and GetHashCode() so that their behavior is consistent with that of the Equals(T) method. If you do override Equals(Object) , your overridden implementation is also called in calls to the static Equals(Object,

Anyone have any opinions on whether or not IEquatable<T> or IComparable<T> should generally require that T is sealed (if it's a class )? This question occurred to me since I'm writing a set of base classes intended to aid in the implementation of immutable classes. Part of the functionality which the base class is intended to provide is automatic implementation of equality comparisons (using the class's fields together with attributes which can be applied to fields to control equality comparisons). It should be pretty nice when I'm finished - I'm using expression trees to dynamically create a

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

I have an array called subscribers that stores objects which conform to the protocol JABPanelChangeSubscriber. The protocol is declared as public protocol JABPanelChangeSubscriber { } and my array is declared as: var subscribers = [JABPanelChangeSubscriber]() Now I need to implement a method to add a subscriber to the list, but it first has to check that that subscriber has not already been added before. public func addSubscriber(subscriber: JABPanelChangeSubscriber) { if subscribers.find(subscriber) == nil { // This ensures that the subscriber has never been added before subscribers.append

Many of my questions here on SO concerns IEquatable implementation. I found it being extremely difficult to implement correctly, because there are many hidden bugs in the naïve implementation, and the articles I found about it are quite incomplete. I want to find or write a definitive reference which must include: How to implement IEquatable correctly How to override Equals correctly How to override GetHashCode correctly How to implement the ToString method correctly How to implement the operator == correctly How to implement the operator != correctly Such a complete reference already exists?