码迷，mamicode.com
首页 > 其他好文 > 详细

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

时间：2015-01-20 06:09:42      阅读：158      评论：0      收藏：0      [点我收藏+]

标签：

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

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

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

　　首先在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 &lt;= 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/

 

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

标签：

原文地址：http://www.cnblogs.com/xiadao521/p/4235120.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！