应用程序框架实战二十六:查询对象

　　信息系统的查询需求千变万化，在仓储中为每个查询需求创建一个特殊方法，将导致大量乏味而臃肿的接口。

　　一种更加可行的办法是，在应用层服务中描述查询需求，并通过仓储执行查询。

　　为了能够更好的描述查询需求，可以将查询功能从仓储中抽取出来，专门创建一个查询对象。

　　查询最复杂的部分是条件过滤，这也是查询对象的主要职责。查询对象可以认为是规约模式的一个变种，允许查询对象动态创建查询条件。

　　在Util.Domains项目Repositories目录中，创建查询对象基接口IQueryBase，代码如下。

using System; using System.Linq.Expressions; namespace Util.Domains.Repositories { /// <summary>
    /// 查询对象 /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    public interface IQueryBase<TEntity> : IPager where TEntity : class, IAggregateRoot { /// <summary>
        /// 获取谓词 /// </summary>
        Expression<Func<TEntity, bool>> GetPredicate(); /// <summary>
        /// 获取排序 /// </summary>
        string GetOrderBy(); } }

　　IQueryBase接口主要用来支持将查询对象传入仓储中。

　　在仓储接口IRepository中增加两个方法，代码如下。

        /// <summary>
        /// 查询 /// </summary>
        /// <param name="query">查询对象</param>
        IQueryable<TEntity> Query( IQueryBase<TEntity> query ); /// <summary>
        /// 分页查询 /// </summary>
        /// <param name="query">查询对象</param>
        PagerList<TEntity> PagerQuery( IQueryBase<TEntity> query );

　　在仓储类Repository中实现这两个方法，代码如下。

        /// <summary>
        /// 查询 /// </summary>
        /// <param name="query">查询对象</param>
        public IQueryable<TEntity> Query( IQueryBase<TEntity> query ) { return FilterBy( Find(), query ); } /// <summary>
        /// 过滤 /// </summary>
        protected IQueryable<TEntity> FilterBy( IQueryable<TEntity> queryable, IQueryBase<TEntity> query ) { var predicate = query.GetPredicate(); if ( predicate == null ) return queryable; return queryable.Where( predicate ); } /// <summary>
        /// 分页查询 /// </summary>
        /// <param name="query">查询对象</param>
        public virtual PagerList<TEntity> PagerQuery( IQueryBase<TEntity> query ) { return Query( query ).PagerResult( query ); }

　　以上代码完成了将查询对象传入仓储并获取结果，下面开始实现查询对象。

　　在Util.Datas项目Queries目录中，创建IQuery接口，代码如下。

using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using Util.Domains; using Util.Domains.Repositories; namespace Util.Datas.Queries { /// <summary>
    /// 查询对象 /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    /// <typeparam name="TKey">实体标识类型</typeparam>
    public interface IQuery<TEntity, TKey> : IQueryBase<TEntity> where TEntity : class,IAggregateRoot<TKey> { /// <summary>
        /// 添加谓词,仅能添加一个条件,如果参数值为空，则忽略该条件 /// </summary>
        /// <param name="predicate">谓词</param>
        /// <param name="isOr">是否使用Or连接</param>
        IQuery<TEntity, TKey> Filter( Expression<Func<TEntity, bool>> predicate, bool isOr = false ); /// <summary>
        /// 过滤条件 /// </summary>
        /// <param name="propertyName">属性名</param>
        /// <param name="value">值</param>
        /// <param name="operator">运算符</param>
        IQuery<TEntity,TKey> Filter( string propertyName, object value, Operator @operator = Operator.Equal ); /// <summary>
        /// 添加查询条件 /// </summary>
        /// <param name="criteria">查询条件</param>
        IQuery<TEntity,TKey> Filter( ICriteria<TEntity> criteria ); /// <summary>
        /// 过滤int数值段 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        IQuery<TEntity,TKey> FilterInt<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, int? min,int? max ); /// <summary>
        /// 过滤double数值段 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        IQuery<TEntity,TKey> FilterDouble<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, double? min, double? max ); /// <summary>
        /// 过滤日期段，不包含时间 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        IQuery<TEntity,TKey> FilterDate<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, DateTime? min, DateTime? max ); /// <summary>
        /// 过滤日期时间段，包含时间 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        IQuery<TEntity,TKey> FilterDateTime<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, DateTime? min, DateTime? max ); /// <summary>
        /// 过滤decimal数值段 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        IQuery<TEntity,TKey> FilterDecimal<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, decimal? min, decimal? max ); /// <summary>
        /// 与连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="query">查询对象</param>
        IQuery<TEntity,TKey> And( IQuery<TEntity,TKey> query ); /// <summary>
        /// 与连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="predicate">谓词</param>
        IQuery<TEntity,TKey> And( Expression<Func<TEntity, bool>> predicate ); /// <summary>
        /// 或连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="query">查询对象</param>
        IQuery<TEntity,TKey> Or( IQuery<TEntity,TKey> query ); /// <summary>
        /// 或连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="predicate">谓词</param>
        IQuery<TEntity,TKey> Or( Expression<Func<TEntity, bool>> predicate ); /// <summary>
        /// 添加排序，支持多次调用OrderBy创建多级排序 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="expression">属性表达式</param>
        /// <param name="desc">是否降序</param>
        IQuery<TEntity,TKey> OrderBy<TProperty>( Expression<Func<TEntity, TProperty>> expression, bool desc = false ); /// <summary>
        /// 添加排序，支持多次调用OrderBy创建多级排序 /// </summary>
        /// <param name="propertyName">排序属性</param>
        /// <param name="desc">是否降序</param>
        IQuery<TEntity,TKey> OrderBy( string propertyName, bool desc = false ); /// <summary>
        /// 获取列表 /// </summary>
        /// <param name="queryable">数据源</param>
        List<TEntity> GetList( IQueryable<TEntity> queryable ); /// <summary>
        /// 获取分页列表 /// </summary>
        /// <param name="queryable">数据源</param>
        PagerList<TEntity> GetPagerList( IQueryable<TEntity> queryable ); } }

　　查询对象中定义的过滤方法默认都是以And方式连接，所以需要增加专门的Or连接方法。当查询需求比较复杂时，可以创建多个查询对象进行合并，从而创建更为复杂的查询条件。

　　为了使用方便，查询对象本身还提供了获取数据的方法，需要传入IQueryable 对象，以便执行实际的查询操作。

　　在Util.Datas项目Queries目录中，创建查询对象实现类Query，代码如下。

using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using Util.Datas.Queries.Criterias; using Util.Datas.Queries.OrderBys; using Util.Domains; using Util.Domains.Repositories; namespace Util.Datas.Queries { /// <summary>
    /// 查询对象 /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    /// <typeparam name="TKey">实体标识类型</typeparam>
    public class Query<TEntity, TKey> : Pager, IQuery<TEntity, TKey> where TEntity : class ,IAggregateRoot<TKey> { #region 构造方法

        /// <summary>
        /// 初始化查询对象 /// </summary>
        public Query() { OrderBuilder = new OrderByBuilder(); } /// <summary>
        /// 初始化查询对象 /// </summary>
        /// <param name="pager">分页对象</param>
        public Query( IPager pager ) : this() { Page = pager.Page; PageSize = pager.PageSize; TotalCount = pager.TotalCount; OrderBy( pager.Order ); } #endregion

        #region 属性

        /// <summary>
        /// 查询条件 /// </summary>
        private ICriteria<TEntity> Criteria { get; set; } /// <summary>
        /// 排序生成器 /// </summary>
        private OrderByBuilder OrderBuilder { get; set; } #endregion

        #region GetPredicate(获取谓词)

        /// <summary>
        /// 获取谓词 /// </summary>
        public Expression<Func<TEntity, bool>> GetPredicate() { if ( Criteria == null ) return null; return Criteria.GetPredicate(); } #endregion

        #region GetOrderBy(获取排序)

        /// <summary>
        /// 获取排序 /// </summary>
        public string GetOrderBy() { Order = OrderBuilder.Generate(); if ( string.IsNullOrWhiteSpace( Order ) ) Order = "Id desc"; return Order; } #endregion

        #region 过滤条件

        /// <summary>
        /// 添加谓词,仅能添加一个条件,如果参数值为空，则忽略该条件 /// </summary>
        /// <param name="predicate">谓词</param>
        /// <param name="isOr">是否使用Or连接</param>
        public IQuery<TEntity, TKey> Filter( Expression<Func<TEntity, bool>> predicate,bool isOr = false ) { predicate = QueryHelper.ValidatePredicate( predicate ); if ( predicate == null ) return this; if ( isOr ) Or( predicate ); else And( predicate ); return this; } /// <summary>
        /// 过滤条件 /// </summary>
        /// <param name="propertyName">属性名</param>
        /// <param name="value">值</param>
        /// <param name="operator">运算符</param>
        public IQuery<TEntity, TKey> Filter( string propertyName, object value, Operator @operator = Operator.Equal ) { return Filter( Lambda.ParsePredicate<TEntity>( propertyName, value, @operator ) ); } /// <summary>
        /// 添加查询条件 /// </summary>
        /// <param name="criteria">查询条件</param>
        public IQuery<TEntity, TKey> Filter( ICriteria<TEntity> criteria ) { And( criteria.GetPredicate() ); return this; } /// <summary>
        /// 过滤int数值段 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        public IQuery<TEntity, TKey> FilterInt<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, int? min, int? max ) { return Filter( new IntSegmentCriteria<TEntity, TProperty>( propertyExpression, min, max ) ); } /// <summary>
        /// 过滤double数值段 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        public IQuery<TEntity, TKey> FilterDouble<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, double? min, double? max ) { return Filter( new DoubleSegmentCriteria<TEntity, TProperty>( propertyExpression, min, max ) ); } /// <summary>
        /// 过滤日期段，不包含时间 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        public IQuery<TEntity, TKey> FilterDate<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, DateTime? min, DateTime? max ) { return Filter( new DateSegmentCriteria<TEntity, TProperty>( propertyExpression, min, max ) ); } /// <summary>
        /// 过滤日期时间段，包含时间 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        public IQuery<TEntity, TKey> FilterDateTime<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, DateTime? min, DateTime? max ) { return Filter( new DateTimeSegmentCriteria<TEntity, TProperty>( propertyExpression, min, max ) ); } /// <summary>
        /// 过滤decimal数值段 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        public IQuery<TEntity, TKey> FilterDecimal<TProperty>( Expression<Func<TEntity, TProperty>> propertyExpression, decimal? min, decimal? max ) { return Filter( new DecimalSegmentCriteria<TEntity, TProperty>( propertyExpression, min, max ) ); } #endregion

        #region 连接

        /// <summary>
        /// 与连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="query">查询对象</param>
        public IQuery<TEntity, TKey> And( IQuery<TEntity, TKey> query ) { return And( query.GetPredicate() ); } /// <summary>
        /// 与连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="predicate">谓词</param>
        public IQuery<TEntity, TKey> And( Expression<Func<TEntity, bool>> predicate ) { if ( Criteria == null ) { Criteria = new Criteria<TEntity>( predicate ); return this; } Criteria = new AndCriteria<TEntity>( Criteria.GetPredicate(), predicate ); return this; } /// <summary>
        /// 或连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="query">查询对象</param>
        public IQuery<TEntity, TKey> Or( IQuery<TEntity, TKey> query ) { return Or( query.GetPredicate() ); } /// <summary>
        /// 或连接,将传入的查询条件合并到当前对象 /// </summary>
        /// <param name="predicate">谓词</param>
        public IQuery<TEntity, TKey> Or( Expression<Func<TEntity, bool>> predicate ) { if ( Criteria == null ) { Criteria = new Criteria<TEntity>( predicate ); return this; } Criteria = new OrCriteria<TEntity>( Criteria.GetPredicate(), predicate ); return this; } #endregion

        #region OrderBy(排序)

        /// <summary>
        /// 添加排序，支持多次调用OrderBy创建多级排序 /// </summary>
        /// <typeparam name="TProperty">属性类型</typeparam>
        /// <param name="expression">属性表达式</param>
        /// <param name="desc">是否降序</param>
        public IQuery<TEntity, TKey> OrderBy<TProperty>( Expression<Func<TEntity, TProperty>> expression, bool desc = false ) { return OrderBy( Lambda.GetName( expression ), desc ); } /// <summary>
        /// 添加排序，支持多次调用OrderBy创建多级排序 /// </summary>
        /// <param name="propertyName">排序属性</param>
        /// <param name="desc">是否降序</param>
        public IQuery<TEntity, TKey> OrderBy( string propertyName, bool desc = false ) { OrderBuilder.Add( propertyName, desc ); GetOrderBy(); return this; } #endregion

        #region Clear(清理)

        /// <summary>
        /// 清理 /// </summary>
        public void Clear() { Criteria = null; OrderBuilder = new OrderByBuilder(); } #endregion

        #region GetList(获取列表)

        /// <summary>
        /// 获取列表 /// </summary>
        /// <param name="queryable">数据源</param>
        public List<TEntity> GetList( IQueryable<TEntity> queryable ) { return Execute( queryable ).OrderBy( Order ).ToList(); } /// <summary>
        /// 执行过滤和分页 /// </summary>
        private IQueryable<TEntity> Execute( IQueryable<TEntity> queryable ) { queryable.CheckNull( "queryable" ); queryable = FilterBy( queryable ); GetOrderBy(); return queryable; } /// <summary>
        /// 过滤 /// </summary>
        private IQueryable<TEntity> FilterBy( IQueryable<TEntity> queryable ) { if ( Criteria == null ) return queryable; return queryable.Where( Criteria.GetPredicate() ); } #endregion

        #region GetPagerList(获取分页列表)

        /// <summary>
        /// 获取分页列表 /// </summary>
        /// <param name="queryable">数据源</param>
        public PagerList<TEntity> GetPagerList( IQueryable<TEntity> queryable ) { return Execute( queryable ).PagerResult( this ); } #endregion } }

　　应用层服务可以这样查询。

        public PagerList<ApplicationDto> Query( ApplicationQuery query ) { return new Query<Application>(query) .Filter( t => t.Code == query.Code ) .Filter( t => t.Name.Contains( query.Name ) ) .Filter( t => t.Enabled == query.Enabled ) .FilterDate( t => t.CreateTime, query.BeginCreateTime, query.EndCreateTime ) .GetPagerList( Repository.Find() ).Convert( t => t.ToDto() ); }

或

        public PagerList<ApplicationDto> Query2( ApplicationQuery query ) { var queryObject = new Query<Application>( query ) .Filter( t => t.Code == query.Code ) .Filter( t => t.Name.Contains( query.Name ) ) .Filter( t => t.Enabled == query.Enabled ) .FilterDate( t => t.CreateTime, query.BeginCreateTime, query.EndCreateTime ); return Repository.PagerQuery( queryObject ).Convert( t => t.ToDto() ); }

 

　　.Net应用程序框架交流QQ群: 386092459，欢迎有兴趣的朋友加入讨论。

　　谢谢大家的持续关注，我的博客地址：http://www.cnblogs.com/xiadao521/