应用程序框架实战二十五:查询条件(规约模式应用)

　　前面已经做了一些准备工作，本篇将介绍查询条件的封装，它是规约模式的一个应用。

　　规约使用一个对象来封装谓词，我之前已经介绍过它在验证方面的应用，本篇是规约模式在查询方面的应用。

　　规约的强大之处在于，能够将一堆杂乱无章的条件判断或查询条件封装起来，以一个清晰的概念来表达，并使得这些谓词具备了可复用的能力。

　　首先在Util.Domains项目的Repositories目录中创建ICriteria接口，这个接口表示一个查询条件，代码如下。

using System;
using System.Linq.Expressions;

namespace Util.Domains.Repositories {
/// <summary>
/// 查询条件
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
public interface ICriteria<TEntity> where TEntity : class,IAggregateRoot {
/// <summary>
/// 获取谓词
/// </summary>
Expression<Func<TEntity, bool>> GetPredicate();
}
}

　　由于我们使用了EF这种ORM框架，查询条件的结果是一个Expression<Func<TEntity, bool>>的谓词表达式。

　　在Util.Datas项目中，打开Extensions.Query.cs文件，增加以下代码。

/// <summary>
/// 过滤
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="source">数据源</param>
/// <param name="criteria">查询条件</param>
public static IQueryable<T> Filter<T>( this IQueryable<T> source, ICriteria<T> criteria ) where T : class,IAggregateRoot {
if ( criteria == null )
return source;
var predicate = criteria.GetPredicate();
if ( predicate == null )
return source;
return source.Where( predicate );
}

　　我们在IQueryable对象上扩展了一个Filter方法，该方法接收一个查询条件，如果查询条件有效，就使用Where方法添加过滤条件。

　　基础工作就这么多，下面来看几个范例。

　　在信息系统中，经常会进行范围查询，比如一个日期段的查询。这看起来是一个简单的需求，初学者一般这样写，t => t.Date >= BeginDate && t.Date <= EndDate，其结果可能是错误的，这是由于从表现层传入的查询条件是可选的，如果客户没有进行输入，结果就是错的。

　　对于范围查询来讲，还有更多的细节需要思考，比如，起始日期和结束日期都没有输入，或只输入了起始日期或结束日期，也可能客户输入的起始日期比结束日期还大。为了获得健壮性，我们会对查询条件进行各种判断，从而导致杂乱无章的代码。更要命的是，这些代码无法复用，在另一个范围查询的位置，我们必须把之前的代码复制过去进行修改。

　　一个更好的办法是把范围查询逻辑封装到查询条件对象中，以后需要进行范围查询时，即可随手拈来。

　　在Util.Datas项目Queries目录中，新建Criterias目录，创建一个查询条件基类CriteriaBase，代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;
using Util.Domains.Repositories;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// 查询条件
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
public abstract class CriteriaBase<TEntity> : ICriteria<TEntity> where TEntity : class, IAggregateRoot {
/// <summary>
/// 谓词
/// </summary>
protected Expression<Func<TEntity, bool>> Predicate { get; set; }

/// <summary>
/// 获取谓词
/// </summary>
public virtual Expression<Func<TEntity, bool>> GetPredicate() {
return Predicate;
}
}
}

　　根据数据类型不同，范围查询有很多种类，比如日期范围查询、日期时间范围查询、整数范围查询、浮点数范围查询等。我们需要为范围查询条件创建一个基类SegmentCriteria，代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;
using Util.Lambdas;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// 段过滤条件
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
/// <typeparam name="TValue">值类型</typeparam>
public abstract class SegmentCriteria<TEntity, TProperty, TValue> : CriteriaBase<TEntity>
where TEntity : class, IAggregateRoot
where TValue : struct {
/// <summary>
/// 初始化段过滤条件
/// </summary>
/// <param name="propertyExpression">属性表达式</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
protected SegmentCriteria( Expression<Func<TEntity, TProperty>> propertyExpression, TValue? min, TValue? max ) {
Builder = new ExpressionBuilder<TEntity>();
PropertyExpression = propertyExpression;
Min = min;
Max = max;
if ( IsMinGreaterMax( min, max ) ) {
Min = max;
Max = min;
}
}

/// <summary>
/// 最小值是否大于最大值
/// </summary>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
protected abstract bool IsMinGreaterMax( TValue? min, TValue? max );

/// <summary>
/// 属性表达式
/// </summary>
public Expression<Func<TEntity, TProperty>> PropertyExpression { get; set; }

/// <summary>
/// 表达式生成器
/// </summary>
private ExpressionBuilder<TEntity> Builder { get; set; }

/// <summary>
/// 最小值
/// </summary>
public TValue? Min { get; set; }

/// <summary>
/// 最大值
/// </summary>
public TValue? Max { get; set; }

/// <summary>
/// 获取谓词
/// </summary>
public override Expression<Func<TEntity, bool>> GetPredicate() {
var first = CreateLeftExpression();
var second = CreateRightExpression();
return Builder.ToLambda( first.And( second ) );
}

/// <summary>
/// 创建左操作数，即 t => t.Property >= Min
/// </summary>
private Expression CreateLeftExpression() {
if ( Min == null )
return null;
return Builder.Create( PropertyExpression, Operator.GreaterEqual, GetMinValue() );
}

/// <summary>
/// 获取最小值
/// </summary>
protected virtual TValue? GetMinValue() {
return Min;
}

/// <summary>
/// 创建右操作数，即 t => t.Property <= Max
/// </summary>
private Expression CreateRightExpression() {
if ( Max == null )
return null;
return Builder.Create( PropertyExpression, GetMaxOperator(), GetMaxValue() );
}

/// <summary>
/// 获取最大值相关的运算符
/// </summary>
protected virtual Operator GetMaxOperator() {
return Operator.LessEqual;
}

/// <summary>
/// 获取最大值
/// </summary>
protected virtual TValue? GetMaxValue() {
return Max;
}
}
}

　　对于日期范围查询，日期是否包含时间非常重要，它们在行为上是不同的。如果日期不包含时间，那么需要为结束日期加一天，并修改运算符为小于。

　　日期时间范围查询条件DateTimeSegmentCriteria,代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// 日期时间段过滤条件 - 包含时间
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
public class DateTimeSegmentCriteria<TEntity, TProperty> : SegmentCriteria<TEntity, TProperty, DateTime> where TEntity : class,IAggregateRoot {
/// <summary>
/// 初始化日期时间段过滤条件
/// </summary>
/// <param name="propertyExpression">属性表达式</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public DateTimeSegmentCriteria( Expression<Func<TEntity, TProperty>> propertyExpression, DateTime? min, DateTime? max )
: base( propertyExpression, min, max ) {
}

/// <summary>
/// 最小值是否大于最大值
/// </summary>
protected override bool IsMinGreaterMax( DateTime? min, DateTime? max ) {
return min > max;
}
}
}

　　日期范围查询条件DateSegmentCriteria，代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// 日期段过滤条件 - 不包含时间
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
public class DateSegmentCriteria<TEntity, TProperty> : SegmentCriteria<TEntity, TProperty, DateTime> where TEntity : class,IAggregateRoot {
/// <summary>
/// 初始化日期段过滤条件
/// </summary>
/// <param name="propertyExpression">属性表达式</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public DateSegmentCriteria( Expression<Func<TEntity, TProperty>> propertyExpression, DateTime? min, DateTime? max )
: base( propertyExpression, min, max ) {
}

/// <summary>
/// 最小值是否大于最大值
/// </summary>
protected override bool IsMinGreaterMax( DateTime? min, DateTime? max ) {
return min > max;
}

/// <summary>
/// 获取最小值
/// </summary>
protected override DateTime? GetMinValue() {
return base.GetMinValue().SafeValue().Date;
}

/// <summary>
/// 获取最大值
/// </summary>
protected override DateTime? GetMaxValue() {
return base.GetMaxValue().SafeValue().Date.AddDays( 1 );
}

/// <summary>
/// 获取最大值相关的运算符
/// </summary>
protected override Operator GetMaxOperator() {
return Operator.Less;
}
}
}

　　整数范围查询条件IntSegmentCriteria，代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// 整数段过滤条件
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
public class IntSegmentCriteria<TEntity, TProperty> : SegmentCriteria<TEntity, TProperty,int> where TEntity : class,IAggregateRoot {
/// <summary>
/// 初始化整数段过滤条件
/// </summary>
/// <param name="propertyExpression">属性表达式</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public IntSegmentCriteria( Expression<Func<TEntity, TProperty>> propertyExpression, int? min, int? max )
: base( propertyExpression,min,max){
}

/// <summary>
/// 最小值是否大于最大值
/// </summary>
protected override bool IsMinGreaterMax( int? min, int? max ) {
return min > max;
}
}
}

　　double范围查询条件DoubleSegmentCriteria，代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// double数值段过滤条件
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
public class DoubleSegmentCriteria<TEntity, TProperty> : SegmentCriteria<TEntity, TProperty, double> where TEntity : class,IAggregateRoot {
/// <summary>
/// 初始化double数值段过滤条件
/// </summary>
/// <param name="propertyExpression">属性表达式</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public DoubleSegmentCriteria( Expression<Func<TEntity, TProperty>> propertyExpression, double? min, double? max )
: base( propertyExpression, min, max ) {
}

/// <summary>
/// 最小值是否大于最大值
/// </summary>
protected override bool IsMinGreaterMax( double? min, double? max ) {
return min > max;
}
}
}

　　decimal范围查询条件DecimalSegmentCriteria，代码如下。

using System;
using System.Linq.Expressions;
using Util.Domains;

namespace Util.Datas.Queries.Criterias {
/// <summary>
/// decimal数值段过滤条件
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
public class DecimalSegmentCriteria<TEntity, TProperty> : SegmentCriteria<TEntity, TProperty, decimal> where TEntity : class,IAggregateRoot {
/// <summary>
/// 初始化decimal数值段过滤条件
/// </summary>
/// <param name="propertyExpression">属性表达式</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public DecimalSegmentCriteria( Expression<Func<TEntity, TProperty>> propertyExpression, decimal? min, decimal? max )
: base( propertyExpression, min, max ) {
}

/// <summary>
/// 最小值是否大于最大值
/// </summary>
protected override bool IsMinGreaterMax( decimal? min, decimal? max ) {
return min > max;
}
}
}

　　我们现在进行日期范围查询，就比较简单了，代码如下。

queryable.Filter( new DateSegmentCriteria<Test, DateTime>( t => t.Date, BeginDate,EndDate ) );

　　不过上面的代码用起来还不是太顺手，可以将范围查询扩展到IQueryable，代码如下。

/// <summary>
/// 过滤整数段
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
/// <param name="source">数据源</param>
/// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public static IQueryable<T> FilterInt<T, TProperty>( this IQueryable<T> source,
Expression<Func<T, TProperty>> propertyExpression, int? min, int? max ) where T : class,IAggregateRoot {
return source.Filter( new IntSegmentCriteria<T, TProperty>( propertyExpression, min, max ) );
}

/// <summary>
/// 过滤double数值段
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
/// <param name="source">数据源</param>
/// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public static IQueryable<T> FilterDouble<T, TProperty>( this IQueryable<T> source,
Expression<Func<T, TProperty>> propertyExpression, double? min, double? max ) where T : class,IAggregateRoot {
return source.Filter( new DoubleSegmentCriteria<T, TProperty>( propertyExpression, min, max ) );
}

/// <summary>
/// 过滤decimal数值段
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
/// <param name="source">数据源</param>
/// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public static IQueryable<T> FilterDecimal<T, TProperty>( this IQueryable<T> source,
Expression<Func<T, TProperty>> propertyExpression, decimal? min, decimal? max ) where T : class,IAggregateRoot {
return source.Filter( new DecimalSegmentCriteria<T, TProperty>( propertyExpression, min, max ) );
}

/// <summary>
/// 过滤日期段，不包含时间
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
/// <param name="source">数据源</param>
/// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public static IQueryable<T> FilterDate<T, TProperty>( this IQueryable<T> source,
Expression<Func<T, TProperty>> propertyExpression, DateTime? min, DateTime? max ) where T : class,IAggregateRoot {
return source.Filter( new DateSegmentCriteria<T, TProperty>( propertyExpression, min, max ) );
}

/// <summary>
/// 过滤日期时间段，包含时间
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <typeparam name="TProperty">属性类型</typeparam>
/// <param name="source">数据源</param>
/// <param name="propertyExpression">属性表达式，范例：t => t.Age</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值</param>
public static IQueryable<T> FilterDateTime<T, TProperty>( this IQueryable<T> source,
Expression<Func<T, TProperty>> propertyExpression, DateTime? min, DateTime? max ) where T : class,IAggregateRoot {
return source.Filter( new DateTimeSegmentCriteria<T, TProperty>( propertyExpression, min, max ) );
}

　　日期范围查询的调用代码简化为如下代码。

queryable.FilterDate( t => t.Date, BeginDate, EndDate)

　　本文介绍了如何使用查询条件对象封装范围查询，当然你可以用类似的方法将业务中的查询条件封装起来。

　　规约模式还有其它用法，更强大的用法，请参考陈晴阳老兄的这篇http://www.cnblogs.com/daxnet/p/3925426.html

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

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