C#中List的排序用法(Sort)

 今天在网上找了些资料觉得挺有用就收集到博客上来了。

要对自定义类数组或List进行排序，譬如：

List<User> userList;

ArrayList arrayList;

最重要的是：继承IComparer<T>接口，实现int IComparer<T>.Compare(T t1, T t2)方法。

代码如下：

 

     /// <summary>
    /// 继承IComparer<T>接口，实现同一自定义类型　对象比较
    /// </summary>
    /// <typeparam name="T">T为泛用类型</typeparam>
     public  class  Reverser < T >  : IComparer < T >
     {
         private  Type type  =  null ;
         private  ReverserInfo info;

         ///  <summary>
         ///  构造函数
         ///  </summary>
         ///  <param name="type"> 进行比较的类类型 </param>
         ///  <param name="name"> 进行比较对象的属性名称 </param>
         ///  <param name="direction"> 比较方向(升序/降序) </param>
         public  Reverser(Type type,  string  name, ReverserInfo.Direction direction)
         {
             this .type  =  type;
             this .info.name  =  name;
             if  (direction  !=  ReverserInfo.Direction.ASC)
                 this .info.direction  =  direction;
        }

         ///  <summary>
         ///  构造函数
         ///  </summary>
         ///  <param name="className"> 进行比较的类名称 </param>
         ///  <param name="name"> 进行比较对象的属性名称 </param>
         ///  <param name="direction"> 比较方向(升序/降序) </param>
         public  Reverser( string  className,  string  name, ReverserInfo.Direction direction)  {
             try
             {
                 this .type  =  Type.GetType(className,  true );
                 this .info.name  =  name;
                 this .info.direction  =  direction;
            }
             catch  (Exception e) {
                 throw  new  Exception(e.Message);
            }
        }

         ///  <summary>
         ///  构造函数
         ///  </summary>
         ///  <param name="t"> 进行比较的类型的实例 </param>
         ///  <param name="name"> 进行比较对象的属性名称 </param>
         ///  <param name="direction"> 比较方向(升序/降序) </param>
         public  Reverser(T t,  string  name, ReverserInfo.Direction direction)
         {
             this .type  =  t.GetType();
             this .info.name  =  name;
             this .info.direction  =  direction;
        }

         // 必须！实现IComparer<T>的比较方法。
         int  IComparer < T > .Compare(T t1, T t2)
         {
             object  x  =  this .type.InvokeMember( this .info.name, BindingFlags.Public  |  BindingFlags.Instance  |  BindingFlags.GetProperty,  null , t1,  null );
             object  y  =  this .type.InvokeMember( this .info.name, BindingFlags.Public  |  BindingFlags.Instance  |  BindingFlags.GetProperty,  null , t2,  null );
             if  ( this .info.direction  !=  ReverserInfo.Direction.ASC)
                Swap( ref  x,  ref  y);
             return  ( new  CaseInsensitiveComparer()).Compare(x, y);
        }

         // 交换操作数
         private  void  Swap( ref  object  x,  ref  object  y)
         {
             object  temp  =  null ;
            temp  =  x;
            x  =  y;
            y  =  temp;
        }
    }

     ///  <summary>
     ///  对象比较时使用的信息类
     ///  </summary>
     public  struct  ReverserInfo
     {
         ///  <summary>
         ///  比较的方向，如下：
         ///  ASC：升序
         ///  DESC：降序
         ///  </summary>
         public  enum  Direction
         {
            ASC  =  0 ,
            DESC,
        } ;

         public  enum  Target
         {
            CUSTOMER  =  0 ,
            FORM,
            FIELD,
            SERVER,
        } ;

         public  string  name;
         public  Direction direction;
         public  Target target;
    }

上面主要是运用了 C#的反射 和 Framework中的排序算法。

像上面那样实现接口后，就可以使用List<T>进行 升序/降序 排序了。

测试代码如下：

 

using  System;
using  System.Collections.Generic;
using  System.Collections;
using  System.Reflection;
using  System.Text;

namespace  List_T_SortTest_u_2
{
     #region 测试Reverser<T>代码段

    /**/ <summary>
    /// 实体类User，测试用
    /// </summary>
     public  class  User
     {
        protected string _name;
        protected int _age;
        protected string _address;

        public User(string name, int age, string address)
        {
            this._name = name;
            this._age = age;
            this._address = address;
        }

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public string Address
        {
            get { return _address; }
            set { _address = value; }
        }
    }

     ///  <summary>
     ///  主程序类(启动类)，测试用
     ///  </summary>
     class  Program
     {
         static  void  Main( string [] args)
         {
            List < User >  userList  =  new  List < User > ();
            User user;

            user  =  new  User( " Wang " ,  21 ,  " ShenYang " );
            userList.Add(user);
            user  =  new  User( " Yan " ,  27 ,  " JinZhou " );
            userList.Add(user);
            user  =  new  User( " Liu " ,  26 ,  " BeiJing " );
            userList.Add(user);
            user  =  new  User( " Zhao " ,  30 ,  " ChaoYang " );
            userList.Add(user);
            user  =  new  User( " Yang " ,  27 ,  " FuXin " );
            userList.Add(user);

             // for (int i = 0; i < ar.Count; i++ )
             //     ;
            Console.Write( " Name      " );
            Console.Write( " Age       " );
            Console.Write( " Address   "  +  " "  +  " " );
            Console.WriteLine( " ----------------------- " );
             foreach  (User u  in  userList)
             {
                Console.Write(u.Name  +  "      " );
                Console.Write(u.Age  +  "      " );
                Console.Write(u.Address  +  "      "  +  " " );
            }
            Console.WriteLine();

            Reverser < User >  reverser  =  new  Reverser < User > (user.GetType(),  " Name " , ReverserInfo.Direction.DESC);
            userList.Sort(reverser);
            Console.WriteLine();
             foreach  (User u  in  userList)
             {

                Console.Write(u.Name + "    ");

 

 当然也有简便的方法,比如:

list.Sort(delegate(User x, User y) { return x.Name.CompareTo(y.Name); });

或

list.Sort((x, y) => x.Name.CompareTo(y.Name));