public abstract class Comparers<T> : IComparable<T>, IEquatable<T>
        where T: class
    {
        //Собственно переопределением этого метода в производном классе и 
        //заканчивается реализация всех методов и операторов сравнения...
        protected abstract int Comparer(T other);

        public int CompareTo(T other)
        {
            //Cсылка null...
            if (object.ReferenceEquals(other, null)) return 1;

            //Ссылки указывают на один объект...
            if (ReferenceEquals(this, other)) return 0;

            return
                Comparer(other);
        }

        public bool Equals(T other)
        {
            return CompareTo(other) == 0;
        }

        public override bool Equals(object obj)
        {
            //При obj == null, obj is JobSchedule == false
            if (obj is T)
                return Equals((T)obj);

            return false;
        }

        //Позволяет реализовать оператор == в производном классе просто вызвав в
        //нём этот метод, т.к. выполняет все необходимые проверки и сравнения.
        protected static bool operatorEqual(T op1, T op2)
        {
            //Возвращает true - если op1 и op2 == null или если op1 и op2 указывают на один обьект.
            if (object.ReferenceEquals(op1, op2)) return true;

            //Если op1 == null, то op2 != null, иначе мы бы не преодолели предыдущего условия.
            if (object.ReferenceEquals(op1, null)) return false;

            return op1.Equals(op2);
        }
    }

    public class TestListItem : Comparers<TestListItem>
    {
        public int ID { get; set; }

        public string Caption { get; set; }

        public TestListItem Empty
        {
            get { return new TestListItem(); }
        }

        protected override int Comparer(TestListItem other)
        {
            if (ID != other.ID) return ID - other.ID;

            if (Caption.Length != other.Caption.Length)
                return Caption.Length > other.Caption.Length ? 1 : -1;

            return 
                string.Compare(Caption, other.Caption);
        }

        public static bool operator ==(TestListItem op1, TestListItem op2)
        {
            return operatorEqual(op1, op2);
        }

        public static bool operator !=(TestListItem op1, TestListItem op2)
        {
            return !(op1 == op2);
        }

        public override int GetHashCode()
        {
            return ID ^ Caption.Length;
        }
    }

А>Как вы думаете, правильно-ли так делать и какими проблемами, кроме предупреждений компилятора , это может обернуться

  public sealed class TestListItem : IEquatable<TestListItem>, IComparable<TestListItem>
  {
    private static readonly ComparerBuilder<TestListItem> ComparerBuilder
        = new ComparerBuilder<TestListItem>()
        .Add(x => x.ID)
        .Add(x => x.Caption);
    private static readonly IEqualityComparer<TestListItem> MyEqualityComparer = ComparerBuilder.ToEqualityComparer();
    private static readonly IComparer<TestListItem> MyComparer = ComparerBuilder.ToComparer();

    public int ID { get; set; }

    public string Caption { get; set; }

    public override bool Equals(object obj) {
      return Equals(obj as TestListItem);
    }

    public override int GetHashCode() {
      return MyEqualityComparer.GetHashCode(this);
    }

    public bool Equals(TestListItem other) {
      return MyEqualityComparer.Equals(this, other);
    }

    public int CompareTo(TestListItem other) {
      return MyComparer.Compare(this, other);
    }

    public static bool operator ==(TestListItem left, TestListItem right) {
      return Equals(left, right);
    }

    public static bool operator !=(TestListItem left, TestListItem right) {
      return !(left == right);
    }

    public static bool operator <(TestListItem left, TestListItem right) {
      return MyComparer.Compare(left, right) < 0;
    }

    public static bool operator <=(TestListItem left, TestListItem right) {
      return MyComparer.Compare(left, right) <= 0;
    }

    public static bool operator >(TestListItem left, TestListItem right) {
      return !(left <= right);
    }

    public static bool operator >=(TestListItem left, TestListItem right) {
      return !(left < right);
    }
  }

_FR>  public sealed class TestListItem : IEquatable<TestListItem>, IComparable<TestListItem>
_FR>  {
_FR>    private static readonly ComparerBuilder<TestListItem> ComparerBuilder
_FR>        = new ComparerBuilder<TestListItem>()
_FR>        .Add(x => x.ID)
_FR>        .Add(x => x.Caption);
_FR>    private static readonly IEqualityComparer<TestListItem> MyEqualityComparer = ComparerBuilder.ToEqualityComparer();
_FR>    private static readonly IComparer<TestListItem> MyComparer = ComparerBuilder.ToComparer();
_FR>  }
_FR>

    private static readonly ComparerBuilder<TestListItem> ComparerBuilder
        = new ComparerBuilder<TestListItem>()
        .Add(x => x.ID)
        .Add(x => x.Caption);

А>    private static readonly ComparerBuilder<TestListItem> ComparerBuilder
А>        = new ComparerBuilder<TestListItem>()
А>        .Add(x => x.ID)
А>        .Add(x => x.Caption);

        .Add(x => x.ID)
        .Add(x => x.Caption);

А>        .Add(x => x.ID)
А>        .Add(x => x.Caption);

public ComparerBuilder<T> Add<P>(Expression<Func<T, P>> expression, IEqualityComparer<P> equalityComparer = null, IComparer<P> comparer = null);

А>Честно говоря не очень Откройте глаза

_FR>У вас, вы говорите, есть базовый класс и несколько наследников. Покажите, как вы собираетесь реализовывать Equals\GetHashCode, тогда и посмотрим

    class TwoDPoint : IComparable, IComparable<TwoDPoint>, IEquatable<TwoDPoint>
    {
        protected int x, y;

        public virtual int CompareTo(object obj)        //<<<---
        {
            Console.WriteLine("TwoDPoint.CompareTo(object)");

            if (object.ReferenceEquals(this, obj)) return 0;
            TwoDPoint other = obj as TwoDPoint;
            if (!object.Equals(other, null))
            {
                return x - other.x == 0 && y - other.y == 0 ? 0
                    : x - other.x > 0 || y - other.y > 0 ? 1 : -1;
            }

            return -1;
        }

        public int CompareTo(TwoDPoint other)
        {
            Console.WriteLine("TwoDPoint.CompareTo(TwoDPoint)");
            return CompareTo((object)other);
        }

        public override bool Equals(object obj)
        {
            Console.WriteLine("TwoDPoint.Equals(object)");
            return CompareTo(obj) == 0;
        }

        public bool Equals(TwoDPoint other)
        {
            Console.WriteLine("TwoDPoint.Equals(TwoDPoint)");
            return Equals((object)other);
        }

        public static bool operator ==(TwoDPoint op1, TwoDPoint op2)
        {
            Console.WriteLine("TwoDPoint.operator==");
            if (object.ReferenceEquals(op1, op2)) return true;
            if (object.ReferenceEquals(op1, null)) return false;
            return op1.Equals(op2);
        }

        public static bool operator !=(TwoDPoint op1, TwoDPoint op2)
        {
            Console.WriteLine("TwoDPoint.operator!=");
            return !(op1 == op2);
        }

        public override int GetHashCode()
        {
            return x ^ y;
        }
    }

    class ThreeDPoint : TwoDPoint, IComparable<ThreeDPoint>, IEquatable<ThreeDPoint>
    {
        int z;

        public override int CompareTo(object obj)
        {
            Console.WriteLine("ThreeDPoint.CompareTo(object)");
            
            if (object.ReferenceEquals(this, obj)) return 0;
            ThreeDPoint other = obj as ThreeDPoint;
            if (!object.Equals(other, null))
            {
                return base.CompareTo(obj) == 0 && z == other.z ? 0
                    : base.CompareTo(obj) > 0 || z - other.z > 0 ? 1 : -1;
            }

            return -1;
        }

        public int CompareTo(ThreeDPoint other)
        {
            Console.WriteLine("ThreeDPoint.CompareTo(ThreeDPoint)");
            return CompareTo((object)other);
        }

        public override bool Equals(object obj)
        {
            Console.WriteLine("ThreeDPoint.Equals(object)");
            return this.CompareTo(obj) == 0;
        }

        public bool Equals(ThreeDPoint other)
        {
            Console.WriteLine("ThreeDPoint.Equals(ThreeDPoint)");
            return this.Equals((object)other);
        }

        public static bool operator ==(ThreeDPoint op1, ThreeDPoint op2)
        {
            Console.WriteLine("ThreeDPoint.operator==");
            if (object.ReferenceEquals(op1, op2)) return true;
            if (object.ReferenceEquals(op1, null)) return false;
            return op1.Equals(op2);
        }

        public static bool operator !=(ThreeDPoint op1, ThreeDPoint op2)
        {
            Console.WriteLine("ThreeDPoint.operator!=");
            return !(op1 == op2);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode() ^ z;
        }
    }
    static class Test
    {
        public static void Main()
        {
            ThreeDPoint three = new ThreeDPoint();
            TwoDPoint two = three as TwoDPoint;

            two.Equals(new object());
            Console.WriteLine();

            two.Equals(two);
            Console.WriteLine();

            two.CompareTo(new object());
            Console.WriteLine();

            two.CompareTo(two);
            Console.WriteLine();

            bool a = (two == new TwoDPoint());
            Console.WriteLine();

            bool b = (two != new TwoDPoint());
        }
    }

_FR>>У вас, вы говорите, есть базовый класс и несколько наследников. Покажите, как вы собираетесь реализовывать Equals\GetHashCode, тогда и посмотрим

• Почитайте и посмотрите, что советовали ранее: как разделить реализацию Object::Equals, IEquatable<>::Equals и оператора ==. Вы тот пример
  Автор: _FRED_
  Дата: 27.07.10
  проигнорировали полностью. Требовалось обращения к компараторам заменить на свою собственную логику (сравнения полей). Не могли бы сравнить свой решение с тем и объяснить, чем ваше решение вам нравится больше?
  
• Является ли валидным с вашей точки зрения то, что три равно двум?

  var two = new TwoDPoint();
  var three = new ThreeDPoint();
  Console.WriteLine("Is Two and Three equal? {0}", two == three);

  
  
• Идеи наследования 3d точки от 2d точки, как и то, что эти типы являются классами, очень подозрительны. Если пример надуман, то реализации равенства на таком абстрактном примере неинтересна. Если не надуман, то чем оправдан?

_FR>>public ComparerBuilder<T> Add<P>(Expression<Func<T, P>> expression, IEqualityComparer<P> equalityComparer = null, IComparer<P> comparer = null);

L>А почему именно Expression? Разве Func-а недостаточно?