从ArrayList.sort到List<T>.sort看dotnet1.1到dotnet3.5的演变!

     如果要在下面中要你对集合数据进行排序，在dotnet1.1中我们可以使用list.sort，有两种方法，

public void List.Sort();
public void List.Sort(IComparer);

他们的区别在前面我那篇英文的文章中写的很清楚了。在什么情况下用那种，我这里就用文章中说到的第二种。

class Student   
{
     private int age;
     private string name;
     public Student(int age,string name)
     {
        this.age = age;
        this.name = name;
     }
     public int Age
     {
          get
          {
            return age;
          }
          set
          {
            this.age = value;
          }
     }
     public string Name
     {
         get
         {
            return name;
          }
         set
          {
            this.name = value;
          }
      }
}
public class StudentComparer : IComparer
{
       public int Compare(object x, object y)
       {
            Student left = x as Student();
            Student right = y as Student();
            return left.age.CompareTo(right.age);
       }
}

然后使用:

   ArrayList arr = new ArrayList();
   arr.add(new Student(18,"zhang1"));
   arr.add(new Student(17,"zhang1"));
   arr.add(new Student(18,"zhang1"));
   arr.sort(new StudentComparer());

搞定。但我想更灵活点，写个方法让你可以有选择的进行升序和降序

  public void SortByStudentAge(List Student, bool ascending)
  {
      List.sort(new StudentComparer(ascending));
  }

这样就灵活了。但是上面的类还要改。

   public class StudentComparer : IComparer
   {
       private bool ascending;
       public StudentComparer(bool ascending)
       {
           this.ascending = ascending;
       }
       public int Compare(object x, object y)
       {
            Student left = x as Student();
            Student right = y as Student();
            return left.age.CompareTo( right.age ) * ( ascending ? 1 : -1);
       }
   }

好了dotnet1.1版本的实现了，路漫漫其修远兮。有点不想写了，坚持。qq zone真不爽，不支持高亮,我明天去博客园申请个博客。我这代码是qq zone里直接写的，不能完全保证编译通过。
       接下来就到dotnet2.0的功能部分了。激动人心，几乎颠覆传统思想。要抗住，技术几年换一代。废话不说了，开始

public void List<T>.Sort();
public void List<T>.Sort(Comparison<T>);
public void List<T>.Sort(IComparer<T>);
public void List<T>.Sort(Int32, Int32, IComparer<T>);

四个重载，同时都是泛型的。
第一个和第三个重载跟上面说道的dotnet 1.1的那两个一样，只是泛型版本而已。不说了。
现在我主要展示第二个。
我同样实现上面的学生类排序

  class Student   {
     private int age;
     private string name;
     public Student(int age,string name)
     {
        this.age = age;
        this.name = name;
     }
     public int Age
     {
          get
          {
            return age;
          }
          set
          {
            this.age = value;
          }
     }
     public string Name
     {
         get
         {
            return name;
          }
         set
          {
            this.name = value;
          }
      }
   }

这个类不变。照抄。
接下来写排序方法，支持升序和降序
Comparison是个泛型委托，我定义个排序方法给它。

  public static int Compare(Student a, Student b)//在dotnet 2.0这个方法名可以随便
  {
        return (a.Age - b.Age);
  }

  public void SortByStudentAge(List<Student> Student, bool ascending)
  {
      List<Student>.sort(Comparison<Student>(Compare));
  }

 

搞定但是这样还不支持动态切换升序和降序,我必须把ascending,传递给Compare方法，但是它是委托的函数，我不能给它加参数。所以我只能给它定义个类来传递参数。

public class StudentComparer
{
  private bool ascending;
  public StudentComparer(bool ascending)
  { 
   this.ascending = ascending;
  }
    public int Compare(Student a, Student b)//在dotnet 2.0这个方法名可以随便
  {
        return (a.Age - b.Age)*(ascending?1:-1);
  }
}

接下来使用

  public void SortByStudentAge(List<Student> Student, bool ascending)
  {
      StudentComparer stuComp = new StudentComparer(ascending);
      List<Student>.sort(Comparison<Student>(stuComp.Compare));
  }

搞定，但是没实现一种排序就要多写一个类，想死。而且在dotnet2.0 写类仅仅是为了传一个参数而已 。dotnet1.1只能是写类。
     dotnet3.5的写法，那真的是春天来了。体现出动态语言优点和简洁。

   class Student   
   {
     public int Age
     {
       get;set;
     }
     public string Name
     {
       get;set;
     }
   }

接下来就是支持升序和降序的排序了。

public void SortByStudentAge(List<Student> Student, bool ascending)
  {
      List<Student>.sort((a ,b )=>( a.Age - b.Age ) * ( ascending ? 1 : -1)); //Lambda表达式
  }

 

当然，我们还可以用Dotnet3.5的linq实现排序，那更简单更快。

            var list = new List<Student>
            {
                new Student{Age=28,Name="ZHANGSAN"},
                new Student{Age=18,Name="Lisi"},
                new Student{Age=23,Name="Wangwu"}
            };
            var res = list.OrderByDescending(S => S.Age).GetEnumerator();//降序
            //升序 var res = list.OrderBy(S => S.Age).GetEnumerator();
            while (res.MoveNext())
            {
                Console.WriteLine(res.Current.Age + " " + res.Current.Name);
            }

搞定，呵呵。