9.1.2 asp.net core 自动生成组合查询

在做系统的时候，经常遇到前台录入一大堆的查询条件，然后点击查询提交后台，在Controller里面生成对应的查询SQL或者表达式，数据库执行再将结果返回客户端。

例如如下页面，输入三个条件，日志类型、开始和结束日期，查询后台系统操作日志，并显示。

这种类似页面在系统中还是比较多的，通常情况下，我们会在cshtml中放上日志类型、开始、结束日期这三个控件，controller的action有对应的三个参数，然后在action、逻辑层或者仓储层实现将这三个参数转换为linq，例如转成c=>c.BeginDate>=beginDate && c.EndDate < endDate.AddDay(1) && c.OperType == operType。

这里有个小技巧，就是结束日期小于录入的结束日期+1天。一般大家页面中录入结束日期的时候都是只到日期，不带时分秒，例如结束日期为2016年1月31日，endDate 就是2016-01-31。其实这时候，大家的想法是到2016年1月31日23:59:59秒止。如果数据库中存储的是带时分秒的时间，例如2016-01-31 10:00:00.000，而程序中写的是c.EndDate < endDate的话，那么这个2016年1月31日零点之后的全不满足条件。所以，这里应该是小于录入的结束日期+1。

如果我们有更多的条件怎么办？如果有的条件允许为空怎么办？如果有几十个这样的页面的？难道要一个个的去写么？

基于以上的考虑，我们为了简化操作，编写了自动生成组合查询条件的通用框架。做法主要有如下几步：

• 前端页面采用一定的格式设置html控件的Id和Name。
• 编写ModelBinder，接收前台传来的参数，生成查询条件类
• 将查询条件类转换为SQL语句（petapoco等框架）或者表达式（EF框架），我们.netcore下用的是ef，因此只说明表达式的做法。peta的我们在.net framework下也实现了，在此不做叙述。
• 提交数据库执行

下面详细介绍下具体的过程。

1、前端页面采用一定的格式设置Html控件的Id和Name，这里我们约定的写法是{Op}__{PropertyName}，就是操作符、两个下划线、属性名。

<form asp-action="List" method="post" class="form-inline">
  <div class="form-group">
    <label class="col-md-4 col-xs-4 col-sm-4 control-label">日志类型：</label>
    <div class="col-md-8 col-xs-8 col-sm-8">
      <select id="Eq__LogOperType" name="Eq__LogOperType" class="form-control" asp-items="@operateTypes"></select>
    </div>
  </div>
  <div class="form-group">
    <label class="col-md-4 col-xs-4 col-sm-4 control-label">日期：</label>
    <div class="col-md-8 col-xs-8 col-sm-8">
      <input type="date" id="Gte__CreateDate" name="Gte__CreateDate" class="form-control" value="@queryCreateDateStart.ToDateString()" />
    </div>
  </div>
  <div class="form-group">
    <label class="col-md-4 col-xs-4 col-sm-4 control-label"> - </label>
    <div class="col-md-8 col-xs-8 col-sm-8">
      <input type="date" id="Lt__CreateDate" name="Lt__CreateDate" class="form-control" value="@queryCreateDateEnd.ToDateString()" />
    </div>
  </div>
  <button class="btn btn-primary" type="submit">查询</button>
</form>

例如，日志类型查询条件要求日志类型等于所选择的类型。日志类的日志类型属性是LogOperType，等于的操作符是Eq，这样Id就是Eq__LogOperType。同样的操作日期在开始和结束日期范围内，开始和结束日期的Id分别为Gte__CreateDate和Lt__CreateDate。

2、编写ModelBinder，接收前端传来的参数，生成查询条件类。

这里，我们定义一个查询条件类，QueryConditionCollection，注释写的还是比较明确的：

    /// <summary>
    /// 操作条件集合
    /// </summary>
    public class QueryConditionCollection : KeyedCollection<string, QueryConditionItem>
    {
        /// <summary>
        /// 初始化
        /// </summary>
        public QueryConditionCollection()
            : base()
        {
        }

        /// <summary>
        /// 从指定元素提取键
        /// </summary>
        /// <param name="item">从中提取键的元素</param>
        /// <returns>指定元素的键</returns>
        protected override string GetKeyForItem(QueryConditionItem item)
        {
            return item.Key;
        }
    }

    /// <summary>
    /// 操作条件
    /// </summary>
    public class QueryConditionItem
    {
        /// <summary>
        /// 主键
        /// </summary>
        public string Key { get; set; }
        /// <summary>
        /// 名称
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 条件操作类型
        /// </summary>
        public QueryConditionType Op { get; set; }

        ///// <summary>
        ///// DataValue是否包含单引号，如'DataValue'
        ///// </summary>
        //public bool IsIncludeQuot { get; set; }

        /// <summary>
        /// 数据的值
        /// </summary>
        public object DataValue { get; set; }
    }

按照我们的设计，上面日志查询例子应该产生一个QueryConditionCollection，包含三个QueryConditionItem，分别是日志类型、开始和结束日期条件项。可是，如何通过前端页面传来的请求数据生成QueryConditionCollection呢？这里就用到了ModelBinder。ModelBinder是MVC的数据绑定的核心，主要作用就是从当前请求提取相应的数据绑定到目标Action方法的参数上。

    public class QueryConditionModelBinder : IModelBinder
    {
        private readonly IModelMetadataProvider _metadataProvider;
        private const string SplitString = "__";

        public QueryConditionModelBinder(IModelMetadataProvider metadataProvider)
        {
            _metadataProvider = metadataProvider;
        }

        public async Task BindModelAsync(ModelBindingContext bindingContext)
        {
            QueryConditionCollection model = (QueryConditionCollection)(bindingContext.Model ?? new QueryConditionCollection());

            IEnumerable<KeyValuePair<string, StringValues>> collection = GetRequestParameter(bindingContext);

            List<string> prefixList = Enum.GetNames(typeof(QueryConditionType)).Select(s => s + SplitString).ToList();

            foreach (KeyValuePair<string, StringValues> kvp in collection)
            {
                string key = kvp.Key;
                if (key != null && key.Contains(SplitString) && prefixList.Any(s => key.StartsWith(s, StringComparison.CurrentCultureIgnoreCase)))
                {
                    string value = kvp.Value.ToString();
                    if (!string.IsNullOrWhiteSpace(value))
                    {
                        AddQueryItem(model, key, value);
                    }
                }
            }

            bindingContext.Result = ModelBindingResult.Success(model);

            //todo: 是否需要加上这一句？
            await Task.FromResult(0);
        }

        private void AddQueryItem(QueryConditionCollection model, string key, string value)
        {
            int pos = key.IndexOf(SplitString);
            string opStr = key.Substring(0, pos);
            string dataField = key.Substring(pos + 2);

            QueryConditionType operatorEnum = QueryConditionType.Eq;
            if (Enum.TryParse<QueryConditionType>(opStr, true, out operatorEnum))
                model.Add(new QueryConditionItem
                {
                    Key = key,
                    Name = dataField,
                    Op = operatorEnum,
                    DataValue = value
                });
        }
  }

主要流程是，从当前上下文中获取请求参数（Querystring、Form等），对于每个符合格式要求的请求参数生成QueryConditionItem并加入到QueryConditionCollection中。

为了将ModelBinder应用到系统中，我们还得增加相关的IModelBinderProvider。这个接口的主要作用是提供相应的ModelBinder对象。为了能够应用QueryConditionModelBinder，我们必须还要再写一个QueryConditionModelBinderProvider，继承IModelBinderProvider接口。

    public class QueryConditionModelBinderPrivdier : IModelBinderProvider
    {
        public IModelBinder GetBinder(ModelBinderProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (context.Metadata.ModelType != typeof(QueryConditionCollection))
            {
                return null;
            }

            return new QueryConditionModelBinder(context.MetadataProvider);
        }
    }

下面就是是在Startup中注册ModelBinder。

services.AddMvc(options =>

{

     options.ModelBinderProviders.Insert(0, new QueryConditionModelBinderPrivdier());

});

3、将查询类转换为EF的查询Linq表达式。

我们的做法是在QueryConditionCollection类中编写方法GetExpression。这个只能贴代码了，里面有相关的注释，大家可以仔细分析下程序。

        public Expression<Func<T, bool>> GetExpression<T>()
        {
            if (this.Count() == 0)
            {
                return c => true;
            }

            //构建 c=>Body中的c
            ParameterExpression param = Expression.Parameter(typeof(T), "c");

            //获取最小的判断表达式
            var list = Items.Select(item => GetExpression<T>(param, item));
            //再以逻辑运算符相连
            var body = list.Aggregate(Expression.AndAlso);

            //将二者拼为c=>Body
            return Expression.Lambda<Func<T, bool>>(body, param);
        }

        private Expression GetExpression<T>(ParameterExpression param, QueryConditionItem item)
        {
            //属性表达式
            LambdaExpression exp = GetPropertyLambdaExpression<T>(item, param);

            //常量表达式
            var constant = ChangeTypeToExpression(item, exp.Body.Type);

            //以判断符或方法连接
            return ExpressionDict[item.Op](exp.Body, constant);
        }

        private LambdaExpression GetPropertyLambdaExpression<T>(QueryConditionItem item, ParameterExpression param)
        {
            //获取每级属性如c.Users.Proiles.UserId
            var props = item.Name.Split('.');

            Expression propertyAccess = param;

            Type typeOfProp = typeof(T);

            int i = 0;
            do
            {
                PropertyInfo property = typeOfProp.GetProperty(props[i]);
                if (property == null) return null;
                typeOfProp = property.PropertyType;
                propertyAccess = Expression.MakeMemberAccess(propertyAccess, property);
                i++;
            } while (i < props.Length);

            return Expression.Lambda(propertyAccess, param);
        }

        #region ChangeType
        /// <summary>
        /// 转换SearchItem中的Value的类型，为表达式树
        /// </summary>
        /// <param name="item"></param>
        /// <param name="conversionType">目标类型</param>
        private Expression ChangeTypeToExpression(QueryConditionItem item, Type conversionType)
        {
            if (item.DataValue == null)
                return Expression.Constant(item.DataValue, conversionType);

            #region 数组
            if (item.Op == QueryConditionType.In)
            {
                var arr = (item.DataValue as Array);
                var expList = new List<Expression>();
                //确保可用
                if (arr != null)
                    for (var i = 0; i < arr.Length; i++)
                    {
                        //构造数组的单元Constant
                        var newValue = arr.GetValue(i);
                        expList.Add(Expression.Constant(newValue, conversionType));
                    }

                //构造inType类型的数组表达式树，并为数组赋初值
                return Expression.NewArrayInit(conversionType, expList);
            }
            #endregion

            var value = conversionType.GetTypeInfo().IsEnum ? Enum.Parse(conversionType, (string)item.DataValue)
                : Convert.ChangeType(item.DataValue, conversionType);

            return Expression.Convert(((Expression<Func<object>>)(() => value)).Body, conversionType);
        }
        #endregion

        #region SearchMethod 操作方法
        private readonly Dictionary<QueryConditionType, Func<Expression, Expression, Expression>> ExpressionDict =
            new Dictionary<QueryConditionType, Func<Expression, Expression, Expression>>
                {
                    {
                        QueryConditionType.Eq,
                        (left, right) => { return Expression.Equal(left, right); }
                        },
                    {
                        QueryConditionType.Gt,
                        (left, right) => { return Expression.GreaterThan(left, right); }
                        },
                    {
                        QueryConditionType.Gte,
                        (left, right) => { return Expression.GreaterThanOrEqual(left, right); }
                        },
                    {
                        QueryConditionType.Lt,
                        (left, right) => { return Expression.LessThan(left, right); }
                        },
                    {
                        QueryConditionType.Lte,
                        (left, right) => { return Expression.LessThanOrEqual(left, right); }
                        },
                    {
                        QueryConditionType.Contains,
                        (left, right) =>
                            {
                                if (left.Type != typeof (string)) return null;
                                return Expression.Call(left, typeof (string).GetMethod("Contains"), right);
                            }
                        },
                    {
                        QueryConditionType.In,
                        (left, right) =>
                            {
                                if (!right.Type.IsArray) return null;
                                //调用Enumerable.Contains扩展方法
                                MethodCallExpression resultExp =
                                    Expression.Call(
                                        typeof (Enumerable),
                                        "Contains",
                                        new[] {left.Type},
                                        right,
                                        left);

                                return resultExp;
                            }
                        },
                    {
                        QueryConditionType.Neq,
                        (left, right) => { return Expression.NotEqual(left, right); }
                        },
                    {
                        QueryConditionType.StartWith,
                        (left, right) =>
                            {
                                if (left.Type != typeof (string)) return null;
                                return Expression.Call(left, typeof (string).GetMethod("StartsWith", new[] {typeof (string)}), right);

                            }
                        },
                    {
                        QueryConditionType.EndWith,
                        (left, right) =>
                            {
                                if (left.Type != typeof (string)) return null;
                                return Expression.Call(left, typeof (string).GetMethod("EndsWith", new[] {typeof (string)}), right);
                            }
                     }
                };
        #endregion

4、提交数据库执行并反馈结果

在生成了表达式后，剩下的就比较简单了。仓储层直接写如下的语句即可：

var query = this.dbContext.OperLogs.AsNoTracking().Where(predicate).OrderByDescending(o => o.CreateDate).ThenBy(o => o.OperLogId);

predicate就是从QueryConditionCollection.GetExpression方法中生成的，类似

Expression<Func<OperLogInfo, bool>> predicate = conditionCollection.GetExpression<OperLogInfo>();

QueryConditionCollection从哪里来呢？因为有了ModelBinder，Controller的Action上直接加上参数，类似

public async Task<IActionResult> List(QueryConditionCollection queryCondition) { ... }

至此，自动生成的组合查询就基本完成了。之后我们程序的写法，只需要在前端页面定义查询条件的控件，Controller的Action中加上QueryConditionCollection参数，然后调用数据库前将QueryConditionCollection转换为表达式就OK了。不再像以往一样在cshtml、Controller中写一大堆的程序代码了，在条件多、甚至有可选条件时，优势更为明显。

面向云的.net core开发框架