EF+MVC动态Lamda表达式拼接（学习笔记二）

　　好的，亲爱的观众朋友们，我们就前面EF+MVC动态Lamda表达式拼接（学习笔记一）接着说，前段的格式定义好了，那么我们后端怎样去实现呢？这里我也简单的做了一个小例子，那门这个例子用于解决什么场景的查询呢？请看图：

　　这个查询我想大家并不陌生，没错，接下来我要实现的效果就是在文本框里面支持三个字段的模糊查询，废话不多说，直接上代码：

　　

  public List<TEntity> GetList(List<ConditionLamda> conditionLamda)
        {
            //创建表达式的开始部分：p=>
            var parameter = Expression.Parameter(typeof(TEntity), "p");
            //取出类的所有字段

            #region 



            var property_list = typeof(TEntity).GetProperties().ToList();
            //取出需要作为条件查询的属性，防止因为前端误传报错
            //conditionLamda = conditionLamda.Where(w => property_list.Select(p => p.Name.ToLower()).Contains(w.Property.ToLower())).ToList();

            var isFirst = true;

            Expression lamda = null;

            //保存第一次
            Expression tempLamda = null;

            foreach (var item in conditionLamda)
            {


                var property = property_list.Where(p => p.Name.ToLower() == item.Property.ToLower()).FirstOrDefault();


             
                    if (property != null)
                    {
                        //创建我们要查询的字段：p.UserName
                        var para = Expression.Property(parameter, property.Name);
                        //给值做转换
                        var value = Expression.Constant(item.Value);
                        //运算

                        switch (item.Operator)
                        {
                            case "=":
                                {
                                    lamda = Expression.Equal(para, value);
                                }
                                break;
                            case "!=":
                                {
                                    lamda = Expression.NotEqual(para, value);
                                }
                                break;
                            case ">":
                                {
                                    lamda = Expression.GreaterThan(para, value);
                                }
                                break;
                            case "<":
                                {
                                    lamda = Expression.LessThan(para, value);
                                }
                                break;
                            case ">=":
                                {
                                    lamda = Expression.GreaterThanOrEqual(para, value);
                                }
                                break;
                            case "<=":
                                {
                                    lamda = Expression.LessThanOrEqual(para, value);
                                }
                                break;
                            case "like"://like
                                {
                                    if (property.PropertyType.Name == "String")
                                    {

                                        lamda = Expression.Call(
                                             Expression.Property(parameter, typeof(TEntity).GetProperty(property.Name)),  //c.DataSourceName
                                             typeof(string).GetMethod("Contains", new Type[] { typeof(string) }),// 反射使用.Contains()方法                         
                                             value           // .Contains(optionName)     不能使用上面组合出来的value
                                        );
                                    }
                                }
                                break;
                            default:
                                break;
                        }

                        if (lamda != null)
                        {
                            if (isFirst)
                            {
                                tempLamda = lamda;
                                isFirst = false;
                            }
                            else
                            {
                                switch (item.Join)
                                {
                                    case "||":
                                        {
                                            lamda = Expression.Or(tempLamda, lamda);
                                        }
                                        break;
                                    case "&&":
                                    default:
                                        {
                                            lamda = Expression.And(tempLamda, lamda);
                                        }
                                        break;
                                }
                                tempLamda = lamda;
                            }
                        }
                    }

                }
               
            

            #endregion

            return Context.Set<TEntity>().Where(Expression.Lambda<Func<TEntity, bool>>(lamda, parameter)).ToList();
        }

　　上面还有一些运算时没有的，比如in   not in   等     这些你可以试着自己去写，没有问题的，我这边只是做一个例子，希望你有更好的思路，多多交流才是王道，做IT的，不能闭关自守，好了，写到这里那么我们就完成了   select * from 表名 where 列1=‘XX’   and 列2=‘XX’    这种形式的查询，当然或也是可以的  select * from 表名 where 列1=‘XX’   or 列2=‘XX’  上面写了这么多，那么前段的值怎么传过来呢？虽然在第一篇文章中有提到过，我这里也在啰嗦一下好了，看家伙：

　　

{ Join: "||", Property: "merchant_accno", Operator: "like", Value:v }

　　这个时候，我们只需要在后端定义一个类来接受这种形式的传参就行了，同样，上代码，程序员少说话：

　　

 public class ConditionLamda
    {
        public string Join { get; set; }
        public string Property { get; set; }
        public string Operator { get; set; }
        public string Value { get; set; }
    }

　　

　　好的，这么一来我们就搞定了通用查询了，但是你可能会问，那么如何搞定 select * from 表名 where 列1=‘’  and （列2 like ‘XX’ or  列3  like  '%XX%'） 这种组合查询呢个，我们下回分享，喜欢的可以

　　码农 https://shop162421329.taobao.com 

　　　　　　

 

转载于:https://www.cnblogs.com/Xty09/p/5807064.html