在实现 IComparable 时，CompareTo 方法如何工作？

Question

我有一堂课：

 public class Customer :IComparable<Customer>
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public int Salary { get; set; }
        }

我也有一个列表：

Customer cust = new Customer() { Id=10,Name="Jack",Salary= 15000};
            Customer cust1 = new Customer() { Id = 10, Name = "Abby", Salary = 5000 };
            Customer cust2 = new Customer() { Id = 10, Name = "Zed", Salary = 152000 };

            List<Customer> CustomerList = new List<Customer>();
            list.Add(cust);
            list.Add(cust1);
            list.Add(cust2);
            CustomerList.Sort();

我明白为什么 list.Sort 对 Customer 不起作用，因为 Customer 类具有三个属性并且它不知道如何对其进行排序。但是，如果我在Customer 类中实现接口IComparable，我就可以按照我想要的任何方式对客户列表进行排序。

public class Customer :IComparable<Customer>
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public int Salary { get; set; }

            public int CompareTo(Customer other)
            {
                return this.Salary.CompareTo(other.Salary);
            }            
        }

现在我的问题是.. 实现 CompareTo 方法如何让我对CustomerList 进行排序？我什至没有覆盖排序方法或任何东西。 我很困惑，因为我根本没有使用 CompareTo 方法。

我阅读了https://stackoverflow.com/a/4188041/2064292，但它没有回答我的问题。

Answer 1

当你实现IComparable<T>，创建一个public int CompareTo(T) 方法时，你实际上是在告诉排序机制，它在别处定义，如何通过比较来对你的类的两个实例进行排序一个实例到另一个实例。

就像我说的，实际的排序机制是在别处定义的，例如List<T>.Sort()。无论排序机制使用哪种算法——bubble sort、quick sort 等——都无关紧要，但它们都需要一遍又一遍地比较实例以产生排序结果。每次比较两个实例时，都会调用您的 public int CompareTo(T) 方法实现，因为这是您定义如何将您的具体实现相互比较以产生排序结果的地方。

Answer 2

虽然有很多不同的排序算法，但它们都归结为同一件事：

四处移动，使“较低”的项目排在“较高”的项目之前。

因此，所有排序都需要能够理解他们正在排序的对象的“较低”和“较高”。

数字很简单；例如3 < 4 是 true，因为 3 低于 4。即使只有数字，我们也必须为int、long、decimal、double 等编写不同的排序算法，因为我们不能在这里使用泛型（< 等运算符是不能通过泛型获得），当然不能在object 上使用<。

因此我们需要定义一些机制，通过该机制 .NET 可以为各种数字以及字符串等提供默认的“较低”和“较高”逻辑。

我们也不能对我们不知道的类型进行任何排序，所以我们再次需要这种机制来知道哪个是“低”，哪个是“高”。

IComaprable<T> 和 IComparable 这样做。

我们还有 IComparer<T> 和 IComparer 允许我们定义自定义订单（例如，对区分大小写和不区分大小写的搜索具有不同的逻辑）或允许某人为不区分大小写的类型提供订单'不实现IComparer。

排序通常是这样的：

1. 如果我们传递了一个IComparer<T> 对象，使用它来决定哪个更低或更高。

2. 如果我们没有通过IComparer<T>，那么使用Comparer<T>.Default。

使用Comparer<T>.Default 意味着当我们没有IComparer<T> 时，我们不需要单独排序，我们只使用默认值。

现在，Comparer<T>.Default 的工作方式如下：

1. 如果类型实现了IComparable<T>，则调用它。

2. 否则，如果该类型实现了IComparable（泛型之前的旧接口），则使用它。

3. 否则抛出异常，因为无法知道如何订购任何东西。

Answer 3

CustomerList 是具有泛型类型参数 Customer 的泛型 List。 Sort() 方法的排序算法实现是由 Generic List 提供的，通过查看 Microsoft 文档here，您可以看到实际上根据列表的大小使用了三种算法：

• 如果分区大小少于 16 个元素，则使用插入 排序算法。
• 如果分区数超过2 * LogN，其中N 是输入数组的范围，它使用堆排序算法。
• 否则，它使用快速排序算法。

这些算法都依赖于您对 IComparable 的实现，以便 Customer 类知道如何订购您的客户对象。

Answer 4

在 List.Sort() 的代码中，它将是

• 将每个对象转换为 IComparable，
• 使用该接口调用 CompareTo()，
• 该调用的结果决定了排序顺序。

例如：

// Sorts a list using IComparable<T>
public static void Sort(this List<T> list)
{
   // Worst sorting algorithm ever
   for (int i = 0; i < list.Count; ++i)
   {
      for (int j = 0; j < list.Count; ++j)
      {
          // Assumes that type T implements IComparable<T>
          IComparable<T> first  = (list[i] as IComparable<T>);
          IComparable<T> second = (list[j] as IComparable<T>);

          if (first.CompareTo(second) > 0)
          {
              // wrong order
              Swap(list, i, j);
          }
      }
   }
}