PredicateBuilder 对 ADO.Net Entity Framework 支持的改进

曾几何时，网络上曾经大传 PredicateBuilder 用于拼接两个 Lambda 表达式树。在对内存数据的筛选上面，其简洁方便的操作大放异彩，但是对数据库操作的不支持，一直是其硬伤。PredicateBuilder 拼接表达式的过程中，产生的 Invoke 表达式无法翻译成 SQL 语句，这是其根本原因。另外，Invoke 表达式编译后，形成的委托调用委托的方式，也是对性能的一种损耗。

 

当然，也有很多人对其做过改造，不过给人的感觉，总不是那么完美。以前，因为种种原因，我们不得不忍受这种问题。前几天，由于工作中用到了 Entity Framework 和动态拼接 Lambda 表达式树，为了避免全表查询的尴尬，硬着头皮研究改造 PredicateBuilder —— 各种纠结。还好，了解透彻原理后就很简单了。期间，用到了下面这个测试类：

public class Person
{
    public int ID { get; set; }
    public string Name { get; set; }
}

 

这里先说一下要达到的目的：

两个表达式：

Expression<Func<Person, bool>> a = p => p.ID == 3;
Expression<Func<Person, bool>> b = c => c.Name == "张三";

拼接之后，想要达成如下形式：

Expression<Func<Person, bool>> x = y => y.ID == 3 && y.Name == "张三";

原始 PredicateBuilder 用的是 Invoke 表达式，也就是说没有解析待拼接的表达式。我们可以解析一下，看看能否达到效果。

 

首先来看相同点：

表达式 a ：根是一个相等判断的二元表达式，其左子树是属性的调用的表达式，右子树是一个数字常量表达式。

表达式 b ：根是一个相等判断的二元表达式，其左子树是属性的调用的表达式，右子树是一个数字常量表达式。

下面看不同：

表达式 a 参数名字是 p ，表达式 b 参数名字是 c —— 两者参数的名称不同，但是类型是相同的。

 

对于目标表达式，这里我第一印象是把右边表达式的参数，改成左边的，然后把左右两边表达式的 Body 拼接，加上左边的参数，这就是目标表达式树。经过分析，这种做法是可行的，下面上代码，代码不解释：

/// <summary>
/// 谓词表达式构建器
/// </summary>
public static class PredicateBuilder
{
    #region Expression Joiner
    /// <summary>
    /// 创建一个值恒为 <c>true</c> 的表达式。
    /// </summary>
    /// <typeparam name="T">表达式方法类型</typeparam>
    /// <returns>一个值恒为 <c>true</c> 的表达式。</returns>
    public static Expression<Func<T, bool>> True<T>() { return p => true; }

    /// <summary>
    /// 创建一个值恒为 <c>false</c> 的表达式。
    /// </summary>
    /// <typeparam name="T">表达式方法类型</typeparam>
    /// <returns>一个值恒为 <c>false</c> 的表达式。</returns>
    public static Expression<Func<T, bool>> False<T>() { return f => false; }

    /// <summary>
    /// 使用 Expression.OrElse 的方式拼接两个 System.Linq.Expression。
    /// </summary>
    /// <typeparam name="T">表达式方法类型</typeparam>
    /// <param name="left">左边的 System.Linq.Expression 。</param>
    /// <param name="right">右边的 System.Linq.Expression。</param>
    /// <returns>拼接完成的 System.Linq.Expression。</returns>
    public static Expression<T> Or<T>(this Expression<T> left, Expression<T> right)
    {
        return MakeBinary(left, right, Expression.OrElse);
    }

    /// <summary>
    /// 使用 Expression.AndAlso 的方式拼接两个 System.Linq.Expression。
    /// </summary>
    /// <typeparam name="T">表达式方法类型</typeparam>
    /// <param name="left">左边的 System.Linq.Expression 。</param>
    /// <param name="right">右边的 System.Linq.Expression。</param>
    /// <returns>拼接完成的 System.Linq.Expression。</returns>
    public static Expression<T> And<T>(this Expression<T> left, Expression<T> right)
    {
        return MakeBinary(left, right, Expression.AndAlso);
    }

    /// <summary>
    /// 使用自定义的方式拼接两个 System.Linq.Expression。
    /// </summary>
    /// <typeparam name="T">表达式方法类型</typeparam>
    /// <param name="left">左边的 System.Linq.Expression 。</param>
    /// <param name="right">右边的 System.Linq.Expression。</param>
    /// <returns>拼接完成的 System.Linq.Expression。</returns>
    public static Expression<T> MakeBinary<T>(this Expression<T> left, Expression<T> right, Func<Expression, Expression, Expression> func)
    {
        return MakeBinary((LambdaExpression)left, right, func) as Expression<T>;
    }

    /// <summary>
    /// 拼接两个 <paramref name="System.Linq.Expression"/> ，两个 <paramref name="System.Linq.Expression"/> 的参数必须完全相同。
    /// </summary>
    /// <typeparam name="T">表达式中的元素类型</typeparam>
    /// <param name="left">左边的 <paramref name="System.Linq.Expression"/></param>
    /// <param name="right">右边的 <paramref name="System.Linq.Expression"/></param>
    /// <param name="func">表达式拼接的具体逻辑</param>
    /// <returns>拼接完成的 <paramref name="System.Linq.Expression"/></returns>
    public static LambdaExpression MakeBinary(this LambdaExpression left, LambdaExpression right, Func<Expression, Expression, Expression> func)
    {
        var data = Combinate(right.Parameters, left.Parameters).ToArray();
        right = ParameterReplace.Replace(right, data) as LambdaExpression;
        return Expression.Lambda(func(left.Body, right.Body), left.Parameters.ToArray());
    }
    #endregion

    #region Private Methods
    private static IEnumerable<KeyValuePair<T, T>> Combinate<T>(IEnumerable<T> left, IEnumerable<T> right)
    {
        var a = left.GetEnumerator();
        var b = right.GetEnumerator();
        while (a.MoveNext() && b.MoveNext())
            yield return new KeyValuePair<T, T>(a.Current, b.Current);
    }
    #endregion
}

#region class: ParameterReplace
internal sealed class ParameterReplace : ExpressionVisitor
{
    public static Expression Replace(Expression e, IEnumerable<KeyValuePair<ParameterExpression, ParameterExpression>> paramList)
    {
        var item = new ParameterReplace(paramList);
        return item.Visit(e);
    }

    private Dictionary<ParameterExpression, ParameterExpression> parameters = null;

    public ParameterReplace(IEnumerable<KeyValuePair<ParameterExpression, ParameterExpression>> paramList)
    {
        parameters = paramList.ToDictionary(p => p.Key, p => p.Value, new ParameterEquality());
    }

    protected override Expression VisitParameter(ParameterExpression p)
    {
        ParameterExpression result;
        if (parameters.TryGetValue(p, out result))
            return result;
        else
            return base.VisitParameter(p);
    }

    #region class: ParameterEquality
    private class ParameterEquality : IEqualityComparer<ParameterExpression>
    {
        public bool Equals(ParameterExpression x, ParameterExpression y)
        {
            if (x == null || y == null)
                return false;

            return x.Type == y.Type;
        }

        public int GetHashCode(ParameterExpression obj)
        {
            if (obj == null)
                return 0;

            return obj.Type.GetHashCode();
        }
    }
    #endregion
}
#endregion

 

如果是在 .Net 3.5 下运行的话，还少一个 ExpressionVisitor 类，在 .Net 4.0 就不需要了，顺便把代码贴上来，需要的就拿走吧：

#region class: ExpressionVisitor
[DebuggerStepThrough]
public abstract class ExpressionVisitor
{
    protected ExpressionVisitor()
    {
    }

    protected virtual Expression Visit(Expression exp)
    {
        if (exp == null)
            return exp;
        switch (exp.NodeType)
        {
            case ExpressionType.Negate:
            case ExpressionType.NegateChecked:
            case ExpressionType.Not:
            case ExpressionType.Convert:
            case ExpressionType.ConvertChecked:
            case ExpressionType.ArrayLength:
            case ExpressionType.Quote:
            case ExpressionType.TypeAs:
                return this.VisitUnary((UnaryExpression)exp);
            case ExpressionType.Add:
            case ExpressionType.AddChecked:
            case ExpressionType.Subtract:
            case ExpressionType.SubtractChecked:
            case ExpressionType.Multiply:
            case ExpressionType.MultiplyChecked:
            case ExpressionType.Divide:
            case ExpressionType.Modulo:
            case ExpressionType.And:
            case ExpressionType.AndAlso:
            case ExpressionType.Or:
            case ExpressionType.OrElse:
            case ExpressionType.LessThan:
            case ExpressionType.LessThanOrEqual:
            case ExpressionType.GreaterThan:
            case ExpressionType.GreaterThanOrEqual:
            case ExpressionType.Equal:
            case ExpressionType.NotEqual:
            case ExpressionType.Coalesce:
            case ExpressionType.ArrayIndex:
            case ExpressionType.RightShift:
            case ExpressionType.LeftShift:
            case ExpressionType.ExclusiveOr:
                return this.VisitBinary((BinaryExpression)exp);
            case ExpressionType.TypeIs:
                return this.VisitTypeIs((TypeBinaryExpression)exp);
            case ExpressionType.Conditional:
                return this.VisitConditional((ConditionalExpression)exp);
            case ExpressionType.Constant:
                return this.VisitConstant((ConstantExpression)exp);
            case ExpressionType.Parameter:
                return this.VisitParameter((ParameterExpression)exp);
            case ExpressionType.MemberAccess:
                return this.VisitMemberAccess((MemberExpression)exp);
            case ExpressionType.Call:
                return this.VisitMethodCall((MethodCallExpression)exp);
            case ExpressionType.Lambda:
                return this.VisitLambda((LambdaExpression)exp);
            case ExpressionType.New:
                return this.VisitNew((NewExpression)exp);
            case ExpressionType.NewArrayInit:
            case ExpressionType.NewArrayBounds:
                return this.VisitNewArray((NewArrayExpression)exp);
            case ExpressionType.Invoke:
                return this.VisitInvocation((InvocationExpression)exp);
            case ExpressionType.MemberInit:
                return this.VisitMemberInit((MemberInitExpression)exp);
            case ExpressionType.ListInit:
                return this.VisitListInit((ListInitExpression)exp);
            default:
                throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
        }
    }

    protected virtual MemberBinding VisitBinding(MemberBinding binding)
    {
        switch (binding.BindingType)
        {
            case MemberBindingType.Assignment:
                return this.VisitMemberAssignment((MemberAssignment)binding);
            case MemberBindingType.MemberBinding:
                return this.VisitMemberMemberBinding((MemberMemberBinding)binding);
            case MemberBindingType.ListBinding:
                return this.VisitMemberListBinding((MemberListBinding)binding);
            default:
                throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
        }
    }

    protected virtual ElementInit VisitElementInitializer(ElementInit initializer)
    {
        ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments);
        if (arguments != initializer.Arguments)
        {
            return Expression.ElementInit(initializer.AddMethod, arguments);
        }
        return initializer;
    }

    protected virtual Expression VisitUnary(UnaryExpression u)
    {
        Expression operand = this.Visit(u.Operand);
        if (operand != u.Operand)
        {
            return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);
        }
        return u;
    }

    protected virtual Expression VisitBinary(BinaryExpression b)
    {
        Expression left = this.Visit(b.Left);
        Expression right = this.Visit(b.Right);
        Expression conversion = this.Visit(b.Conversion);
        if (left != b.Left || right != b.Right || conversion != b.Conversion)
        {
            if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)
                return Expression.Coalesce(left, right, conversion as LambdaExpression);
            else
                return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);
        }
        return b;
    }

    protected virtual Expression VisitTypeIs(TypeBinaryExpression b)
    {
        Expression expr = this.Visit(b.Expression);
        if (expr != b.Expression)
        {
            return Expression.TypeIs(expr, b.TypeOperand);
        }
        return b;
    }

    protected virtual Expression VisitConstant(ConstantExpression c)
    {
        return c;
    }

    protected virtual Expression VisitConditional(ConditionalExpression c)
    {
        Expression test = this.Visit(c.Test);
        Expression ifTrue = this.Visit(c.IfTrue);
        Expression ifFalse = this.Visit(c.IfFalse);
        if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)
        {
            return Expression.Condition(test, ifTrue, ifFalse);
        }
        return c;
    }

    protected virtual Expression VisitParameter(ParameterExpression p)
    {
        return p;
    }

    protected virtual Expression VisitMemberAccess(MemberExpression m)
    {
        Expression exp = this.Visit(m.Expression);
        if (exp != m.Expression)
        {
            return Expression.MakeMemberAccess(exp, m.Member);
        }
        return m;
    }

    protected virtual Expression VisitMethodCall(MethodCallExpression m)
    {
        Expression obj = this.Visit(m.Object);
        IEnumerable<Expression> args = this.VisitExpressionList(m.Arguments);
        if (obj != m.Object || args != m.Arguments)
        {
            return Expression.Call(obj, m.Method, args);
        }
        return m;
    }

    protected virtual ReadOnlyCollection<Expression> VisitExpressionList(ReadOnlyCollection<Expression> original)
    {
        List<Expression> list = null;
        for (int i = 0, n = original.Count; i < n; i++)
        {
            Expression p = this.Visit(original[i]);
            if (list != null)
            {
                list.Add(p);
            }
            else if (p != original[i])
            {
                list = new List<Expression>(n);
                for (int j = 0; j < i; j++)
                {
                    list.Add(original[j]);
                }
                list.Add(p);
            }
        }
        if (list != null)
        {
            return list.AsReadOnly();
        }
        return original;
    }

    protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
    {
        Expression e = this.Visit(assignment.Expression);
        if (e != assignment.Expression)
        {
            return Expression.Bind(assignment.Member, e);
        }
        return assignment;
    }

    protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
    {
        IEnumerable<MemberBinding> bindings = this.VisitBindingList(binding.Bindings);
        if (bindings != binding.Bindings)
        {
            return Expression.MemberBind(binding.Member, bindings);
        }
        return binding;
    }

    protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding binding)
    {
        IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(binding.Initializers);
        if (initializers != binding.Initializers)
        {
            return Expression.ListBind(binding.Member, initializers);
        }
        return binding;
    }

    protected virtual IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBinding> original)
    {
        List<MemberBinding> list = null;
        for (int i = 0, n = original.Count; i < n; i++)
        {
            MemberBinding b = this.VisitBinding(original[i]);
            if (list != null)
            {
                list.Add(b);
            }
            else if (b != original[i])
            {
                list = new List<MemberBinding>(n);
                for (int j = 0; j < i; j++)
                {
                    list.Add(original[j]);
                }
                list.Add(b);
            }
        }
        if (list != null)
            return list;
        return original;
    }

    protected virtual IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<ElementInit> original)
    {
        List<ElementInit> list = null;
        for (int i = 0, n = original.Count; i < n; i++)
        {
            ElementInit init = this.VisitElementInitializer(original[i]);
            if (list != null)
            {
                list.Add(init);
            }
            else if (init != original[i])
            {
                list = new List<ElementInit>(n);
                for (int j = 0; j < i; j++)
                {
                    list.Add(original[j]);
                }
                list.Add(init);
            }
        }
        if (list != null)
            return list;
        return original;
    }

    protected virtual Expression VisitLambda(LambdaExpression lambda)
    {
        Expression body = this.Visit(lambda.Body);
        if (body != lambda.Body)
        {
            return Expression.Lambda(lambda.Type, body, lambda.Parameters);
        }
        return lambda;
    }

    protected virtual NewExpression VisitNew(NewExpression nex)
    {
        IEnumerable<Expression> args = this.VisitExpressionList(nex.Arguments);
        if (args != nex.Arguments)
        {
            if (nex.Members != null)
                return Expression.New(nex.Constructor, args, nex.Members);
            else
                return Expression.New(nex.Constructor, args);
        }
        return nex;
    }

    protected virtual Expression VisitMemberInit(MemberInitExpression init)
    {
        NewExpression n = this.VisitNew(init.NewExpression);
        IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings);
        if (n != init.NewExpression || bindings != init.Bindings)
        {
            return Expression.MemberInit(n, bindings);
        }
        return init;
    }

    protected virtual Expression VisitListInit(ListInitExpression init)
    {
        NewExpression n = this.VisitNew(init.NewExpression);
        IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers);
        if (n != init.NewExpression || initializers != init.Initializers)
        {
            return Expression.ListInit(n, initializers);
        }
        return init;
    }

    protected virtual Expression VisitNewArray(NewArrayExpression na)
    {
        IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions);
        if (exprs != na.Expressions)
        {
            if (na.NodeType == ExpressionType.NewArrayInit)
            {
                return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
            }
            else
            {
                return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
            }
        }
        return na;
    }

    protected virtual Expression VisitInvocation(InvocationExpression iv)
    {
        IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);
        Expression expr = this.Visit(iv.Expression);
        if (args != iv.Arguments || expr != iv.Expression)
        {
            return Expression.Invoke(expr, args);
        }
        return iv;
    }
}
#endregion

 

如果您觉得不错，就帮忙点下推荐，谢谢。当然，路过打酱油也是欢迎的，呵呵。