泛型排序

ASP.NET 2.0  泛型

介绍了两个接口的使用: IComparer IComparable 。 这些接口同一文章中讨论有两个原因而定。 经常一起,用于这些接口,并且尽管接口类似 (并具有类似名称),它们用途不同。

如果数组类型 (如 字符串 整数 ) 已支持 IComparer 可以不提供任何显式引用为 IComparer 排序数组。 在这种情况下该数组的元素会转换为 IComparer ( Comparer.Default ) 的默认实现,为您。 但是,如果想要为自定义的对象提供进行排序或比较功能,必须实现一个或两这些接口。

本文中引用以下.NET Framework 类库命名空间:

System.Collections

 

 

IComparable

IComparable 的作用是提供比较特定类型的两个对象的方法。 这是必需如果您想要为对象提供任何排序功能。 视为 IComparable 提供对象的默认排序顺序。 例如,如果您有您的类型的对象的数组,并且该阵列上调用 Sort 方法, IComparable 排序期间提供对象的比较结果。 在实现 IComparable 接口时, 必须实现该 CompareTo 方法,如下所示:

// Implement IComparable CompareTo method - provide default sort order.
int IComparable.CompareTo(object obj)
{
   car c=(car)obj;
   return String.Compare(this.make,c.make);

}
				

方法中的程序比较是正在比较的值的数据类型 depending on 不同。 由于所选择用于比较属性是字符串,此示例中使用 String.Compare

 

IComparer

IComparer 的作用是提供其他比较机制。 是例如可能要提供对多个字段或属性,类的顺序升序和降序相同的字段或两者的顺序。

使用 IComparer 是两步过程。 首先,声明一个实现 IComparer ,类,然后实现 Compare 方法:

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;
   }
}
				

根据值是否大于、 等于,或小于另返回 IComparer.Compare 方法需要第三个比较 1、 0 或-1 的说明。。 可以通过在此方法切换逻辑运算符更改排序顺序 (升序或降序)。

第二步是声明返回您 IComparer 对象的实例的方法:

public static IComparer sortYearAscending()
{      
   return (IComparer) new sortYearAscendingHelper();
}
				

在本示例中,该对象用于为第二个参数调用重载的 方法时接受 IComparer 。 使用 IComparer 不限于使用数组。 它将被接受作为参数在许多不同的集合和控件类。

 

分步示例

下面的示例演示这些接口的使用。 为了说明 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
    					

 

 

posted @ 2009-06-01 22:29  jackyong  阅读(649)  评论(1编辑  收藏  举报