继承IComparer接口实现Sort(IComparer comparer)排序；继承IComparable接口实现自定义集合类的Sort()排序

如下demo示范了IComparable接口和IComparer接口的实现范例，demo说明如下：

1.利用数组列表的常用成员，实现客户信息类内部的人员信息添加，删除，显示等功能

2.通过将客户信息类（CustomerInfo）继承实现接口IComparable成员，ArrayList集合对象的Sort()功能

3.通过自定义类实现IComparer接口成员，实现对客户信息集合的自定义排序（Sort(IComparer comparer)）

解释下IComparable接口：

.Net的内置结构体如int，bool，double，再比如内置类型string，都实现了IComparable接口，只有实现了该接口，才能对这些数据类型组成的集合利用集合方法Sort()进行排序，那么对于自定义的类型或结构体，如果想要对这些对象组成的集合进行排序，那么这些类或结构体也要实现IComparable接口，所以自定义类或结构需要继承自IComparable接口，然后在结构体或类内部实现接口成员Compare方法，

解释下IComparer接口：

集合的默认排序是调用无参的Sort()方法, 采用元素的IComparable接口所实现的Compare方法进行排序；有参排序方法Sort(IComparer comparer)，可以自定义类实现IComparer接口成员Compare方法，按照自己的需要在Compare方法内元素进行比较大小，从而实现Sort(IComparer comparer)的自定义排序.

如下示例的集合类型是ArrayList，ArrayList集合类定义了的Sort方法重载，如下：

public virtual void Sort();//默认升序排列
public virtual void Sort(IComparer comparer);//通过参数，自定义排序

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyCompareInterfaceDemo
{
    /// <summary>
    /// //定义一个客户信息类
    /// </summary>
    public class CustomerInfo:IComparable
    {
        public string Name { get; set; }
        public int ID { get; set; }
        public string CompanyName { get; set; }
        public CustomerInfo(string name,int ID,string name_company)
        {
            Name = name;
            this.ID = ID;
            CompanyName = name_company;
        }
        public CustomerInfo() { }
        /// <summary>
        /// //定义一个私有的客户信息列表
        /// </summary>
        static ArrayList customers = new ArrayList();

        /// <summary>
        /// //定义一个公共方法Add，逐个添加客户信息
        /// </summary>
        /// <param name="cust"></param>
        public void AddCustomer(CustomerInfo cust)
        {
            customers.Add(cust);
        }
        /// <summary>
        /// //定义一个公共方法，添加一组客户信息
        /// </summary>
        /// <param name="custs"></param>
        public void AddCustomers(params CustomerInfo[] custs)
        {
            customers.AddRange(custs);
        }
        //定义一个公共方法Remove，删除指定的客户信息
        public void RemoveCustomer(CustomerInfo cust)
        {
            int index_cust = customers.IndexOf(cust);
            if (index_cust>0)
            {
                customers.RemoveAt(index_cust);
            }
        }
        public void ShowInfo()
        {
            foreach (CustomerInfo item in customers)
            {
                Console.WriteLine($"{item.ID},{item.Name},{item.CompanyName}");
            }
            Console.ReadKey();
        }
        //将Arraylist按照指定的方式排序
        public void SortByName()
        {
            //public virtual void Sort(IComparer comparer);
            //Sort方法的参数是IComparer对象，需要自己写一个比较类，实现IComaprer接口作为Sort参数
            customers.Sort(new MyCompareClass());
        }

        public void SortbyID()
        {
            //Sort方法对集合进行排序，必须确保集合的每个元素类型都实现了IComparable接口
            //这里集合的元素类型是类CustomerInfo，所以要在这个类种实现IComparable接口
            //1.类CustomerInfo继承IComparable接口；2.CustomerInfo类中实现IComparable接口的成员
            customers.Sort();
        }
        /// <summary>
        /// 升序排列
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int CompareTo (object obj) => this.ID.CompareTo((obj as CustomerInfo).ID);
        /// <summary>
        /// 降序排列
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        //public int CompareTo(object obj) => (obj as CustomerInfo).ID.CompareTo(this.ID);

    }
    /// <summary>
    /// 自定义一个Compare类，实现IComparer接口，即实现该接口的Compare方法int Compare(object x, object y)
    /// </summary>
    public class MyCompareClass:IComparer
    {
        //public interface IComparer
        //{
        //    int Compare(object x, object y);
        //}
        public int Compare(object cust1,object cust2)
        {
            return (cust1 as CustomerInfo).Name.CompareTo((cust2 as CustomerInfo).Name);
        }
    }
}

在Main()方法中实例化若干个客户信息对象，添加到集合中，并通过集合默认的Sort()方法和集合自定义的Sort方法（IComparer comparer），实现客户信息的排序，如下代码：

    class Program
    {
        static void Main(string[] args)
        {
            CustomerInfo cust1 = new CustomerInfo("XiaoSheng", 1, "ASUS");
            CustomerInfo cust2 = new CustomerInfo("DaWang", 2, "CURTIS");
            CustomerInfo cust3 = new CustomerInfo("XiaoWang", 3, "SND YIZHONG");
            CustomerInfo cust4 = new CustomerInfo { Name = "ZhangSan", ID = 4, CompanyName = "ASDF" };
            CustomerInfo cust = new CustomerInfo();
            cust.AddCustomer(cust2);
            cust.AddCustomer(cust4);
            cust.AddCustomers(cust3, cust1);
            cust.ShowInfo();
            cust.RemoveCustomer(cust4);
            cust.ShowInfo();
            //cust.SortByName();
            cust.SortbyID();
            cust.ShowInfo();
        }
    }

客户集合默认顺序如下：

2,DaWang,CURTIS
4,ZhangSan,ASDF
3,XiaoWang,SND YIZHONG
1,XiaoSheng,ASUS

删除ID=4的客户后，显示如下：

2,DaWang,CURTIS
3,XiaoWang,SND YIZHONG
1,XiaoSheng,ASUS

按照ID排序后显示如下：
1,XiaoSheng,ASUS
2,DaWang,CURTIS
3,XiaoWang,SND YIZHONG

按照name排序后显示如下：

2,DaWang,CURTIS
1,XiaoSheng,ASUS
3,XiaoWang,SND YIZHONG

如果将以上集合类型ArrayList换成其泛型强类型List<T>, 在List<T>类中也定义了对应的泛型Sort方法，原型如下：

public void Sort();//默认排序，通过元素类型实现的IComparable接口成员实现，来排序
public void Sort(IComparer<T> comparer); //实现泛型接口，自定义排序方式

如下代码实现泛型集合默认排序（IComparable<T>）和自定义排序IComparer<T>

//list通过下表访问元素
List<int> lst = new List<int> { 2, 4, 1 };
lst.Add(-10);
lst.Sort();//升序排列，int实现了IComparable<Int32>接口，集合可以调用sort方法排列元素
lst.Sort(new MyClass());//降序排列，通过参数自定义排序对象实现排列

public class MyClass : IComparer<int>
{
    public int Compare(int x, int y)
    {
         return y.CompareTo(x);
    }
}