基础查询扩展 - 分页与排序

上一篇介绍了IQueryable的Where方法存在的问题,并扩展了一个名为Filter的过滤方法,它是Where方法的增强版。本篇将介绍查询的另一个重要主题——分页与排序。

对于任何一个信息系统,查询都需要分页,因为不可能直接返回表中的所有数据。

如果直接使用原始的Ado.Net,我们可以编写一个通用分页存储过程来进行分页查询,然后通过一个DataTable返回给业务层。不过进入Entity Framework时代,分页变得异常简单,通过Skip和Take两个方法配合就可以完成任务。

为了让分页查询变得更加简单,我们需要进一步扩展和封装。

先考虑输入参数,表现层需要将一些分页参数传递到应用层,为此我们可以定义一个分页对象来承载和计算分页相关的数据。

在Util.Domains项目的Repositories目录中,创建IPager接口和它的实现类Pager。

IPager接口代码如下。

namespace Util.Domains.Repositories {
    /// <summary>
    /// 分页
    /// </summary>
    public interface IPager {
        /// <summary>
        /// 页数,即第几页,从1开始
        /// </summary>
        int Page { get; set; }
        /// <summary>
        /// 每页显示行数
        /// </summary>
        int PageSize { get; set; }
        /// <summary>
        /// 总行数
        /// </summary>
        int TotalCount { get; set; }
        /// <summary>
        /// 总页数
        /// </summary>
        int PageCount { get; }
        /// <summary>
        /// 跳过的行数
        /// </summary>
        int SkipCount { get; }
        /// <summary>
        /// 排序条件
        /// </summary>
        string Order { get; set; }
    }
}

Pager类代码如下。

namespace Util.Domains.Repositories {
    /// <summary>
    /// 分页
    /// </summary>
    public class Pager : IPager {
        /// <summary>
        /// 初始化分页
        /// </summary>
        public Pager()
            : this( 1 ) {
        }

        /// <summary>
        /// 初始化分页
        /// </summary>
        /// <param name="page">页索引</param>
        /// <param name="pageSize">每页显示行数,默认20</param> 
        /// <param name="totalCount">总行数</param>
        public Pager( int page, int pageSize = 20, int totalCount = 0 ) {
            Page = page;
            PageSize = pageSize;
            TotalCount = totalCount;
        }

        private int _pageIndex;
        /// <summary>
        /// 页索引,即第几页,从1开始
        /// </summary>
        public int Page {
            get {
                if ( _pageIndex <= 0 )
                    _pageIndex = 1;
                return _pageIndex;
            }
            set { _pageIndex = value; }
        }

        /// <summary>
        /// 每页显示行数
        /// </summary>
        public int PageSize { get; set; }

        /// <summary>
        /// 总行数
        /// </summary>
        public int TotalCount { get; set; }

        /// <summary>
        /// 总页数
        /// </summary>
        public int PageCount {
            get {
                if ( TotalCount == 0 )
                    return 0;
                if ( ( TotalCount % PageSize ) == 0 )
                    return TotalCount / PageSize;
                return ( TotalCount / PageSize ) + 1;
            }
        }

        /// <summary>
        /// 跳过的行数
        /// </summary>
        public int SkipCount {
            get {
                if ( Page > PageCount )
                    Page = PageCount;
                return PageSize * ( Page - 1 );
            }
        }

        /// <summary>
        /// 排序条件
        /// </summary>
        public string Order { get; set; }
    }
}

我将排序条件Order也打包到IPager接口中,这是因为排序与分页密切相关,甚至在调用Skip方法之前,.Net强制要求设置排序条件。

在调用Skip方法时需要计算出跳过的行数,SkipCount提供了这个功能。

由于客户端可能传递错误的分页参数,所以需要在Pager中进行修正。

PagerTest单元测试代码如下。

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Util.Domains.Repositories;

namespace Util.Domains.Tests.Repositories {
    /// <summary>
    /// 分页测试
    /// </summary>
    [TestClass]
    public class PagerTest {

        #region 测试初始化

        /// <summary>
        /// 分页
        /// </summary>
        private Pager _pager;

        /// <summary>
        /// 测试初始化
        /// </summary>
        [TestInitialize]
        public void TestInit() {
            _pager = new Pager();
        }

        #endregion

        #region 默认值

        /// <summary>
        /// 分页默认值
        /// </summary>
        [TestMethod]
        public void Test_Default() {
            Assert.AreEqual( 1, _pager.Page );
            Assert.AreEqual( 20, _pager.PageSize );
            Assert.AreEqual( 0, _pager.TotalCount );
            Assert.AreEqual( 0, _pager.PageCount );
        }

        #endregion

        #region PageCount(总页数)

        /// <summary>
        /// 总行数为0,每页20行,页数为0
        /// </summary>
        [TestMethod]
        public void TestPageCount_TotalCountIs0() {
            _pager.TotalCount = 0;
            Assert.AreEqual( 0, _pager.PageCount );
        }

        /// <summary>
        /// 总行数为100,每页20行,页数为5
        /// </summary>
        [TestMethod]
        public void TestPageCount_TotalCountIs100() {
            _pager.TotalCount = 100;
            Assert.AreEqual( 5, _pager.PageCount );
        }

        /// <summary>
        /// 总行数为1,每页20行,页数为1
        /// </summary>
        [TestMethod]
        public void TestPageCount_TotalCountIs1() {
            _pager.TotalCount = 1;
            Assert.AreEqual( 1, _pager.PageCount );
        }

        /// <summary>
        /// 总行数为100,每页10行,页数为10
        /// </summary>
        [TestMethod]
        public void TestPageCount_PageSizeIs10_TotalCountIs100() {
            _pager.PageSize = 10;
            _pager.TotalCount = 100;
            Assert.AreEqual( 10, _pager.PageCount );
        }

        #endregion

        #region Page(页索引)

        /// <summary>
        /// 页索引小于1,则修正为1
        /// </summary>
        [TestMethod]
        public void TestPage_Less1() {
            _pager.Page = 0;
            Assert.AreEqual( 1, _pager.Page );

            _pager.Page = -1;
            Assert.AreEqual( 1, _pager.Page );
        }

        #endregion

        #region SkipCount(跳过的行数)

        /// <summary>
        /// 跳过的行数
        /// </summary>
        [TestMethod]
        public void TestSkipCount() {
            _pager.TotalCount = 100;

            _pager.Page = 0;
            Assert.AreEqual( 0, _pager.SkipCount );

            _pager.Page = 1;
            Assert.AreEqual( 0, _pager.SkipCount );

            _pager.Page = 2;
            Assert.AreEqual( 20, _pager.SkipCount );

            _pager.Page = 3;
            Assert.AreEqual( 40, _pager.SkipCount );

            _pager.Page = 4;
            Assert.AreEqual( 60, _pager.SkipCount );

            _pager.Page = 5;
            Assert.AreEqual( 80, _pager.SkipCount );

            _pager.Page = 6;
            Assert.AreEqual( 80, _pager.SkipCount );
        }

        /// <summary>
        /// 跳过的行数
        /// </summary>
        [TestMethod]
        public void TestSkipCount_2() {
            _pager.TotalCount = 99;

            _pager.Page = 0;
            Assert.AreEqual( 0, _pager.SkipCount );

            _pager.Page = 1;
            Assert.AreEqual( 0, _pager.SkipCount );

            _pager.Page = 2;
            Assert.AreEqual( 20, _pager.SkipCount );

            _pager.Page = 3;
            Assert.AreEqual( 40, _pager.SkipCount );

            _pager.Page = 4;
            Assert.AreEqual( 60, _pager.SkipCount );

            _pager.Page = 5;
            Assert.AreEqual( 80, _pager.SkipCount );

            _pager.Page = 6;
            Assert.AreEqual( 80, _pager.SkipCount );
        }

        /// <summary>
        /// 跳过的行数
        /// </summary>
        [TestMethod]
        public void TestSkipCount_3() {
            _pager.TotalCount = 0;
            _pager.Page = 1;
            Assert.AreEqual( 0, _pager.SkipCount );
        }

        #endregion
    }
}

现在有了Pager来传递分页参数,但分页结果采用什么类型返回呢?一种办法是通过List<T>返回对象集合,再定义几个out参数来返回分页参数,但这种做法比较丑陋,out只应该在必要时才使用。

一个更好的办法是创建派生自List<T>的自定义集合,只需要添加几个分页属性即可。

在Util.Domains项目的Repositories目录中,创建PagerList分页列表,代码如下。

using System;
using System.Collections.Generic;
using System.Linq;

namespace Util.Domains.Repositories {
    /// <summary>
    /// 分页集合
    /// </summary>
    /// <typeparam name="T">元素类型</typeparam>
    public class PagerList<T> : List<T> {
        /// <summary>
        /// 分页集合
        /// </summary>
        /// <param name="pager">查询对象</param>
        public PagerList( IPager pager )
            : this( pager.Page, pager.PageSize, pager.TotalCount, pager.Order ) {
        }

        /// <summary>
        /// 分页集合
        /// </summary>
        /// <param name="totalCount">总行数</param>
        public PagerList( int totalCount )
            : this( 1, 20, totalCount ) {
        }

        /// <summary>
        /// 分页集合
        /// </summary>
        /// <param name="page">页索引</param>
        /// <param name="pageSize">每页显示行数</param>
        /// <param name="totalCount">总行数</param>
        public PagerList( int page, int pageSize, int totalCount )
            : this( page, pageSize, totalCount, "" ) {
        }

        /// <summary>
        /// 分页集合
        /// </summary>
        /// <param name="page">页索引</param>
        /// <param name="pageSize">每页显示行数</param>
        /// <param name="totalCount">总行数</param>
        /// <param name="order">排序条件</param>
        public PagerList( int page, int pageSize, int totalCount, string order ) {
            var pager = new Pager( page, pageSize, totalCount );
            TotalCount = pager.TotalCount;
            PageCount = pager.PageCount;
            Page = pager.Page;
            PageSize = pager.PageSize;
            Order = order;
        }

        /// <summary>
        /// 页索引,即第几页,从1开始
        /// </summary>
        public int Page { get; private set; }

        /// <summary>
        /// 每页显示行数
        /// </summary>
        public int PageSize { get; private set; }

        /// <summary>
        /// 总行数
        /// </summary>
        public int TotalCount { get; private set; }

        /// <summary>
        /// 总页数
        /// </summary>
        public int PageCount { get; private set; }

        /// <summary>
        /// 排序条件
        /// </summary>
        public string Order { get; private set; }

        /// <summary>
        /// 转换分页集合的元素类型
        /// </summary>
        /// <typeparam name="TResult">目标元素类型</typeparam>
        /// <param name="converter">转换方法</param>
        public PagerList<TResult> Convert<TResult>( Func<T, TResult> converter ) {
            var result = new PagerList<TResult>( Page, PageSize, TotalCount, Order );
            result.AddRange( this.Select( converter ) );
            return result;
        }
    }
}

PagerList可以接收一个IPager的参数,这样可以快速设置分页参数。

当你从仓储中获取到PagerList<T>,T类型参数是一个领域层的聚合,如果你的应用层操作的是Dto,这个PagerList就无法使用,将一个PagerList<TEntity>完整转换为PagerList<TDto>需要好几行乏味的赋值代码。为了解决这个问题,提供了一个Convert方法,该方法接收一个Func<T, TResult>参数,Func是.Net内置的一个标准委托,我们可以传递一个方法完成Entity到Dto的转换,其它分页参数的赋值操作会在Convert中完成。

PagerListTest单元测试代码如下。

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Util.Domains.Repositories;
using Util.Domains.Tests.Samples;

namespace Util.Domains.Tests.Repositories {
    /// <summary>
    /// 分页集合测试
    /// </summary>
    [TestClass]
    public class PagerListTest {
        /// <summary>
        /// 分页集合
        /// </summary>
        private PagerList<Employee> _list;

        /// <summary>
        /// 测试初始化
        /// </summary>
        [TestInitialize]
        public void TestInit() {
            _list = new PagerList<Employee>( 1, 2, 3 );
            _list.Add( new Employee() );
            _list.Add( new Employee(){Name = "B"} );
        }

        /// <summary>
        /// 元素个数
        /// </summary>
        [TestMethod]
        public void TestCount() {
            Assert.AreEqual( 2, _list.Count );
        }

        /// <summary>
        /// 用索引获取元素
        /// </summary>
        [TestMethod]
        public void TestIndex() {
            Assert.AreEqual( "B", _list[1].Name );
        }

        /// <summary>
        /// 转换类型
        /// </summary>
        [TestMethod]
        public void TestConvert() {
            var result = _list.Convert( t => new EmployeeDto() );
            Assert.AreEqual( 2, result.Count );
            Assert.AreEqual( 1, result.Page );
            Assert.AreEqual( 2, result.PageSize );
            Assert.AreEqual( 3, result.TotalCount );
            Assert.AreEqual( 2, result.PageCount );
        }
    }
}

准备工作已经就绪,现在开始扩展IQueryable的分页和排序功能。

注意观察IPager接口中的排序条件Order,它是一个字符串类型,使用弱类型的字符串是有原因的。要在IQueryable上进行排序,第一次升序调用OrderBy,降序调用OrderByDescending,如果要继续添加第二个排序条件,升序调用ThenBy,降序调用ThenByDescending。可以看到,排序API并不易用,如果要设置多个排序条件相当麻烦。更重要的一点是这些方法的参数是强类型的Func或Expression,而表现层传过来的参数一般都是字符串,这些字符串无法直接传递给上述方法,更不要谈排序方向和多个排序字段。

从上面可以看出,弱类型也不是一无是处,它可以提供强大的灵活性。为了弥补Linq强类型查询的不足,微软提供了一组动态查询帮助类,其中DynamicQueryable为IQueryable扩展了几个常用方法,它可以接收字符串参数,并解析为相应的Expression。

由于这一组帮助类内容很少,所以我不想为此引用一个额外的程序集。我将这些帮助类放到了Util项目的Lambdas目录的Dynamics子目录中,并修改它们的命名空间为Util.Lambdas.Dynamics,这样Resharper就不会显示警告了。

这几个动态查询帮助类的代码就不贴了,有兴趣可下载本文的示例代码文件。

在Util.Datas项目中找到Extensions.Query.cs文件,添加下面的扩展代码。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Util.Datas.Queries;
using Util.Domains.Repositories;
using Util.Lambdas.Dynamics;

namespace Util.Datas {
    /// <summary>
    /// 查询扩展
    /// </summary>
    public static class Extensions {
        /// <summary>
        /// 过滤
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="predicate">谓词</param>
        public static IQueryable<T> Filter<T>( this IQueryable<T> source, Expression<Func<T, bool>> predicate ) {
            predicate = QueryHelper.ValidatePredicate( predicate );
            if ( predicate == null )
                return source;
            return source.Where( predicate );
        }

        /// <summary>
        /// 排序
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="propertyName">排序属性名,多个属性用逗号分隔,降序用desc字符串,范例:Name,Age desc</param>
        public static IQueryable<T> OrderBy<T>( this IQueryable<T> source, string propertyName ) {
            return source.OrderByDynamic( propertyName );
        }

        /// <summary>
        /// 创建分页列表
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="page">页索引,表示第几页,从1开始</param>
        /// <param name="pageSize">每页显示行数,默认20</param>
        public static PagerList<T> PagerResult<T>( this IQueryable<T> source, int page, int pageSize = 20 ) {
            return PagerResult( source, new Pager( page, pageSize ) );
        }

        /// <summary>
        /// 创建分页列表
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="source">数据源</param>
        /// <param name="pager">分页对象</param>
        public static PagerList<T> PagerResult<T>( this IQueryable<T> source, IPager pager ) {
            source = OrderBy( source, pager );
            source = Pager( source, pager );
            return CreatePageList( source, pager );
        }

        /// <summary>
        /// 排序
        /// </summary>
        private static IQueryable<T> OrderBy<T>( IQueryable<T> source, IPager pager ) {
            if ( pager.Order.IsEmpty() )
                return source;
            return source.OrderBy( pager.Order );
        }

        /// <summary>
        /// 分页
        /// </summary>
        private static IQueryable<T> Pager<T>( IQueryable<T> source, IPager pager ) {
            if ( pager.TotalCount <= 0 )
                pager.TotalCount = source.Count();
            return source.Skip( pager.SkipCount ).Take( pager.PageSize );
        }

        /// <summary>
        /// 创建分页列表
        /// </summary>
        private static PagerList<T> CreatePageList<T>( IEnumerable<T> source, IPager pager ) {
            var result = new PagerList<T>( pager );
            result.AddRange( source.ToList() );
            return result;
        }
    }
}

这里扩展了OrderBy方法,在方法内部委托给OrderByDynamic执行,OrderByDynamic方法由DynamicQueryable提供。

PagerResult方法用来获取分页结果,有两个重载,第一个重载方法 PagerList<T> PagerResult<T>( this IQueryable<T> source, int page, int pageSize = 20 ) 接收两个分页参数,在使用这个重载之前假定排序已经完成。另一个重载方法 PagerList<T> PagerResult<T>( this IQueryable<T> source, IPager pager )接收一个分页对象,它会同时完成分页和排序操作。

我在实际应用中,几乎总是使用第二个重载,因为我在应用层使用了查询实体,查询实体是从Pager派生的查询参数对象,待介绍到应用层再详述。

还有一点需要注意,Pager对象的TotalCount是允许设置的,我在获取总行数的时候作了一个判断,如果TotalCount已经被设置,就不会调用Count方法。这样设计的原因是调用Count方法的开销很高,可能导致表扫描或索引扫描,如果在执行 PagerResult之前已经执行过Count,就不需要再重复执行。

本篇介绍的方法,应用层可以这样调用。

var dtos = Repository.Find().Filter(t = >t.Name.Contains("a")).OrderBy(t = >t.CreateTime).PagerResult(1).Convert(t = >t.ToDto());

var dtos = Repository.Find().Filter(t = >t.Name.Contains(testQuery.Name)).PagerResult(testQuery).Convert(t = >t.ToDto());

上面的代码已经比较简单,不过我将查询功能单独提取出来,使用查询对象模式进行封装,进一步简化操作。

下一篇将介绍查询条件,它是规约模式的一种实现。

下载地址:http://files.cnblogs.com/xiadao521/Util.2015.1.3.1.rar

应用程序框架实战