从ArrayList.sort到List.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的功能部分了。激动人心，几乎颠覆传统思想。要抗住，技术几年换一代。所以说要把基础打好（美国当今成熟一代程序员，都是看懂LINUX源代码，算法和基本功很过硬的，所以他们不说别的，新技术到手上，可以很快消化。而作为半路上来做程序员的你，你就要思考了）,废话不说了，开始

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

搞定，呵呵。不用怕，要有开放的编程思想，如果你不能接受，就只能淘汰。写多了js的伪oop或者python ruby,那么自然也就习惯了。写累了。。