ICompare接口、Sort()方法

一、接口中的方法並不實現具體功能，繼承於該接口的類必須實現具體功能。

核心思想：對修改封閉，對擴展開放。

 二、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);

             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;　　　　　　　     //調用了C#中封裝的類，詳情見下一篇
            return String.Compare(this.make, c.make);
        }

       　　　　　//由於這裏使用了嵌套類，把嵌套類包裹到方法中方便調用（類名.方法名）
        public static IComparer sortYearAscending()
        {　　　　　　　     //調用了上面的類
            return (IComparer)new sortYearAscendingHelper();
        }

      
        public static IComparer sortYearDescending()
        {　　　　　　　   //調用了上面的類
            return (IComparer)new sortYearDescendingHelper();
        }

      
        public static IComparer sortMakeDescending()
        {　　　　　　　     //調用了上面的類
            return (IComparer)new sortMakeDescendingHelper();
        }

    }
}