using System;
using System.Collections.Generic;

namespace CLRviaCSharp
{
  public sealed class Point : IComparable<Point>
  {
    private int m_x, m_y;

    public Point (int x, int y)
    {
      m_x = x;
      m_y = y;
    }

    // implement IComparable.CompareTo()
    public int CompareTo(Point other)
    {
      return Compare(this, other);
    }

    // operator overloading
    public static bool operator <(Point me, Point other)
    {
      return Compare(me, other) < 0;
    }
    public static bool operator <=(Point me, Point other)
    {
      return Compare(me, other) <= 0;
    }
    public static bool operator >(Point me, Point other)
    {
      return Compare(me, other) > 0;
    }
    public static bool operator >=(Point me, Point other)
    {
      return Compare(me, other) >= 0;
    }

    // override Object.ToString()
    public override String ToString()
    {
      return String.Format("({0}, {1})", m_x.ToString(), m_y.ToString());
    }

    // static helper method for points comparison
    public static int Compare(Point p, Point q)
    {
      return Math.Sign(Math.Sqrt(p.m_x * p.m_x + p.m_y * p.m_y) - Math.Sqrt(q.m_x * q.m_x + q.m_y * q.m_y));
    }
    public static int CompareDESC(Point p, Point q)
    {
      return -Compare(p, q);
    }
  }

  public class test
  {
    public static void Main()
    {
      Point[] points = new Point[] {new Point(3, 3), new Point(1, 2)};

      // original points
      Console.WriteLine("Points:");
      foreach (Point p in points)
      {
        Console.WriteLine(p);
      }

      // ordered by IComparable.CompareTo()
      if (points[0].CompareTo(points[1]) > 0)
      {
        Swap<Point>(ref points[0], ref points[1]);
      }
      Console.WriteLine("Points from closest (0, 0) to farthest:");
      foreach (Point p in points)
      {
        Console.WriteLine(p);
      }

      // ordered by overloaded operator <=
      // it is more natural than CompareTo()
      if (points[0] <= points[1])
      {
        Swap<Point>(ref points[0], ref points[1]);
      }
      Console.WriteLine("Points from farthest to closest (0, 0):");
      foreach (Point p in points)
      {
        Console.WriteLine(p);
      }

      // ordered by Array.Sort()
      Array.Sort(points, Point.Compare);
      Console.WriteLine("Points from closest (0, 0) to farthest:");
      foreach (Point p in points)
      {
        Console.WriteLine(p);
      }

      // simulate Array.Sort()
      // Point.CompareDESC is a function (method in C#)
      // which would be tranformed to a delegate by C# compiler
      Sort<Point>(points, Point.CompareDESC);
      Console.WriteLine("Points from farthest to closest (0, 0):");
      foreach (Point p in points)
      {
        Console.WriteLine(p);
      }

      // this time, we define a delegate explicitly
      Comparison<Point> cmpDelegate = new Comparison<Point>(Point.Compare);
      Sort<Point>(points, cmpDelegate);
      Console.WriteLine("Points from closest (0, 0) to farthest:");
      foreach (Point p in points)
      {
        Console.WriteLine(p);
      }
    }

    // simulate Array.Sort<T>(T[] array, Comparison<T> comparison)
    // Comparison<T> is a generic delegate:
    // public delegate int Comparison<T> (T x, T y)
    public static void Sort<T>(T[] pList, Comparison<T> cmp)
    {
      // extremely simplified sort algorithm
      for (int i = 1; i < pList.Length; i++)
      {
        // cmp is a delegate!
        // cmp(pList[i - 1], pList[i]) is also ok and more natural
        if (cmp.Invoke(pList[i - 1], pList[i]) > 0)
        {
          Swap<T>(ref pList[i - 1], ref pList[i]);
        }
      }
    }

    // utility method to swap two objects
    public static void Swap<T>(ref T p, ref T q)
    {
      T temp = p;
      p = q;
      q = temp;
    }
  }
}

这个例子源自Jeffrey Richter《CLR via C#》。原例是讲接口继承的，为了演示C#语言的几个特性，做了些改动。

1、通过operator overloading，Point实现了<、<=、>、>=几个更加自然的比较运算。对比points[0].CompareTo(points[1])和points[0] < points[1]。

2、在定义了Point的“比较”操作的基础上，通过generic method，Point数组实现了排序算法。

3、首先，利用Array.Sort()，可以很方便地完成Point[]的排序。

4、为了研究Array.Sort()的机制，我们实现了自己的Sort()方法。Sort method需要一个callback。C#中没有指针的概念（限于safe code），所以不能像C/C++那样通过将一个指向函数的指针作为参数而为Sort提供一个callback。C#实现callback的机制是delegate。

5、例子演示了两种callback语法：一种接近于C/C++的pointer points to function的语法；一种是正规的delegate语法。对于C/C++程序员来说，正规的delegate语法非常别扭，这也是C#提供简化语法的原因！

6、注意Sort()内的cmp的调用（invoke）语法：可以直接应用cmp(pList[i-1], pList[i])语法调用callback，也可以用cmp.Invoke(pList[i-1], pList[i])这种正规的delegate调用语法。但这种方式没有前一种方式自然，这也是C#为C/C++程序员简化语法的原因罢。Don Box对这种简化提出了异议：In my opinion, this slight obfuscation adds little to the usability of delegate. -- Don Box, Essential .NET, p.185

7、C++ STL的理念是Program = Algorithm + Data Structure，算法可以应用于任何实现了某种Iterator的Container上，从而实现算法复用。C#中没有全局函数的概念，从而导致算法和数据结构无法分离，如Array有自己的Sort()，List<T>也有自己的Sort()，等等。本例中的Swap<T>就是一个例子，所有的排序算法都需要Swap，所以都需要实现自己的Swap。这种reinvent-the-wheel的工作实在有违generic的精神。

 8、Sort()之所以需要一个callback，是因为Sort本身不知道如何去比较所操作的数据对象（points），这是数据对象自己才能决定的事情，这也是一种专业化分工罢。无论是现实世界还是程序世界，都是work effectively的不二法门。