ICompare接口、Sort()方法

1、接口中的方法并不实现具体功能，继承于该接口的类必须实现具体功能。

核心思想：对修改封闭，对扩展开放。

2、Sort（）方法：

默认：Sort（内容）

英文：按照首字母顺序排序，首字母相同则看第二个字母；

数字：从小到大排序；

自定义 Sort(内容，排序规则）

内容按照自定义的规则排序。

host类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleEnum
{
    class host
    {
        [STAThread]
        static void Main(string[] args)
        {
            // 创建一个数组，里面放汽车名和年份    
            car[] arrayOfCars = new car[6]
            {
            new car("Ford",1992),
            new car("Fiat",1988),
            new car("Buick",1932),
            new car("Ford",1932),
            new car("Dodge",1999),
            new car("Honda",1977)
            };
 
 
            Console.WriteLine("排序前\n");
            foreach (car c in arrayOfCars)
                Console.WriteLine(c.Make + "\t\t" + c.Year);
 
            Console.WriteLine("\Sort默认正向排序 \n");
            Array.Sort(arrayOfCars);
            foreach (car c in arrayOfCars)
                Console.WriteLine(c.Make + "\t\t" + c.Year);<br>
             Console.WriteLine("\Sort 按年份正向排序 )\n");
            Array.Sort(arrayOfCars, car.sortYearAscending());
            foreach (car c in arrayOfCars)
                Console.WriteLine(c.Make + "\t\t" + c.Year);
 
            Console.WriteLine("\Sort 按汽车名正向排序 \n");
            Array.Sort(arrayOfCars, car.sortMakeDescending());
            foreach (car c in arrayOfCars)
                Console.WriteLine(c.Make + "\t\t" + c.Year);
 
           Console.WriteLine("\Sort 按汽车名反向排序 \n");
            Array.Sort(arrayOfCars, car.sortYearDescending());
            foreach (car c in arrayOfCars)
                Console.WriteLine(c.Make + "\t\t" + c.Year);
 
            Console.ReadLine();
        }
    }
}

Car类

using System;
using System.Collections;
namespace ConsoleEnum
{
    public class car : IComparable
    {
        //  嵌套类：类中的类。
 
        // 按年升序
        private class sortYearAscendingHelper : IComparer
        {
            //实现接口定义的方法
            int IComparer.Compare(object a, object b)
            {
                car c1 = (car)a;
                car c2 = (car)b;
 
                if (c1.year > c2.year)
                    return 1;
 
                if (c1.year < c2.year)
                    return -1;
 
                else
                    return 0;
            }
        }
 
        // 按年降序
        private class sortYearDescendingHelper : IComparer
        {  //实现接口定义的方法
            int IComparer.Compare(object a, object b)
            {
                car c1 = (car)a;
                car c2 = (car)b;
 
                if (c1.year < c2.year)
                    return 1;
 
                if (c1.year > c2.year)
                    return -1;
 
                else
                    return 0;
            }
        }
 
        // 按汽车名字母降序
        private class sortMakeDescendingHelper : IComparer
        {  //实现接口定义的方法
            int IComparer.Compare(object a, object b)
            {
                car c1 = (car)a;
                car c2 = (car)b;
                 
                return String.Compare(c2.make, c1.make);
            }
        }
 
 
 
        private int year;
        private string make;
 
        //构造函数
        public car(string Make, int Year)
        {
            make = Make;
            year = Year;
        }
 
        //属性
        public int Year
        {
            get { return year; }
            set { year = value; }
        }
 
        public string Make
        {
            get { return make; }
            set { make = value; }
        }
 
        // 实现IComparable接口来提供默认的排序顺序的对比。
         public  int IComparable.CompareTo(object obj)
        {
            car c = (car)obj;<br>　　　　　　　     //调用了C#中封装的类，详情见下一篇
            return String.Compare(this.make, c.make);
        }
 
       <br>　　　　　//因为这里使用了嵌套类，把嵌套类包裹到方法中方便调用（类名.方法名）
        public static IComparer sortYearAscending()
        {<br>　　　　　　　     //调用了上面的类
            return (IComparer)new sortYearAscendingHelper();
        }
 
       
        public static IComparer sortYearDescending()
        {<br>　　　　　　　   //调用了上面的类
            return (IComparer)new sortYearDescendingHelper();
        }
 
       
        public static IComparer sortMakeDescending()
        {<br>　　　　　　　     //调用了上面的类
            return (IComparer)new sortMakeDescendingHelper();
        }
 
    }
}