icomparable

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

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

This question already has an answer here: When to use IComparable<T> Vs. IComparer<T> 8 answers What is the difference between IComparable and IComparer Interfaces? Is it necessary to use this interface always with Array.Sort() method nawfal As the name suggests, IComparable<T> reads out I'm comparable . IComparable<T> when defined for T lets you compare the current instance with another instance of same type. IComparer<T> reads out I'm a comparer, I compare . IComparer<T> is used to compare any two instances of T , typically outside the scope of the instances of T . As to what they are for

I'm trying to figure out which of these interfaces I need to implement. They both essentially do the same thing. When would I use one over the other? Well they are not quite the same thing as IComparer<T> is implemented on a type that is capable of comparing two different objects while IComparable<T> is implemented on types that are able to compare themselves with other instances of the same type. I tend to use IComparable<T> for times when I need to know how another instance relates to this instance. IComparer<T> is useful for sorting collections as the IComparer<T> stands outside of the

How do I compare values of generic types? I have reduced it to a minimal sample: public class Foo<T> where T : IComparable { private T _minimumValue = default(T); public bool IsInRange(T value) { return (value >= _minimumValue); // <-- Error here } } The error is: Operator '>=' cannot be applied to operands of type 'T' and 'T'. What on earth!? T is already constrained to IComparable , and even when constraining it to value types ( where T: struct ), we still can't apply any of the operators < , > , <= , >= , == or != . (I know that workarounds involving Equals() exist for == and != , but it