自动生成 Lambda查询和排序，从些查询列表so easy

如下图查询页面，跟据不同条件动态生成lambda的Where条件和OrderBy,如果要增加或调整查询，只用改前台HTML即可，不用改后台代码

前台代码：

    <div style="padding-bottom: 5px;" id="queryForm">

        <span>员工姓名：</span><input type="text" emptytext="ddd" data-options="{match:'in'}" class="mini-textbox" id="Age" />
        <span>部门：</span><input type="text" class="mini-textbox" data-options="{match:'like'}" id="Sex" />

        生日从  <input id="beg" format="yyyy-MM-dd" showokbutton="false" showclearbutton="true" data-options="{match:'from',innerkey:'Birthday'}" class="mini-datepicker" />
        至  <input id="end" format="yyyy-MM-dd" showokbutton="false" showclearbutton="true" data-options="{match:'to',innerkey:'Birthday'}" class="mini-datepicker" />

        <span>年龄从：</span><input type="text" emptytext="ddd" data-options="{match:'from',innerkey:'Age'}" class="mini-textbox" id="bb" />
        <span>至：</span><input type="text" class="mini-textbox" data-options="{match:'to',innerkey:'Age'}" id="bd" />

        <a class="mini-button" iconcls="icon-search" onclick="search()">查找</a>


    </div>  


<div id="datagrid1" ondrawcell="Link" onupdate="load" class="mini-datagrid" style=" 100%; height: 100%;" allowresize="true"
             idfield="Id" sortfield="Age" showpager="false" pagesize="-1" sizelist="[-1]" sortorder="asc" multiselect="true">
            <div property="columns">
                <!--<div type="indexcolumn"></div>        -->
                <div type="checkcolumn"></div>
                <div field="UserName" data-options="{Func:'test'}" width="120" headeralign="center" allowsort="true">姓名</div>
                <div field="Sex" renderer="SexShow" width="120" headeralign="center" allowsort="true">性别</div>

                <div field="LoginName" width="120">登录名</div>
                <div field="Password" width="120">密码</div>
                <div field="Birthday" width="100">生日</div>
                <div field="Age" width="100" allowsort="true">年龄</div>
                <div field="Remark" align="right" width="100">备注</div>


                <div field="Married" renderer="MarriedShow" width="100">婚否</div>

            </div>
        </div>

查询控件上的 data-options="{match:'from',innerkey:'Birthday'}" 后多个查询条件会组合成一个json数组，传到后台，反序列化成List<QueryItem>,
排序条件Jquery 的Grid控件也会传到后台的，反序列化成SortItem，分页信息 反序列化成 Pager，详见后台代码。

上后台代码：比较复杂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using App.Core;
using System.Reflection;
using System.Linq.Expressions;
using System.Data.Entity;
using System.Collections.Specialized;
namespace App.PageBase.Query
{
    //查询条件模型
    public class QueryItem 
    {
        public string match { get; set; }
        public string value { get; set; }
        public string key { get; set; }
        public string innerkey { get; set; }

    }
    //排序模型
    public class SortItem
    {

        public string sortField { get; set; }
        public string sortOrder { get; set; }
    }
    //列表分页模型
    public class Pager
    {
        public int pageSize
        {
            get;
            set;
        }
        public int pageIndex
        {
            get;
            set;
        }
        public int totalCount
        {
            get;
            set;
        }

    }


    //生成查询条件类
    public class QueryBulider<TEntity> where TEntity : class,new()
    {
        private Pager _pager;// = new Pager();
        private SortItem _sort;// = new SortItem();
        private List<QueryItem> _queryItems;//= new List<QueryItem>();
        public Pager pager
        {
            get { return _pager; }
            set { _pager = value; }
        }
        public SortItem sort
        {
            get { return _sort; }
            set { _sort = value; }
        }
        public List<QueryItem> queryItems
        {
            get { return _queryItems; }
            set { _queryItems = value; }
        }
        /// <summary>
        /// 根据 分页模型，排序模型，查询条件模型列表构造 自动查询生成器
        /// </summary>
        /// <param name="pager"></param>
        /// <param name="sort"></param>
        /// <param name="queryItems"></param>
        public QueryBulider(Pager pager, SortItem sort, List<QueryItem> queryItems)
        {
            this.pager = pager;
            this.sort = sort;
            this.queryItems = queryItems;


        }
        public QueryBulider()
        { }
    
        /// <summary>
        /// 根据HTTP实例化
        /// </summary>
        /// <param name="requstForm"></param>
        public QueryBulider(NameValueCollection requstForm)
        {
            string filter = requstForm["filter"];
            string pageIndex = requstForm["pageIndex"];
            string pageSize = requstForm["pageSize"];
            string sortField = requstForm["sortField"];
            string sortOrder = requstForm["sortOrder"];

            if (!string.IsNullOrEmpty(pageSize) && !string.IsNullOrEmpty(pageIndex)&&pageSize!="-1")
            {
                this.pager = new Pager { pageIndex = int.Parse( pageIndex), pageSize = int.Parse( pageSize) };
            }
            if (!string.IsNullOrEmpty(sortField))
            {
                this.sort = new SortItem { sortField = sortField, sortOrder = sortOrder };
            }
            if (!string.IsNullOrEmpty(filter))
            {
                this.queryItems = JsonHelper.Json2Object<List<QueryItem>>(filter);
            }
           
        }
        //生成常量表达式
        private ConstantExpression GetValueConstant(string value, Type type)
        {
            string typeName = type.Name.ToLower();
            ConstantExpression rtn = null;
            switch (typeName)
            {
                case "int32":
                    int intValue;
                    if (!int.TryParse(value, out intValue))
                    {
                        rtn = Expression.Constant(false);
                    }
                    else
                    {
                        rtn = Expression.Constant(intValue);

                    }
                    break;
                case "string":

                    rtn = Expression.Constant(value);
                    break;
                case "float":
                    float fValue;
                    if (!float.TryParse(value, out fValue))
                    {
                        rtn = Expression.Constant(false);
                    }
                    else
                    {
                        rtn = Expression.Constant(fValue);

                    }
                    break;
                case "single":
                    Single sgValue;
                    if (!Single.TryParse(value, out sgValue))
                    {
                        rtn = Expression.Constant(false);
                    }
                    else
                    {
                        rtn = Expression.Constant(sgValue);

                    }
                    break;
                case "decimal":
                    decimal dcValue;
                    if (!decimal.TryParse(value, out dcValue))
                    {
                        rtn = Expression.Constant(false);
                    }
                    else
                    {
                        rtn = Expression.Constant(dcValue);

                    }
                    break;
                case "double":
                    double dbValue;
                    if (!double.TryParse(value, out dbValue))
                    {
                        rtn = Expression.Constant(false);
                    }
                    else
                    {
                        rtn = Expression.Constant(dbValue);

                    }
                    break;
                case "datetime":
                    DateTime dateValue;
                    if (!DateTime.TryParse(value, out dateValue))
                    {
                        rtn = Expression.Constant(false);
                    }
                    else
                    {
                        rtn = Expression.Constant(dateValue);

                    }
                    break;

                default:
                    rtn = Expression.Constant(false);
                    break;




            }
            return rtn;

        }


        //生成列表常量表达式  实现 In ('a','b') 
        private ConstantExpression GetValueListConstant(string value, Type type)
        {
            string typeName = type.GenericTypeArguments.Length == 0 ? type.Name : type.GenericTypeArguments[0].Name;
            ConstantExpression rtn = null;
            switch (typeName.ToLower())
            {
                case "int32":
                    int intValue;
                    string[] arrInt = value.Split(',');
                    List<int> dlInt = new List<int>();
                    foreach (string a in arrInt)
                    {
                        if (int.TryParse(a, out intValue))
                        {
                            dlInt.Add(intValue);
                        }

                    }
                    if (dlInt.Count == 0)
                    {
                        rtn = Expression.Constant(false);

                    }
                    else
                    {
                        rtn = Expression.Constant(dlInt);
                    }

                    break;
                case "string":
                    List<string> dlStr = value.Split(',').ToList();
                    if (dlStr.Count == 0)
                    {
                        rtn = Expression.Constant(false);

                    }
                    else
                    {
                        rtn = Expression.Constant(dlStr);
                    }
                    break;


                default:
                    rtn = Expression.Constant(false);
                    break;




            }
            return rtn;

        }


        /// <summary>
        /// 根据前台查询字段自动生成Lambad(支持=，like,between,in 查询)
        /// </summary>
        /// <returns></returns>
        public Expression<Func<TEntity, bool>> BulidWhere()
        {
            Type type = typeof(TEntity);
            string key = "";
            string value = "";
            string match = "";
            string innerkey = "";
            ParameterExpression instance = Expression.Parameter(type);
            BinaryExpression result = Expression.Equal(Expression.Constant(true), Expression.Constant(true));
            if (queryItems == null) return Expression.Lambda<Func<TEntity, bool>>(result, instance);
            foreach (var item in queryItems)
            {
                key = item.key;

                value = item.value;//.ToLower();
                if (string.IsNullOrEmpty(value)) continue;
                match = item.match.ToLower();
                innerkey = !string.IsNullOrEmpty(item.innerkey) ? item.innerkey : key;
                PropertyInfo propertyInfo = type.GetProperty(innerkey);
                var proFullType = propertyInfo.PropertyType;
                Type propertyType = proFullType.GenericTypeArguments.Length == 0 ? proFullType : proFullType.GenericTypeArguments[0];
                var valueExpression = match == "in" ? this.GetValueListConstant(value, propertyType) : this.GetValueConstant(value, propertyType);
                MemberExpression propertyExpression = Expression.Property(instance, propertyInfo);
                if (proFullType.Name.Contains("Nullable"))
                {
                    propertyExpression = Expression.Property(propertyExpression, "Value");
                }
                var falseExpression = (Expression)Expression.Constant(false);
                if (valueExpression.Value.ToString() == "False")
                {

                    result = Expression.And(result, falseExpression);
                    continue;
                }
                switch (match)
                {
                    case "=":
                        result = Expression.And(result, Expression.Equal(propertyExpression, valueExpression));
                        break;
                    case "like":
                        if (propertyType == typeof(string))
                        {
                            var like = Expression.Call(propertyExpression, typeof(string).GetMethod("Contains"), valueExpression);
                            result = Expression.And(result, like);
                        }
                        else
                        {
                            result = Expression.And(result, falseExpression);

                        }
                        break;
                    case "in":
                        if (propertyType == typeof(string) || propertyType == typeof(Int32))
                        {
                            var inExp = Expression.Call(valueExpression, valueExpression.Type.GetMethod("Contains", new Type[] { propertyType }), propertyExpression);
                            result = Expression.And(result, inExp);
                        }
                        else
                        {
                            result = Expression.And(result, falseExpression);

                        }

                        break;
                    case "from":

                        if (propertyType.IsValueType)
                        {

                            var from = Expression.GreaterThanOrEqual(propertyExpression, valueExpression);
                            result = Expression.And(result, from);
                        }
                        else
                        {
                            result = Expression.And(result, falseExpression);

                        }
                        break;
                    case "to":
                        if (propertyType.IsValueType)
                        {

                            var from = Expression.LessThanOrEqual(propertyExpression, valueExpression);
                            result = Expression.And(result, from);
                        }
                        else
                        {
                            result = Expression.And(result, falseExpression);

                        }
                        break;
                }
            }
            var lambda = Expression.Lambda<Func<TEntity, bool>>(result, instance);
            return lambda;

        }
    }
}

这一套自动查询支持对应sql的 In,=,Like ,Between 查询，原理上也支持Not Like, Not In但是一般给用户的查询不会用到这些查询。

扩展EF框架的 DBSet：

namespace App.PageBase.Query
{
    // 摘要: 
    //     提供一组用于查询实现 System.Linq.IQueryable<T> 的数据结构的 static（在 Visual Basic 中为 Shared）方法。
    public static class DbSet
    {
        /// <summary>
        /// 按QueryBulider自动生成 过滤，排序,分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="qb"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        public static IQueryable<T> Query<T>(this DbSet<T> qb, QueryBulider<T> query) where T : class,new()
        {

            var IQ = qb.Where(query.BulidWhere());
            if (query.sort == null && query.pager != null)
            {
                throw new Exception("列表分页时必须指定排序字段");
            }

            Type type = typeof(T);
            var callWhere = IQ.Expression;
            if (query.sort != null)
            {
                var sortFieldProperty = type.GetProperty(query.sort.sortField);
                var instance =Expression.Parameter(type);
                var sortFieldExpression = Expression.Property(instance, sortFieldProperty);
                string OrderName = query.sort.sortOrder;
                if (OrderName.ToLower() == "desc")
                {
                    OrderName = "OrderByDescending";
                }
                else
                {
                    OrderName = "OrderBy";
                }

                Expression.Lambda(sortFieldExpression, instance);
                callWhere = Expression.Call(typeof(Queryable), OrderName, new Type[] { type, sortFieldProperty.PropertyType }, callWhere, Expression.Lambda(sortFieldExpression, instance));
            }
            if (query.pager != null)
            {
                IQ = IQ.Provider.CreateQuery<T>(callWhere).Skip(query.pager.pageIndex * query.pager.pageSize).Take(query.pager.pageSize);
            }

            return IQ;

        }


    }

   后台页面调用：

   var  queryBulider = new QueryBulider<UserInfo>(Request.Form);

   var dl = db.Set<UserInfo>().Query(queryBulider);

当然前台js组件不同，前台的封装就不一样。MiniUi我是这样弄的。

///组合查询条件

function GetQueryFormData(formId) {
var data = [];
if (!formId) formId = "queryForm";
var form = new mini.Form("#" + formId);
var fields = form.getFields();
var arr = [];
for (var i = 0; i < fields.length; i++) {
var item = {};
item["key"] = fields[i].id;
item["value"] = fields[i].value;
item["match"] = fields[i].match;
item["innerkey"] = fields[i].innerkey;
arr.push(item);
}

return arr;
}

///查询事件

function search() {
var grid = mini.get("datagrid1");
var query = GetQueryFormData();
var json = mini.encode(query);
grid.load({ filter: json });
}