现集合类Sort自定义排序

对集合元素进行排序是经常发生的事情，事实上大部分的集合类型都默认实现了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);

在排序使用上，四个Sort是大同小异，唯一不同的是大部分情况下，排序的要求决定了我们不能完全满足于默认排序的情况，因为Framework根本不清楚“你”排序的目的，例如：

BookStore bs = new BookStore
{
    Books = new List<Book> { 
        new Book{ID = 1, Name="你必须知道的.NET", Price=69, PublishDate=DateTime.Parse("2008-3-30")},
        new Book{ID = 2, Name="Silverlight完美征程", Price=75, PublishDate=DateTime.Parse("2009-4-30")},
        new Book{ID =3, Name="博客园精华集", Price=72, PublishDate=DateTime.Parse("2009-5-3")}    
    }
};

实现自定义的排序算法

如果需要对书店的书目进行排序，那么在我们的小示例中至少可以按照书名、书价和出版日期进行排序，因此.NET Framework在设计上为Sort提供了很好的扩展，通常情况下我们需要实现自定义的comparison和comparer，例如：

            // Release : code01, 2009/04/12                    
            // Author  : Anytao, http://www.anytao.com 
            // List    : Protram.cs

            //02 Sort by custom comparison
            bs.Books.Sort((a, b) => { return a.Price.CompareTo(b.Price); });

            foreach (var item in bs.Books)
            {
                Console.WriteLine(string.Format("{0}:{1}, {2}", item.Name, item.Price, item.PublishDate.ToString()));
            }

你看利用Lambda表达式实现一个Custom Comparison是何其简单：

bs.Books.Sort((a, b) => { return a.Price.CompareTo(b.Price); });

输出的结果为：

如果我们实现以出版日期进行排序的Custom Comparison，应该是这样：

bs.Books.Sort((a, b) => { return a.PublishDate.CompareTo(b.PublishDate); });

排序的结果如我所愿：

利用Lamdba表达式实现的Comparison变得非常简单，优雅有度，我们回归复杂将Lamdba表达式解析为匿名方法（Anonymous Method）：

// Release : code01, 2009/04/12                    
// Author  : Anytao, http://www.anytao.com 
// List    : Protram.cs

//03 Sort by custom comparison: Anonymous Method
bs.Books.Sort(delegate(Book a, Book b)
{
    return a.Price.CompareTo(b.Price);
});

如果你对匿名方法还心存芥蒂，那么我们回归Custom Comparison的最本源实现：

// Release : code01, 2009/04/12                    
// Author  : Anytao, http://www.anytao.com 
// List    : BookComparison.cs

public class BookComparison : IComparer<Book>
{
    public int Compare(Book x, Book y)
    {
        return x.Price.CompareTo(y.Price);
    }
}

利用BookComparison 进行比较，

//04 Sort by custom comparison: BookComparison
bs.Books.Sort(new BookComparison().Compare);

输出的结果和bs.Books.Sort((a, b) => { return a.Price.CompareTo(b.Price); });一样，可谓皆大欢喜。

以自定义方式可以实现的更多的控制，例如我们重构BookComparison：

// Release : code01, 2009/04/12                    
// Author  : Anytao, http://www.anytao.com 
// List    : BookComparison.cs

public class BookComparison : IComparer<Book>
{
    private ComparisonType type;

    public BookComparison(ComparisonType type)
    {
        this.type = type;
    }

    public int Compare(Book x, Book y)
    {
        switch (this.type)
        {
            case ComparisonType.Price:
                return x.Price.CompareTo(y.Price);
                break;
            case ComparisonType.PublishDate:
                return x.PublishDate.CompareTo(y.PublishDate);
                break;
            default:
                break;
        }

        return 0;
    }
}

添加一个ComparisonType结构，在BookComparson初始化时决定Comparison的方式：

//04 Sort by custom comparison: BookComparison
bs.Books.Sort(new BookComparison(ComparisonType.PublishDate).Compare);

结论

自定义Comparison为实现更好的Sort控制，提供了很好的扩展机制。在我们的实际应用中，对于例如BookStore这样的具体应用而言，我更推荐以LINQ的OrderBy来实现，例如：

//05 Sort by Linq
var list = from c in bs.Books
           orderby c.PublishDate ascending
           select c;

foreach (var item in list)
{
    Console.WriteLine(string.Format("{0}:{1}, {2}", item.Name, item.Price, item.PublishDate.ToString()));
}

orderby子句可以选择任意的排序条件，同时ascending或者descending控制升序和降序。

何去何从，看官自评。