IComparer 和 IComparable

    本文分步介绍了两个接口的使用： IComparer 和 IComparable 。 这些接口同一文章中讨论有两个原因而定。 经常一起，用于这些接口，并且尽管接口类似 （并具有类似名称），它们用途不同。
    如果数组类型 （如 字符串 或 整数 ） 已支持 IComparer 可以不提供任何显式引用为 IComparer 排序数组。 在这种情况下该数组的元素会转换为 IComparer ( Comparer.Default ) 的默认实现，为您。 但是，如果想要为自定义的对象提供进行排序或比较功能，必须实现一个或两这些接口。

IComparable

下面的示例演示这些接口的使用。 为了说明 IComparer 和 IComparable ，创建一个名为 汽车 的类。 在 汽车 对象有 使 和 年 属性。 升序排序对于 使 启用域通过该 IComparable 接口和降序排序在 使 通过 IComparer 接口启用了域。 为通过 IComparer 的使用 年度 属性提供了升序和降序排序。

1. 在 Visual C# 中，创建新的控制台应用程序项目。 应用程序 ConsoleEnum 命名。
2. 重命名为 host.cs，Program.cs，，然后将代码替换为下面的代码。
   
   请注意 在 Visual Studio N 重命名为 host.cs 的 Class 1.cs

   using System;
       namespace ConsoleEnum
       {
       class host
       {
       [STAThread]
       static void Main(string[] args)
       {
       // Create an arary of car objects.
       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)
       };
       // Write out a header for the output.
       Console.WriteLine("Array - Unsorted/n");
       foreach(car c in arrayOfCars)
       Console.WriteLine(c.Make + "/t/t" + c.Year);
       // Demo IComparable by sorting array with "default" sort order.
       Array.Sort(arrayOfCars);
       Console.WriteLine("/nArray - Sorted by Make (Ascending - IComparable)/n");
       foreach(car c in arrayOfCars)
       Console.WriteLine(c.Make + "/t/t" + c.Year);
       // Demo ascending sort of numeric value with IComparer.
       Array.Sort(arrayOfCars,car.sortYearAscending());
       Console.WriteLine("/nArray - Sorted by Year (Ascending - IComparer)/n");
       foreach(car c in arrayOfCars)
       Console.WriteLine(c.Make + "/t/t" + c.Year);
       // Demo descending sort of string value with IComparer.
       Array.Sort(arrayOfCars,car.sortMakeDescending());
       Console.WriteLine("/nArray - Sorted by Make (Descending - IComparer)/n");
       foreach(car c in arrayOfCars)
       Console.WriteLine(c.Make + "/t/t" + c.Year);
       // Demo descending sort of numeric value using IComparer.
       Array.Sort(arrayOfCars,car.sortYearDescending());
       Console.WriteLine("/nArray - Sorted by Year (Descending - IComparer)/n");
       foreach(car c in arrayOfCars)
       Console.WriteLine(c.Make + "/t/t" + c.Year);
       Console.ReadLine();
       }
       }
       }
       

3. 将类添加到项目中。 命名类 汽车 。
4. 在 Car.cs 代码替换为下面：

   using System;
       using System.Collections;
       namespace ConsoleEnum
       {
       public class car : IComparable
       {
       // Beginning of nested classes.
       // Nested class to do ascending sort on year property.
       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;
       }
       }
       // Nested class to do descending sort on year property.
       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;
       }
       }
       // Nested class to do descending sort on make property.
       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);
       }
       }
       // End of nested classes.
       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;}
       }
       // Implement IComparable CompareTo to provide default sort order.
       int IComparable.CompareTo(object obj)
       {
       car c=(car)obj;
       return String.Compare(this.make,c.make);
       }
       // Method to return IComparer object for sort helper.
       public static IComparer sortYearAscending()
       {
       return (IComparer) new sortYearAscendingHelper();
       }
       // Method to return IComparer object for sort helper.
       public static IComparer sortYearDescending()
       {
       return (IComparer) new sortYearDescendingHelper();
       }
       // Method to return IComparer object for sort helper.
       public static IComparer sortMakeDescending()
       {
       return (IComparer) new sortMakeDescendingHelper();
       }
       }
       }
       

5. 运行该项目。 下面的输出显示在控制台窗口中：

   Array - Unsorted
       Ford            1992
       Fiat            1988
       Buick           1932
       Ford            1932
       Dodge           1999
       Honda           1977
       Array - Sorted by Make (Ascending - IComparable)
       Buick           1932
       Dodge           1999
       Fiat            1988
       Ford            1932
       Ford            1992
       Honda           1977
       Array - Sorted by Year (Ascending - IComparer)
       Ford            1932
       Buick           1932
       Honda           1977
       Fiat            1988
       Ford            1992
       Dodge           1999
       Array - Sorted by Make (Descending - IComparer)
       Honda           1977
       Ford            1932
       Ford            1992
       Fiat            1988
       Dodge           1999
       Buick           1932
       Array - Sorted by Year (Descending - IComparer)
       Dodge           1999
       Ford            1992
       Fiat            1988
       Honda           1977
       Buick           1932
       Ford            1932