将不确定变为确定~表达式树是否可以有个集合，条件过滤有了新方向续（新增了OR和AND查询）

回到目录

今天发表了《将不确定变为确定~表达式树是否可以有个集合，条件过滤有了新方向》文章后，马上有朋友问起，如何实现OR查询，如果实现AND查询，事实上它说的可能并不完整，完整的话应该是，“如何实现N个字段进行OR运算和AND运算”呢，没错，我在那篇文章中，条件过滤只是针对单个字段的，是一种AND运算，也是一种条件的过滤机制，即：

有条件a1,a2,a3，它的过滤方式是先过滤a1,然后在剩下的结果里过滤a2,最后再过滤a3，它相然等同于a1 && a2 && a3，但如果要实现OR运算，我的那个程序就无能为力了，看看我们伟大的JamesJim同志写的这个OR与AND为表达式树实现的扩展方法吧，呵呵 。

    /// <summary>
    /// 条件建立者
    /// [单元表达式主要考用用在数据库字段或是其他集合字段中考用直接返回bool查询的]
    /// [考用考虑，如果一个内存集合中，考用定义一个属性，属性中有逻辑，例如：return str.Lenght==1;这样的可以用到单元运算符。]
    /// </summary>
    public static class PredicateBuilder
    {
        /// <summary>
        /// 单元 true 表达式
        /// </summary>
        /// <typeparam name="T">指定泛型 T</typeparam>
        /// <returns>true</returns>
        public static Expression<Func<T, bool>> True<T>()
        {
            return item => true;
        }

        /// <summary>
        /// 单元 false 表达式
        /// </summary>
        /// <typeparam name="T">指定泛型 T</typeparam>
        /// <returns>false</returns>
        public static Expression<Func<T, bool>> False<T>()
        {
            return item => false;
        }

        /// <summary>
        /// 双元 Or 表达式
        /// </summary>
        /// <typeparam name="T">指定泛型 T</typeparam>
        /// <param name="exprleft">左表达式</param>
        /// <param name="exprright">右表达式</param>
        /// <returns>返回合并表达式</returns>
        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> exprleft, Expression<Func<T, bool>> exprright)
        {
            var invokedExpr = Expression.Invoke(exprright, exprleft.Parameters.Cast<Expression>());
            return Expression.Lambda<Func<T, bool>>(Expression.Or(exprleft.Body, invokedExpr), exprleft.Parameters);
        }

        /// <summary>
        /// 双元 And 表达式
        /// </summary>
        /// <typeparam name="T">指定泛型 T</typeparam>
        /// <param name="exprleft">左表达式</param>
        /// <param name="exprright">右表达式</param>
        /// <returns>返回合并表达式</returns>
        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> exprleft, Expression<Func<T, bool>> exprright)
        {
            var invokedExpr = Expression.Invoke(exprright, exprleft.Parameters.Cast<Expression>());
            return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(exprleft.Body, invokedExpr), exprleft.Parameters);
        }
    }

再配合我的统一条件功能类，进行一下改造：

    /// <summary>
    /// 功能：条件过滤类
    /// 作者：张占岭
    /// 日期：2012-6-7
    /// </summary>
    public class PredicateList<TEntity> : IEnumerable<Expression<Func<TEntity, bool>>> where TEntity : class
    {
        List<Expression<Func<TEntity, bool>>> expressionList;
        public PredicateList()
        {
            expressionList = new List<Expression<Func<TEntity, bool>>>();
        }
        /// <summary>
        /// 添加到集合
        /// </summary>
        /// <param name="predicate"></param>
        public void Add(Expression<Func<TEntity, bool>> predicate)
        {
            expressionList.Add(predicate);
        }
        /// <summary>
        /// Or操作添加到集合
        /// </summary>
        /// <param name="exprleft"></param>
        /// <param name="exprright"></param>
        public void AddForOr(Expression<Func<TEntity, bool>> exprleft, Expression<Func<TEntity, bool>> exprright)
        {
            expressionList.Add(exprleft.Or(exprright));
        }
        /// <summary>
        /// And操作添加到集合
        /// </summary>
        /// <param name="exprleft"></param>
        /// <param name="exprright"></param>
        public void AddForAnd(Expression<Func<TEntity, bool>> exprleft, Expression<Func<TEntity, bool>> exprright)
        {
            expressionList.Add(exprleft.And(exprright));
        }

        #region IEnumerable 成员

        public IEnumerator GetEnumerator()
        {
            return expressionList.GetEnumerator();
        }

        #endregion

        #region IEnumerable<Expression<Func<TEntity>>> 成员

        IEnumerator<Expression<Func<TEntity, bool>>> IEnumerable<Expression<Func<TEntity, bool>>>.GetEnumerator()
        {
            return expressionList.GetEnumerator();
        }

        #endregion
    }

嘿嘿，这样就可以把一些用到做AND或者OR的条件先进行组成，最后再和其它条件一起过滤，就OK了，呵呵。

调用时，可以这样：

            PredicateList<UserBases> zzl = new PredicateList<UserBases>();
            Expression<Func<UserBases, bool>> exp_name = i => i.Name.Contains("zzl");
            Expression<Func<UserBases, bool>> exp_id = i => i.UserID == 1;
            zzl.AddForOr(exp_name, exp_id);
            GetModel(zzl).ForEach(i => Console.WriteLine(i.Name));
            Console.ReadKey();

OK，世界上对于i.Name和i.UserID的赋值，是我们在业务上判断过的，在PredicateList中存在的过滤条件就是真实要被过滤的。

回到目录