近日，在工作的時候遇到要對一個大的List<T>集合進行排序，於是就瞭解下各種List<T>的排序方法。

首先,排序自然就會想到用Sort方法，看看List<T>的Sort方法各個過載版本：

public void Sort();
public void Sort(Comparison<T> comparison);
public void Sort(IComparer<T> comparer);
public void Sort(int index, int count, IComparer<T> comparer);

1：Sort()方法,摘要：使用預設比較器對整個 System.Collections.Generic.List<T> 中的元素進行排序,這裡的預設比較器就是指Comparer<T>.Default。要使用預設比較器來排序，則類必須實現IComparable<T>介面，排序的時候會呼叫介面的CompareTo方法。

接下來，就定義一個測試類Article，實現IComparable<Article>介面，排序先按SortIndex排序，再按Comments排序。類的定義如下：

public class Article : IComparable<Article>
    {
        public string Title { get; set; }
        public int Comments { get; set; }
        public int SortIndex { get; set; }

        public override string ToString()
        {
            return string.Format("文章：{0}，評論次數:{1}", this.Title, this.Comments);
        }
        
        public int CompareTo(Article other)
        {
            if (other == null)
                return 1;
            int value = this.SortIndex - other.SortIndex;
            if (value == 0)
                value = this.Comments - other.Comments;
            return value;
        }
    }

定義一個獲取100萬的Article集合的方法，Article的SortIndex，Comments都是隨機生成的。實現程式碼如下：

 private static List<Article> GetArticleList()
        {
            List<Article> source = new List<Article>();
            Article article = null;
            var random = new Random(DateTime.Now.Millisecond);
            for (int i = 1000000; i > 0; i--)
            {
                article = new Article()
                {
                    Title = "文章" + i.ToString(),
                    Comments = random.Next(),
                    SortIndex = random.Next()
                };
                source.Add(article);
            }
            return source;
        }

執行Sort方法排序：

private static void SortByDefaultComparer()
        {
            List<Article> list = GetArticleList();
            list.Sort();
        }

2：使用Comparison委託

Comparison委託的定義如下：public delegate int Comparison<in T>(T x, T y);

使用委託，可以傳遞一個與委託簽名相同的函式，可以使用匿名委託，還可以用Lambda表示式：

首先使用第一種方法:定義一個ArticleComparison類，在裡面定義一個Compare方法，函式簽名與Comparison委託保持一致。實現程式碼如下：

public class ArticleComparison
    {
        public int Compare(Article x, Article y)
        {
            if (x == null)
            {
                if (y == null)
                    return 0;
                else
                    return -1;
            }
            else
            {
                if (y == null)
                {
                    return 1;
                }
                else
                {
                    int value = x.SortIndex.CompareTo(y.SortIndex);
                    if (value == 0)
                        value = x.Comments.CompareTo(y.Comments);
                    return value;
                }
            }
        }
    }

//方法呼叫
private static void SortByComparison()
        {
            List<Article> list = GetArticleList();
            list.Sort(new Comparison<Article>(new ArticleComparison().Compare));
        }

接下來，使用Lambda表示式，實現程式碼如下：

 private static void SortByLambda()
        {
            List<Article> list = GetArticleList();
            list.Sort((x, y) =>
            {
                int value = x.SortIndex.CompareTo(y.SortIndex);
                if (value == 0)
                    value = x.Comments.CompareTo(y.Comments);
                return value;
            });
        }

3：使用自定義的IComparer來排序，這裡自定義一個ArticleCompare類：實現程式碼如下：

 public class ArticleCompare : IComparer<Article>
    {
        public int Compare(Article x, Article y)
        {
            if (x == null)
            {
                if (y == null)
                    return 0;
                else
                    return -1;
            }
            else
            {
                if (y == null)
                {
                    return 1;
                }
                else
                {
                    int value = x.SortIndex.CompareTo(y.SortIndex);
                    if (value == 0)
                        value = x.Comments.CompareTo(y.Comments);
                    return value;
                }
            }
        }
    }
//方法呼叫
private static void SortByCustomerComparer()
        {
            List<Article> list = GetArticleList();
            list.Sort(new ArticleCompare());
        }

4：最後一個函式過載，就是指定對那些元素進行排序。

小結：

Sort<T>方法的各個過載版本，最終呼叫的都是Array.Sort<T>(T[] array, int index, int length, IComparer<T> comparer)方法。

使用Comparison委託的時候，會執行IComparer<T> comparer = new Array.FunctorComparer<T>(comparison),最終轉換為IComparer，因此在效能上會打點折扣。

5：使用LINQ排序，實現程式碼如下：

private static void SortByLinq()
        {
            List<Article> list = GetArticleList();
            var sortedList =
               (from a in list
                orderby a.SortIndex, a.Comments
                select a).ToList();
        }

6：使用擴充套件方法OrderBy，OrderByDescending，實現程式碼如下：

private static void SortByExtensionMethod()
        {
            List<Article> list = GetArticleList();
            var sortedList = list.OrderBy(a => a.SortIndex).ThenBy(a => a.Comments);
            sortedList.ToList(); //這個時候會排序
        }

疑惑：讓我覺得奇怪的是，用擴充套件方法，排序的效率竟然會快的驚人。我看了擴充套件方法的實現如下：

public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
    return new OrderedEnumerable<TSource, TKey>(source, keySelector, null, false);
}

返回的是一個新的OrderedEnumerable<TSource, TKey>物件,OrderedEnumerable<>的構造方法如下：

OrderedEnumerable(IEnumerable<TElement> source, Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);

看了實現程式碼，從常理來說是不可能快過Array.Sort<T>方法。只能留下疑惑。希望高人解答！

此外，還有其他的排序方法，也請告知！