C#将集合快速排序

C#实现集合排序类。

说明：

1、集合类型参数化；

2、可根据集合中的对象的各个属性进行排序，传入属性名称即可；

注：属性必须实现了IComparable接口，C#中int、datetime、string等基本类型都已经实现了IComparable接口。

  /// <summary>
     /// 对集合进行排序，如
     /// List<User> users=new List<User>(){.......}
     /// ListSorter.SortList<list<User>,User>(ref users,"Name",SortDirection.Ascending);
     /// </summary>
     public class ListSorter
     {
         public static void SortList<TCollection, TItem>(ref TCollection list, string property, SortDirection direction) where TCollection : IList<TItem>
         {
             PropertyInfo[] propertyinfos = typeof(TItem).GetProperties();
             foreach (PropertyInfo propertyinfo in propertyinfos)
             {
                 if (propertyinfo.Name == property)          //取得指定的排序属性
              // http://www.cnblogs.com/sosoft/
                 {
                     QuickSort<TCollection, TItem>(ref list, , list.Count - , propertyinfo, direction);
                 }
             }
         }
         /// <summary>
         /// 快速排序算法
         /// </summary>
         /// <typeparam name="TCollection">集合类型，需要实现Ilist<T>集合</typeparam>
         /// <typeparam name="TItem">集合中对象的类型</typeparam>
         /// <param name="list">集合对象</param>
         /// <param name="left">起始位置，从0开始</param>
         /// <param name="right">终止位置</param>
         /// <param name="propertyinfo">集合中对象的属性，属性必须要实现IComparable接口</param>
         /// <param name="direction">排序类型（升序或降序）</param>
         private static void QuickSort<TCollection, TItem>(ref TCollection list, int left, int right, PropertyInfo propertyinfo, SortDirection direction) where TCollection : IList<TItem>
         {
             if (left < right)
             {
                 int i = left, j = right;
                 TItem key = list[left];
                 while (i < j)
                 {
                     if (direction == SortDirection.Ascending)
                     {
                         while (i < j && ((IComparable)propertyinfo.GetValue(key, null)).CompareTo((IComparable)propertyinfo.GetValue(list[j], null)) < )
                         {
                             j--;
                         }
                         if (i < j)
                         {
                             list[i] = list[j];
                             i++;
                         }

                         while (i < j && ((IComparable)propertyinfo.GetValue(key, null)).CompareTo((IComparable)propertyinfo.GetValue(list[i], null)) > )
                         {
                             i++;
                         }
                         if (i < j)
                         {
                             list[j] = list[i];
                             j--;
                         }
                         list[i] = key;
                     }
                     else
                     {
                         while (i < j && ((IComparable)propertyinfo.GetValue(key, null)).CompareTo((IComparable)propertyinfo.GetValue(list[j], null)) > )
                         {
                             j--;
                         }
                         if (i < j)
                         {
                             list[i] = list[j];
                             i++;
                         }

                         while (i < j && ((IComparable)propertyinfo.GetValue(key, null)).CompareTo((IComparable)propertyinfo.GetValue(list[i], null)) < )
                         {
                             i++;
                         }
                         if (i < j)
                         {
                             list[j] = list[i];
                             j--;
                         }
                         list[i] = key;
                     }
                 }
                 //执行递归调用
                 QuickSort<TCollection, TItem>(ref list, left, i - , propertyinfo, direction);
                 QuickSort<TCollection, TItem>(ref list, i + , right, propertyinfo, direction);
             }
         }
     }
     /// <summary>
     /// 排序类型
     /// </summary>
     public enum SortDirection
     {
         Ascending,
         Descending
     }