文章/答案/技术大牛

发布

社区首页 >专栏 >基于业务对象(列表)的排序

基于业务对象(列表)的排序

张子阳

发布于 2018-09-30 02:20:24

2.3K0

文章被收录于专栏：分布式系统和大数据处理分布式系统和大数据处理

基于业务对象(列表)的排序

2008-3-21 作者: 张子阳分类: 设计与模式

引言

在上一篇文章基于业务对象的筛选中，我们讨论了如何实现Predicate<T>(T object)委托，自定义DateFilter 类来对业务对象进行筛选。与筛选一样，排序也是常见且重要的操作。在对业务对象进行排序时，不能使用ObjectDataSource作为数据源，因为它只对 DataView、DataTable 和 DataSet 支持自动排序。但你仍可以对GridView编写Sorting事件的处理方法，通过拼装SQL语句，使用“Order By”子句来完成排序。

和进行筛选的思路一样，如果我们将业务对象缓存在服务器上，第一次访问时从数据库提取数据，然后进行缓存，后继的请求只针对缓存了的业务对象进行，则可以降低对数据库的依赖，提高效率。本文将讨论如何对获取的业务对象进行排序，包括简单排序、任意列排序、以及多列复合排序。

本文是接着上一篇写的，一些重复的内容本文将不再讲述，建议先阅读基于业务对象的筛选。

简单排序 - 对固定属性的默认排序

与上篇文章不同，我不再说明使用拼装SQL来完成排序的方式，我们直接看基于List<Order>对象的排序。我们知道List<T>提供了Sort()方法来进行排序操作，那么它又如何使用呢？我们先创建一个ObjSort.aspx文件，然后在代码后置中添加如下代码：

protected void Page_Load(object sender, EventArgs e)
 {
     Label lb1 = new Label(); 

     List<int> list = new List<int>();
     list.Add(4);
     list.Add(5);
     list.Add(2);
     list.Add(9);
     list.Add(1);

     foreach (int item in list) {
        lb1.Text += item.ToString() + ", ";
     }

     form1.Controls.Add(lb1);
     HtmlGenericControl hr = new HtmlGenericControl("hr");
     form1.Controls.Add(hr);

     Label lb2 = new Label();
     list.Sort();     // 对列表进行排序
     foreach (int item in list) {
        lb2.Text += item.ToString() + ", ";
     }
     form1.Controls.Add(lb2);
 }

可以看到，通过在List<int>上使用Sort()方法，对列表中的元素进行了排序。现在我们在OrderManager.cs中新添一个方法GetSortList()，它用于获取列表对象，因为GetList()方法返回的记录数太多，而在本文中我们仅关注排序，所以我们仅返回15条记录。

// 获取用于排序的列表
public static List<Order> GetSortList() {

    List<Order> list = HttpContext.Current.Cache["sortList"] as List<Order>;

    if (list == null) {
       list = GetList("Select Top 15 OrderId, CustomerId, ShipCountry, OrderDate From Orders");
       HttpContext.Current.Cache.Insert("sortList", list);
    }

    return list;
}

如果你没有看上一篇文章，那么只要知道这个方法返回一个List<Order>类型的业务对象，代表一个订单列表就可以了(Order对象包含四个公共属性，分别是OrderId, CustomerId, OrderDate, Country)。然后我们创建 ObjSort2.aspx文件，在它上面拖放一个Reperter控件，并编写一些代码，用于显示一个表格：

<asp:Repeater runat="server" ID="rpOrderList" >
    <HeaderTemplate>
     <table>
        <tr>
            <th>
               <asp:LinkButton ID="lbtOrderId" runat="server">OrderId</asp:LinkButton>
            </th>
            <th>
               <asp:LinkButton ID="lbtCustomerId" runat="server">CustomerId</asp:LinkButton>
            </th>
            <th>
               <asp:LinkButton ID="lbtOrderDate" runat="server">OrderDate</asp:LinkButton>
            </th>
             <th>
                <asp:LinkButton ID="lbtCountry" runat="server">Country</asp:LinkButton>
            </th>
        </tr>
    </HeaderTemplate>
    <ItemTemplate>
        <tr>
            <td><%#Eval("OrderId") %></td>
            <td><%#Eval("CustomerId") %></td>
            <td><%#Eval("OrderDate") %></td>
             <td><%#Eval("Country") %></td>
        </tr>
    </ItemTemplate>       
    <FooterTemplate>      
     </table>
    </FooterTemplate>     
 </asp:Repeater>

然后，我们在后置代码ObjSort2.aspx.cs的Page_Load事件中，添加这样两行语句：

rpOrderList.DataSource = OrderManager.GetSortList();
rpOrderList.DataBind();

然后再打开页面，可以看到在页面上输出了列表。现在我们想对这个列表进行排序，那么我们仿照List<int>的做法，修改上面的代码：

List<Order> list = OrderManager.GetSortList();
list.Sort();    // 期望可以进行排序
rpOrderList.DataSource = list;
rpOrderList.DataBind();

实际上，我们会得到错误：必须至少有一个对象实现 IComparable。

IComparable<T>接口

我们就是自己想也应该想到为什么会出错：Order对象包含了四个属性OrderId、CustomerId、OrderDate、Country，而int只有它本身的值，所以，当我们在List<Order>上调用Sort()的时候，列表对象根本不知道应该如何排序，也不知道以哪个属性来进行排序。而IComparable接口，定义了如何进行排序的规则，如果我们想要对List<Order>对象进行排序，那么我们就需要让列表的元素，也就是Order对象实现这个接口。实际上，List<int>之所以可以直接调用Sort()方法，是因为int，以及几乎全部的基本类型(比如string,char,datetime等)，本身就实现了IComparable<T>。

public interface IComparable<T> {
    int CompareTo(T other);
}

这个接口只需要实现一个方法，CompareTo()，它传递与要比较的对象(列表中的当前对象)同类型的另一个对象 other，返回一个int类型的值：小于零当前对象小于 other 参数。零此对象等于 other。大于零当前对象大于 other。

现在我们让Order对象(Order参见下载的代码)实现这个接口：

// 实现 IComparable<T> 接口 
public int CompareTo(Order other) { 
    return this.CustomerId.CompareTo(other.CustomerId); 
}

我们将排序的规则委托给了CustomerId去处理，因为CustomerId是一个string类型，调用了它的CompareTo()方法。这样，在List<Order>上调用Sort()的时候就会依据这里定义的规则，以CustomerId进行排序了。再次打开ObjSort.aspx，应该可以看到列表按CustomerId进行了排序。

高级排序 - 多个属性组合排序

IComparer<T> 接口

上面仅仅是为列表提供了一个默认排序，实际上，我们经常要求对多个列进行排序，我们还会要求按降序或者升序进行排序，我们甚至会要求对多个列的组合进行排序，比如：先对CustomerId进行升序排列，再对OrderDate降序排列。此时虽然使用CompareTo(Order other)也可以实现，但是要给Order对象添加额外的字段或者属性，这些.Net Framewok已经考虑到了，并提供了IComparer<T>接口封装了排序规则，我们可以通过实现这个接口来完成排序。

public interface IComparer<T> { 
    int Compare(T x, T y);
}

IComparer<T>只需要实现一个方法，Compare()它接受两个同一类型的参数，并返回int类型的结果，与IComparable<T>类似，当返回值小于0时，x小于y；等于0时，x等于y；大于0时，x大于y。需要注意的是：这个接口不是要求我们让Order对象实现它，而是要求另外一个对象实现它，比如OrderComparer，而在调用Sort()方法时，将它作为参数传递进去。因为这个OrderComparer只是用于对Order对象进行排序，不能应用于其他对象，所以我们将它声明为Order的嵌套类。

实现 IComparer<T>接口

打开Order.cs文件，对它进行如下修改，先添加一个枚举SortDirection，用于表示排序的方向：

// 可复用的枚举，表示排序的方向 
public enum SortDirection { 
    Ascending = 0, 
    Descending 
}

在Order类的内部，添加一个枚举，这个枚举类型代表了可以进行排序的属性：

// 嵌套枚举，仅应用于此业务对象，可排序的属性
public enum SortField {
    OrderId,
    CustomerId,
    OrderDate,
    Country
}

我们还需要再定义一个结构Sorter，这个结构包含两个字段，一个SortDirection类型，一个SortField类型，它封装了排序的必要信息：对于哪个属性按照哪种方式(升序或降序)排序。由于这个结构依然是只针对Order对象的，所以我们还是把它定义在Order内部：

// 嵌套结构，仅应用于此业务对象，排序的属性和方式
public struct Sorter {
    public SortField field;
    public SortDirection direction;

    public Sorter(SortField field, SortDirection direction) {
       this.field = field;
       this.direction = direction;
    }

    public Sorter(SortField field) {
       this.field = field;
       this.direction = SortDirection.Ascending;
    }
}

接着，我们在Order内部定义实现IComparer<T>的类OrderComparer：

// 嵌套类，仅对于此业务对象进行排序 
public class OrderComparer : IComparer<Order> { 

}

现在考虑如何实现它：因为我们要实现对某个属性，按某种方式排序，那么我们至少要将这两个参数传进去，所以OrderCompare应该包含字段用于维护SortDirection和SortField；因为我们期望可以对多个属性组合排序，所以应该维护一个它们的列表，而SortDirection和SortFiled，已经包含在了Sorter结构中，所以它只要维护一个List<Sorter>结构就可以了：

public class OrderComparer : IComparer<Order> {
    private List<Sorter> list;
    // 构造函数，设定排序字段列表
    public OrderComparer(List<Sorter> list) {
        this.list = list;
    }
}

接着考虑如何排序，先从简单入手，我们不考虑对于多个属性的排序，只对某个属性按某种方式排序，那么我们需要添加一个方法CompareTo()，它接受排序的属性、排序的方式，以及排序的两个对象，最后返回int类型，说明这两个对象的大小(位置的先后)：

// 对单个属性按某种方式进行排序
public int Compare(Order x, Order y, SortField field, SortDirection direction) {
    int result = 0;          // 默认排序位置不变化

    switch (field) {
       case SortField.Country:
           if (direction == SortDirection.Ascending)
              result = x.Country.CompareTo(y.Country);
           else
              result = y.Country.CompareTo(x.Country);
           break;
       case SortField.CustomerId:
           if (direction == SortDirection.Ascending)
              result = x.CustomerId.CompareTo(y.CustomerId);
           else
              result = y.CustomerId.CompareTo(x.CustomerId);
           break;
       case SortField.OrderDate:
           if (direction == SortDirection.Ascending)
              result = x.OrderDate.CompareTo(y.OrderDate);
           else
              result = y.OrderDate.CompareTo(x.OrderDate);
           break;
       case SortField.OrderId:
           if (direction == SortDirection.Ascending)
              result = x.OrderId.CompareTo(y.OrderId);
           else
              result = y.OrderId.CompareTo(x.OrderId);
           break;
    }

    return result;
}

但是这个方法不会实现IComparer<T>接口，也没有办法进行多个列的排序。继续进行之前，我们考虑下如何对两个对象的多个属性(比如A、B、C)来进行排序：先对属性A进行比较，如果属性A相同，继续比较属性B，如果属性B相同，继续比较属性C。在这个过程中，只要有任意一个属性不相同，就可以决定两个对象的先后顺序，也就是不再进行后面属性的比较。

有了思路，我们现在实现IComparer<T>接口，编写方法

// 实现 IComparer接口
public int Compare(Order x, Order y) {
    int result = 0;
    foreach (Sorter item in list) {
       result = Compare(x, y, item.field, item.direction);
       if (result != 0)      // 一旦result不为0，则已经区分出位置大小，跳出循环
           break;
    }

    return result;
}

在这个方法中，我们遍历了List<Sorter>，并且在foreach语句中调用了我们前面定义的对单个属性的比较方法Compare(Order x, Order y, SortField field, SortDirection direction)，一旦比较结果不为0，那么就跳出循环。

好了OrderComparer类的实现已经完成了，我们再看下还有什么可以完善的地方：如果以后每次调用Sort进行排序的时候，都要先需要先创建列表，指定排序规则，构造OrderCompare对象，显然会很麻烦，所以我们给在Book类中添加一组重载了的方法GetComparer()，用来简化以后调用时的操作步骤：

// 指定排序属性 和 排序方式
public static OrderComparer GetComparer(SortField field, SortDirection direction) {
    List<Sorter> list = new List<Sorter>();
    Sorter sorter = new Sorter(field, direction);
    list.Add(sorter);
    return new OrderComparer(list);
}

// 指定排序属性，默认为升序
public static OrderComparer GetComparer(SortField field) {
    return new OrderComparer(field, SortDirection.Ascending);
}

// 默认为以OrderId升序排列
public static OrderComparer GetComparer() {
    return new OrderComparer(SortField.OrderId, SortDirection.Ascending);
}

// 排序列表
public static OrderComparer GetComparer(List<Sorter> list) {
    return new OrderComparer(list);
}

好了，现在OrderComparer类就全部创建好了，我们接下来看一下如何使用它：

页面调用

我们修改一下代码后置文件，来看下如何进行设置，我们将Sort()改成这样：

list.Sort(Order.GetComparer(Order.SortField.Country, SortDirection.Descending)); // 以Country倒序排列

然后查看页面，发现列表以Country属性进行了倒序排列。那如果我们想先按Country倒序排列，再按CustomerId顺序排列，又该如何呢？

// 以Country降序, CustomerId升序排列
List<Order.Sorter> sorterList = new List<Order.Sorter>(); //先创建sorterList
sorterList.Add(new Order.Sorter(Order.SortField.Country, SortDirection.Descending));     // 先以Country Desc排序
sorterList.Add(new Order.Sorter(Order.SortField.CustomerId));//再以CustomerId Asc
list.Sort(Order.GetComparer(sorterList));

现在打开页面，可以看到列表以我们期望的方式进行了排序。在本文中，由于仅仅是出于示范的目的，所以我们在代码中直接书写了用于排序的SortList，实际上这些应该是基于用户选择而动态创建的。在ObjSort2.aspx页面上，表格的标题我使用了LinkButton，有兴趣的话可以编写LinkButton的Click事件，来动态地实现这一排序过程。