动态拼接LINQ查询条件的解决方案

开发中，需要根据用户选择的过滤条件从数据库中查询数据。过滤条件包括等于（”==”）、不等于(“!=”)、大于(“>”)、小于（”<”）、大于等于(“>=”)、小于等于(“<=”)、包含（”in”）、不包含（”out”）八种。过滤条件之间可以是“AND”和“OR”两种关系。过滤条件支持的数据类型有整型和字符串等。用户选择的过滤条件通过json数据提交给后端，后端反序列化后得到过滤条件对象，该对象是FilterModel类的实例，下面是FilterModel类的定义。

    public class FilterModel
    {
public string column { get; set; }//过滤条件中使用的数据列
public string action { get; set; }//过滤条件中的操作:==、!=等
public string logic { get; set; }//过滤条件之间的逻辑关系：AND和OR
public string value { get; set; }//过滤条件中的操作的值
public string dataType { get; set; }//过滤条件中的操作的字段的类型
    }

数据库操作使用ADO.NET EF技术，查询使用Linq。而Linq的扩展方法接收的是一个lambda表达式作为查询条件。那么怎样可以将用户选择的查询条件转换成需要的lambda表达式呢？本文给出了自己的解决方案。
首先，定义下面的泛型方法GetFilterExpression，该方法完成lambda表达式的拼接。GetFilterExpression方法中泛型参数T为需要操作的数据库表对象，输入参数为FilterModel类的实例集合，包含用户选择的所有条件，遍历该集合，调用CreateLambda()方法生成条件对应的lambda表达式，虽有根据条件之间的关系是“AND”还是“OR”完成lambda表达式的拼接工作。

        public static Expression<Func<T, bool>> GetFilterExpression<T>(List<FilterModel> filterConditionList)
        {
            Expression<Func<T, bool>> condition = null;
try
            {
if (filterConditionList != null && filterConditionList.Count > 0)
                    {                        
foreach (FilterModel filterCondition in filterConditionList)
                        {
                            Expression<Func<T, bool>> tempCondition = CreateLambda<T>(filterCondition);
if (condition == null)
                            {
                                condition = tempCondition;
                            }
else
                            {
if ("AND".Equals(filterCondition.logic))
                                {
                                    condition = condition.And(tempCondition);
                                }
else
                                {
                                    condition = condition.Or(tempCondition);
                                }
                            }
                        }
                    }
            }
catch (Exception ex)
            {
                LogHelper.WriteLogException("获取筛选条件异常:" + ex.Message);
            }
return condition;
        }

接下来，介绍CreateLambda()方法的逻辑，该方法完成过滤条件到lambda表达式的生成操作。

        public static Expression<Func<T, bool>> CreateLambda<T>(FilterModel filterCondition)
        {
var parameter = Expression.Parameter(typeof(T), "p");//创建参数i
var constant = Expression.Constant(filterCondition.value);//创建常数
            MemberExpression member = Expression.PropertyOrField(parameter, filterCondition.column);
if ("=".Equals(filterCondition.action))
            {
return Expression.Lambda<Func<T, bool>>(Expression.Equal(member, constant), parameter);
            }
else if ("!=".Equals(filterCondition.action))
            {
return Expression.Lambda<Func<T, bool>>(Expression.NotEqual(member, constant), parameter);
            }
else if (">".Equals(filterCondition.action))
            {
return Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(member, constant), parameter);
            }
else if ("<".Equals(filterCondition.action))
            {
return Expression.Lambda<Func<T, bool>>(Expression.LessThan(member, constant), parameter);
            }
else if (">=".Equals(filterCondition.action))
            {
return Expression.Lambda<Func<T, bool>>(Expression.GreaterThanOrEqual(member, constant), parameter);
            }
else if ("<=".Equals(filterCondition.action))
            {
return Expression.Lambda<Func<T, bool>>(Expression.LessThanOrEqual(member, constant), parameter);
            }
else if ("in".Equals(filterCondition.action) && "1".Equals(filterCondition.dataType))
            {
return GetExpressionWithMethod<T>("Contains", filterCondition);
            }
else if ("out".Equals(filterCondition.action) && "1".Equals(filterCondition.dataType))
            {
return GetExpressionWithoutMethod<T>("Contains", filterCondition);
            }
else
            {
return null;
            }
        }

CreateLambda(）方法根据判断条件的类型,调用Expression的Equal、NotEqual、GreaterThan、LessThan、LessThanOrEqual、GreaterThanOrEqual方法来生成lambda表达式，而对于”包含”和”不包含”，需要调用字符串的Contains()方法来完成。而这部分逻辑在GetExpressionWithMethod()和GetExpressionWithoutMethod(）方法中实现。
“不包含”是在可看成是” 包含”的否定(Not)。

        public static Expression<Func<T, bool>> GetExpressionWithMethod<T>(string methodName, FilterModel filterCondition)
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(T), "p");
            MethodCallExpression methodExpression = GetMethodExpression(methodName, filterCondition.column, filterCondition.value, parameterExpression);
return Expression.Lambda<Func<T, bool>>(methodExpression, parameterExpression);
        }

public static Expression<Func<T, bool>> GetExpressionWithoutMethod<T>(string methodName, FilterModel filterCondition)
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(T), "p");
            MethodCallExpression methodExpression = GetMethodExpression(methodName, filterCondition.column, filterCondition.value, parameterExpression);
var notMethodExpression = Expression.Not(methodExpression);
return Expression.Lambda<Func<T, bool>>(notMethodExpression, parameterExpression);
        }

/// <summary>
/// 生成类似于p=>p.values.Contains("xxx");的lambda表达式
/// parameterExpression标识p，propertyName表示values，propertyValue表示"xxx",methodName表示Contains
/// 仅处理p的属性类型为string这种情况
/// </summary>
/// <param name="methodName"></param>
/// <param name="propertyName"></param>
/// <param name="propertyValue"></param>
/// <param name="parameterExpression"></param>
/// <returns></returns>
private static MethodCallExpression GetMethodExpression(string methodName, string propertyName, string propertyValue, ParameterExpression parameterExpression)
        {            
var propertyExpression = Expression.Property(parameterExpression, propertyName);
            MethodInfo method = typeof(string).GetMethod(methodName, new[] { typeof(string) });
var someValue = Expression.Constant(propertyValue, typeof(string));
return Expression.Call(propertyExpression, method, someValue);
        }

最后，介绍一下拼接lambda表达式的实现代码。LinqBuilder类提供 Or()和And()来拼接关系是”且”和”或”的lambda表达式。这部分代码来源于网络。

    public static class LinqBuilder
    {
/// <summary>
/// 默认True条件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Expression<Func<T, bool>> True<T>() { return f => true; }

/// <summary>
/// 默认False条件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Expression<Func<T, bool>> False<T>() { return f => false; }

/// <summary>
/// 拼接 OR 条件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp"></param>
/// <param name="condition"></param>
/// <returns></returns>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> exp, Expression<Func<T, bool>> condition)
        {
var inv = Expression.Invoke(condition, exp.Parameters.Cast<Expression>());
return Expression.Lambda<Func<T, bool>>(Expression.Or(exp.Body, inv), exp.Parameters);
        }

/// <summary>
/// 拼接And条件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exp"></param>
/// <param name="condition"></param>
/// <returns></returns>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> exp, Expression<Func<T, bool>> condition)
        {
var inv = Expression.Invoke(condition, exp.Parameters.Cast<Expression>());
return Expression.Lambda<Func<T, bool>>(Expression.And(exp.Body, inv), exp.Parameters);
        }
    }