IComparer<T> VS IComparable<T>

IComparer<T> VS IComparable<T>两者的比较其实是如何实现对象的custom sort 和default sort的过程。微软的MSDN上有一个sample很好的说明了这二者的区别与联系。

//Main 函数：

 
// Nested class to do descending sort on year property.

private class sortYearDescendingHelper :IComparer<Car>

{

      int IComparer<Car>.Compare(Car a, Car b)

     {

           if (a.year < b.year)

               return 1;

           if (a.year > b.year)

              return -1;

           else

           return 0;

     } 

}

 

class Host

 {

        static void Main(string[] args)

         {

            // Create an arary of Car objects.     

             Car[] arrayOfCars =newCar[6]

            {

                   newCar("Ford",1992),        

                   newCar("Fiat",1988),

                   newCar("Buick",1932),         

                   newCar("Ford",1932),

                   newCar("Dodge",1999),       

                   newCar("Honda",1977)

            };

 

        // Write out a header for the output.

        Console.WriteLine("Array - Unsorted\n");

           foreach (Car cin 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.

        //类Car 通过嵌套类提供了几种其它方式的sort。通常情况下这些自定义排序要放在client端，因为

        //server端通常无法精确确定客户端的要求。

        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 cin arrayOfCars)

                Console.WriteLine(c.Make +"\t\t" + c.Year);

 

         // Demo descending sort of numeric value using IComparer.

        IComparer<Car> cpr = new sortYearDescendingHelper();
        Array.Sort(arrayOfCars, cpr);          

           Console.WriteLine("\nArray - Sorted by Year (Descending - IComparer)\n");

           foreach (Car c in arrayOfCars)

                 Console.WriteLine(c.Make +"\t\t" + c.Year);

 

        Console.ReadLine();

        }

}

//Car

 

public class Car :IComparable<Car>

 {

        

// Beginning of nested classes.

 

// Nested class to do ascending sort on year property.

     private class sortYearAscendingHelper :IComparer<Car>

 

    {

            int IComparer<Car>.Compare(Car a, Car b)

            {

                if (a.year > b.year)

                   return 1;

                    if (a.year < b.year)

                          return -1;

                else

                   return 0;

            }

     }

        

// Nested class to do descending sort on make property.

   private class sortMakeDescendingHelper :IComparer<Car>

    {

        int IComparer<Car>.Compare(Car a, Car b)

        {

             returnString.Compare(b.make, a.make);

         }

   }

        

// End of nested classes.

 

privateint year;

privatestring make;

 

        

   public Car(string Make, int Year)

   {

            make = Make;

            year = Year;

    }

        

    publicint 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<Car>.CompareTo(Car other)

    {

            return String.Compare(this.make, other.make);

   }

        

   int CompareTo(Car other)

   {         

           returnString.Compare(this.make, other.make);

   }

        

// Method to return IComparer object for sort helper.    

   public static IComparer<Car> sortYearAscending()

   {          

         return (IComparer<Car>)newsortYearAscendingHelper();

  }

        

// Method to return IComparer object for sort helper.      

 public static IComparer<Car> sortYearDescending()

   {        

         return (IComparer<Car>)newsortYearDescendingHelper();

   }

}