看到推荐贴， 我也来发一个实体类排序的， 用快速排序法， 可以依据多个字段排序

        /// <summary>

        /// Sort a entity array.

        /// </summary>

        /// <param name="orgArray">Entity array.</param>

        /// <param name="isAsc">Sort order.</param>

        /// <param name="orderBy">

        /// An array of properties names. Must be a property in each of them, 

        /// and the properties comparable. Compare these properties values.

        /// </param>

        public static void Sort(object[] orgArray, bool isAsc,  params string[] orderBy)

        {

            if (orgArray == null || orgArray.Length == 0)

                return;



            sort(orgArray, 0, orgArray.Length, isAsc, orderBy);

        }



        /// <summary>

        /// Quicksort.

        /// </summary>

        /// <param name="orgArray">Entity array.</param>

        /// <param name="low"></param>

        /// <param name="high"></param>

        /// <param name="orderBy">

        /// An array of properties names. Must be a property in each of them, 

        /// and the properties comparable. Compare these properties values.

        /// </param>

        private static void sort(object[] orgArray, int low, int high, bool isAsc, params string[] orderBy)

        {

            int i, j, f;

            object t;

            if (low == high) 

                return;

            if (low == high - 1)

            {

                if ((Compare(orgArray[low] , orgArray[high], orderBy) < 0) == isAsc)

                {

                    t = orgArray[low];

                    orgArray[low] = orgArray[high];

                    orgArray[high] = t;

                }

                return;

            }



            i = low; 

            j = high;

            f =  low;

            while (i != j)

            {

                for (; j != i; j-- )

                {

                    if ((Compare(orgArray[j], orgArray[f], orderBy) < 0) == isAsc)

                    {

                        t = orgArray[j];

                        orgArray[j] = orgArray[f];

                        orgArray[f] = t;

                        f = j;

                        break;

                    }

                }

                if (i == j) break;

                for (; i != j; i++ )

                {

                    if ((Compare(orgArray[i], orgArray[f], orderBy) < 0) == isAsc)

                    {

                        t = orgArray[i];

                        orgArray[i] = orgArray[f];

                        orgArray[f] = t;

                        f = i;

                        break;

                    }

                }

            }

            if (f > low)

                sort(orgArray, low, f - 1, isAsc, orderBy);

            if ( f < high)

                sort(orgArray, f + 1, high, isAsc, orderBy);

        }



        /// <summary>

        /// Compare two object.

        /// </summary>

        /// <param name="a"></param>

        /// <param name="b"></param>

        /// <param name="orderBy">

        /// An array of properties names. Must be a property in each of them, 

        /// and the properties comparable. Compare these properties values.

        /// </param>

        /// <returns>

        /// A 32-bit signed integer that indicates the relative order of the objects

        /// being compared. The return value has these meanings: Value Meaning Less than

        /// zero This instance is less than obj. Zero This instance is equal to obj.

        /// Greater than zero This instance is greater than obj.

        /// </returns>

        private static int Compare(object a, object b, params string[] orderBy)

        {

            Type type = a.GetType();



            PropertyInfo pro = null;

            foreach (string proname in orderBy)

            {

                pro = type.GetProperty(proname);

                if (!pro.GetValue(a, null).Equals(pro.GetValue(b, null)))

                {

                    return ((IComparable)pro.GetValue(a, null)).CompareTo(pro.GetValue(b, null));

                }

                

            }



            return 0;

        }

    }