c# 表达式目录树

拼接表达式目录树

看下面2行代码：

  Func<int, int, int> func = (m, n) => m * n + 2; //匿名方法
  Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;//用快捷方式(就是用lambda)声明一个表达式目录树

 第一行是用lambda表达式表明了一个委托，第二行代码则是声明了一个表达式目录树，左边代码虽然看着一样，但是其实是不一样的。使用ExpressionTreeVisualizer工具查看exp会发现这里和上面的委托是完全不一样的，这里面将变量和常量等都做了解析。它类似于一个树形结构，描述不同变量和常量之间的关系，是一种数据结构

 更具体形象一点可以看下图，将其层层解析出来：

 通过上面我们可以知道一个委托和表达式目录树都可以通过一个lambda表达式来表示，但是却不是一种东西，但是，委托和表达式目录树是可以进行转换的。

                 int iResult1 = func.Invoke(12, 23);
                //exp.Compile()=> 委托； 
                int iResult2 = exp.Compile().Invoke(12, 23); //12 * 23 +2  278

看上面代码，通过compile方法可以转换成委托。

还有一点需要注意，用lambda表达式声明表达式目录树的时候不能有语句体(就是{}),只能有一行代码：

     Expression<Func<int, int, int>> exp1 = (m, n) =>
                    {
                        return m * n + 2;
                    };

上面的代码就是错误的，需要改成：

   Expression<Func<int, int, int>> exp1 = (m, n) => m * n + 2;

手动拼装表达式目录树

先插一句，如果需要将现有的通过lambda形式声明出来的表达式目录树换成手动拼装的，而且本身对其不怎么熟悉的话可以通过反编译工具查看编译工具中c#语言对应的表达式目录树写法。很有用

示例1 先看一个非常简单的：

Expression<Func<int>> expression = () => 123 + 234; 

 现在我们不使用lambda表达式来声明表达式目录树了，我们手动拼装：

                  //手动拼装表达式目录树，不是用的lambda的快捷方式
                {
                    //Expression<Func<int>> expression = () => 123 + 234; 
                    //ConstantExpression表示具有常数值的表达式，
                    ConstantExpression left = Expression.Constant(123, typeof(int));
                    //也可以这样写，第二个参数不必写
                    //ConstantExpression left = Expression.Constant(123);
                    ConstantExpression right = Expression.Constant(234, typeof(int));
                    //Add表示加，如果是乘的话就要用Multiply
                    var plus = Expression.Add(left, right);
                    //完成拼装
                    Expression<Func<int>> expression = Expression.Lambda<Func<int>>(plus, new ParameterExpression[0]);
                    //转换成委托并执行
                    int iResult = expression.Compile().Invoke();
                    int iResult1 = expression.Compile()();
                }

示例2 下面看一个稍微复杂一点的：

                    // 更复杂一点的：
                    Expression<Func<int, int, int>> expression = (m, n) => m * n + m + n + 2; 

手动拼装：

// 更复杂一点的：
                    //Expression<Func<int, int, int>> expression = (m, n) => m * n + m + n + 2; 
                    //声明变量
                    ParameterExpression m = Expression.Parameter(typeof(int), "m");
                    ParameterExpression n = Expression.Parameter(typeof(int), "n");
                    //常量2
                    ConstantExpression constant2 = Expression.Constant(2, typeof(int));
                    var multiply = Expression.Multiply(m, n);
                    var plus1 = Expression.Add(multiply, m);
                    var plus2 = Expression.Add(plus1, n);
                    var plus = Expression.Add(plus2, constant2);
                    Expression<Func<int, int, int>> expression = Expression.Lambda<Func<int, int, int>>(plus, new ParameterExpression[]
                    {
                        m,
                        n
                    });
                    int iResult = expression.Compile().Invoke(12, 10);

                }

 示例3：

   Expression<Func<People, bool>> lambda = (x) => x.Id.ToString().Equals("5"); 

  手动拼装：

         { //People类型的对象是变量
                    ParameterExpression x = Expression.Parameter(typeof(People), "x");
                    //获取Id字段信息  通过反射获取 注意Id是字段，所以用GetFiled
                    FieldInfo field = typeof(People).GetField("Id");
                    ConstantExpression constant5 = Expression.Constant("5");
                    //结果 fieldExp: x.Id Id是字段，所以用Field，如果是属性的话就需要用Property，当然还可以用PropertyOrField方法
                    var fieldExp = Expression.Field(x, field);
                    //因为Id要进行tostring，而且Id是int类型，所以获取int中重写的无参tostring方法
                    MethodInfo toString = typeof(int).GetMethod("ToString", new Type[] { });
                    //因为通过tostring转换成了string类型，所以要获取string中重写的带string参数的Equals方法
                    MethodInfo equals = typeof(string).GetMethod("Equals", new Type[] { typeof(string) });
                    //结果 tostringExp ：x.Id.ToString()  Call是调用方法
                    var tostringExp = Expression.Call(fieldExp, toString, new Expression[0]);
                    //结果 equalsExp:x.Id.ToString().Equals("5")
                    var equalsExp = Expression.Call(tostringExp, equals, new Expression[]
                      {
                         constant5
                      });
                    //expression: x => x.Id.ToString().Equals("5")
                    Expression<Func<People, bool>> expression = Expression.Lambda<Func<People, bool>>(equalsExp, new ParameterExpression[]
                    {
                           x
                    });
                    bool bResult = expression.Compile().Invoke(new People()
                    {
                        Id = 5,
                        Name = "德玛西亚"
                    });
                }

 表达式目录树究竟能干什么？

 可以将一个实体的数据赋给另一个实体(前提是2个实体的属性字段完全一致)，当然是用泛型+反射，还有序列化和反序列化也都能实现，但是性能比较差。硬编码的性能是最好的，但是通用性差，硬编码就是下面这种写法：

                People people = new People()
                {
                    Id = 11,
                    Name = "Richard",
                    Age = 31
                };
                PeopleCopy peopleCopy = new PeopleCopy()//硬编码 //硬编码性能好，但是通用型差
                {
                    Id = people.Id,
                    Name = people.Name,
                    Age = people.Age
                };

要想性能快，通用性好，我们可以用表达式目录树

   /// <summary>
    /// 生成表达式目录树 缓存
    /// </summary>
    public class ExpressionMapper
    {
        /// <summary>
        /// 字典缓存--hash分布  
        /// </summary>
        private static Dictionary<string, object> _Dic = new Dictionary<string, object>();  //超过一定的数量之后  在字典中获取值就会有性能损耗

        /// <summary>
        /// 字典缓存表达式树
        /// </summary>
        /// <typeparam name="TIn"></typeparam>
        /// <typeparam name="TOut"></typeparam>
        /// <param name="tIn"></param>
        /// <returns></returns>
        public static TOut Trans<TIn, TOut>(TIn tIn)
        {
            string key = string.Format("funckey_{0}_{1}", typeof(TIn).FullName, typeof(TOut).FullName);
            if (!_Dic.ContainsKey(key))
            {
                //动态的生成表达式
                ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
                List<MemberBinding> memberBindingList = new List<MemberBinding>();
                foreach (var item in typeof(TOut).GetProperties())
                {
                    MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
                    MemberBinding memberBinding = Expression.Bind(item, property);
                    memberBindingList.Add(memberBinding);
                }
                foreach (var item in typeof(TOut).GetFields())
                {
                    MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
                    MemberBinding memberBinding = Expression.Bind(item, property);
                    memberBindingList.Add(memberBinding);
                }
                MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
                Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
                {
                    parameterExpression
                });
                Func<TIn, TOut> func = lambda.Compile();//拼装是一次性的
                _Dic[key] = func;
            }
            return ((Func<TIn, TOut>)_Dic[key]).Invoke(tIn);
        }
    }

 调用：

   PeopleCopy peopleCopy = ExpressionMapper.Trans<People, PeopleCopy>(people);

下面再下一个泛型缓存，上面的字典是hash分布的，使用字典缓存的话，当数量达到一定程度，读取字典信息性能就会下降：

namespace ExpressionDemo.MappingExtend
{
    /// <summary>
    /// 生成表达式目录树  泛型缓存
    /// </summary>
    /// <typeparam name="TIn"></typeparam>
    /// <typeparam name="TOut"></typeparam>
    public class ExpressionGenericMapper<TIn, TOut>//Mapper`2 //正对于每两个不同类型的组合都会生成副本
    {
        private static Func<TIn, TOut> _FUNC = null;// 在每个副本中都有一个委托
        static ExpressionGenericMapper() //静态构造函数 生成表达式目录树 
        {
            ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
            List<MemberBinding> memberBindingList = new List<MemberBinding>();
            foreach (var item in typeof(TOut).GetProperties())
            {
                MemberExpression property = Expression.Property(parameterExpression, typeof(TIn).GetProperty(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }
            foreach (var item in typeof(TOut).GetFields())
            {
                MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
                MemberBinding memberBinding = Expression.Bind(item, property);
                memberBindingList.Add(memberBinding);
            }
            MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray());
            Expression<Func<TIn, TOut>> lambda = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]
            {
                    parameterExpression
            });
            _FUNC = lambda.Compile();//拼装是一次性的   转换成委托以后放入副本的静态变量中去
        }
        public static TOut Trans(TIn t) // 直接获取副本的静态变量（委托）
        {
            return _FUNC(t);
        }
    }
}

解析表达式目录树

 ExpressionVisitor是一个访问者类，Visist是一个入口，先判断，作进一步的解析，然后调度到更加专业的方法中去解析，大体流程如下：
 1 lambda会区分参数和方法体，调度到更加专业的方法中去解析
 2 根据表达式的类型，调度到更加专业的方法中去解析
 3 在更加专业的解析方法中会默认根据传进来的旧的表达式产生一个新的表达式目录树

 下面是一个没什么实际意义的一个简单示例，而且是继承了ExpressionVisitor并重写一部分方法的一个示例类，是为了方便演示才继承重写的：

namespace ExpressionDemo.Visitor
{
    /// <summary>
    /// ExpressionVisitor是一个访问者类，Visist是一个入口，先判断，作进一步的解析，然后调度到更加专业的方法中去解析，大体流程如下：
    /// 1 lambda会区分参数和方法体，调度到更加专业的方法中去解析
    /// 2 根据表达式的类型，调度到更加专业的方法中去解析
    /// 3 在更加专业的解析方法中会默认根据传进来的旧的表达式产生一个新的表达式目录树
    /// </summary>
    public class OperationsVisitor : ExpressionVisitor
    {
        public Expression Modify(Expression expression)
        {
            //指向的是父类的Visit方法，如果这个子类中也重写Visit方法的话，其实指向的是当前类的Visit方法，如果真要指向父类的话最好用base.Visit
            //如果执行下面方法的时候会判断expression是什么表达式，如果是常量表达式，那么会自动分配到VisitConstant这个方法中去执行，
            // 因为Visist的功能是 将调度到此类中更专用的访问方法之一的表达式。
            return this.Visit(expression);
        }
        /// <summary>
        /// 二进制表达式
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        protected override Expression VisitBinary(BinaryExpression b)
        {
            //NodeType：节点类型  如果节点类型是add，就是"+",下面就使用Expression.Subtract方法变成"-"  
            if (b.NodeType == ExpressionType.Add)
            {
                //产生一个新的表达式
                Expression left = base.Visit(b.Left);
                Expression right = base.Visit(b.Right);
                //在这里是将解析出来的表达式重新组合，Subtract表示算术减法，在这里重新组合成：left-right的表达式
                return Expression.Subtract(left, right);
            }
            //调用父类的VisitBinary方法
            return base.VisitBinary(b);
        }
        /// <summary>
        /// 专门解析常量表达式的  在这里进行重写了
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected override Expression VisitConstant(ConstantExpression node)
        {
            //调用父类的VisitConstant方法
            return base.VisitConstant(node);
        }
    }
}

 调用：

            {
                //修改表达式目录树
                Expression<Func<int, int, int>> exp = (m, n) => m * n + 2; 
                OperationsVisitor visitor = new OperationsVisitor(); 
                Expression expNew = visitor.Modify(exp);
            }

 结果：

{(m, n) => ((m * n) - 2)}

 这只是一个很简单的一个描述，实际工作中是不会做这个的，实际中我们关心的还是例如linq中通过lambda形式来声明一个表达式目录树，表达式目录树是如何解析成sql来查询数据的

下面看一个非常简单的例子：

基础类：

namespace ExpressionDemo.DBExtend
{
    internal static class SqlOperator
    {
        /// <summary>
        /// this ExpressionType typ  参数是这种类型，这是写了一个扩展方法，所以ExpressionType对象点"."具备的方法的时候就会有它，可以直接调用这个方法，扩展方法牛逼
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        internal static string ToSqlOperator(this ExpressionType type)
        {
            switch (type)
            {
                case (ExpressionType.AndAlso):
                case (ExpressionType.And):
                    return "AND";
                case (ExpressionType.OrElse):
                case (ExpressionType.Or):
                    return "OR";
                case (ExpressionType.Not):
                    return "NOT";
                case (ExpressionType.NotEqual):
                    return "<>";
                case ExpressionType.GreaterThan:
                    return ">";
                case ExpressionType.GreaterThanOrEqual:
                    return ">=";
                case ExpressionType.LessThan:
                    return "<";
                case ExpressionType.LessThanOrEqual:
                    return "<=";
                case (ExpressionType.Equal):
                    return "=";
                default:
                    throw new Exception("不支持该方法");
            }

        }
         
    }
}

namespace ExpressionDemo.Visitor
{
    public class ConditionBuilderVisitor : ExpressionVisitor
    {
        private Stack<string> _StringStack = new Stack<string>();

        public string Condition()
        {
            string condition = string.Concat(this._StringStack.ToArray());
            this._StringStack.Clear();
            return condition;
        }

        /// <summary>
        /// 如果是二元表达式
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected override Expression VisitBinary(BinaryExpression node)
        {
            if (node == null) throw new ArgumentNullException("BinaryExpression");

            this._StringStack.Push(")");
            base.Visit(node.Right);//解析右边
            this._StringStack.Push(" " + node.NodeType.ToSqlOperator() + " ");//这ToSqlOperator是自定义的一个扩展方法，
            base.Visit(node.Left);//解析左边
            this._StringStack.Push("(");

            return node;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected override Expression VisitMember(MemberExpression node)
        {
            if (node == null) throw new ArgumentNullException("MemberExpression");
            this._StringStack.Push(" [" + node.Member.Name + "] ");
            return node;
        }
        /// <summary>
        /// 常量表达式
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        protected override Expression VisitConstant(ConstantExpression node)
        {
            if (node == null) throw new ArgumentNullException("ConstantExpression");
            this._StringStack.Push(" '" + node.Value + "' ");
            return node;
        }
    /// <summary>
        /// 方法表达式
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        protected override Expression VisitMethodCall(MethodCallExpression m)
        {
            if (m == null) throw new ArgumentNullException("MethodCallExpression");

            string format;
            switch (m.Method.Name)
            {
                case "StartsWith":
                    format = "({0} LIKE '{1}%')";
                    break;

                case "Contains":
                    format = "({0} LIKE '%{1}%')";
                    break;

                case "EndsWith":
                    format = "({0} LIKE '%{1}')";
                    break;

                default:
                    throw new NotSupportedException(m.NodeType + " is not supported!");
            }
            this.Visit(m.Object);
            this.Visit(m.Arguments[0]);
            string right = this._StringStack.Pop();
            string left = this._StringStack.Pop();
            this._StringStack.Push(String.Format(format, left, right));

            return m;
        }
    }
}

 调用：

   {
                Expression<Func<People, bool>> lambda = x => x.Age > 5; 
                ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
                vistor.Visit(lambda);
                Console.WriteLine(vistor.Condition());
            }

 结果：

( [Age]  >  '5' )

 还可以支持其他一些的调用：

   {
                //Expression<Func<People, bool>> lambda = x => x.Age > 5;
                Expression<Func<People, bool>> lambda = x => x.Age > 5 && x.Id > 5
                                                         && x.Name.StartsWith("1")
                                                         && x.Name.EndsWith("1")
                                                         && x.Name.Contains("1");

                string sql = string.Format("Delete From [{0}] WHERE {1}"
                    , typeof(People).Name
                    , " [Age]>5 AND [ID] >5"
                    );
                ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
                vistor.Visit(lambda);
                Console.WriteLine(vistor.Condition());
            }
            {
                Expression<Func<People, bool>> lambda = x => x.Age > 5 && x.Name == "A" || x.Id > 5;
                ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
                vistor.Visit(lambda);
                Console.WriteLine(vistor.Condition());
            }
            {
                Expression<Func<People, bool>> lambda = x => x.Age > 5 || (x.Name == "A" && x.Id > 5);
                ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
                vistor.Visit(lambda);
                Console.WriteLine(vistor.Condition());
            }
            {
                Expression<Func<People, bool>> lambda = x => (x.Age > 5 || x.Name == "A") && x.Id > 5;
                ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
                vistor.Visit(lambda);
                Console.WriteLine(vistor.Condition());
            }

 表达式目录树的拼接

 封装的一个自定义类：

namespace ExpressionDemo.Extend
{
    /// <summary>
    /// 合并表达式 And Or  Not扩展
    /// </summary>
    public static class ExpressionExtend
    {
        /// <summary>
        /// 合并表达式 expr1 AND expr2
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expr1"></param>
        /// <param name="expr2"></param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
        {
            //注意，不能直接用下面被注释调的代码，因为expr1和expr2不是同一个表达式，参数也不一样，所以不能直接使用expr1.parameters，需要重新定义一个新的参数
            //return expression.lambda<func<t, bool>>(expression.andalso(expr1.body, expr2.body), expr1.parameters);

            ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
            NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);

            var left = visitor.Replace(expr1.Body);// 重新生成了一个表达式目录树
            var right = visitor.Replace(expr2.Body);
            var body = Expression.And(left, right);
            return Expression.Lambda<Func<T, bool>>(body, newParameter);

        }
        /// <summary>
        /// 合并表达式 expr1 or expr2
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expr1"></param>
        /// <param name="expr2"></param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
        {

            ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
            NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);

            var left = visitor.Replace(expr1.Body);
            var right = visitor.Replace(expr2.Body);
            var body = Expression.Or(left, right);
            return Expression.Lambda<Func<T, bool>>(body, newParameter);
        }
        public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr)
        {
            var candidateExpr = expr.Parameters[0];
            var body = Expression.Not(expr.Body);

            return Expression.Lambda<Func<T, bool>>(body, candidateExpr);
        }
    }
}

 调用：

  #region 表达式拼接
            {

                // 把多个表达式拼接起来
                Expression<Func<People, bool>> lambda1 = x => x.Age > 5;
                Expression<Func<People, bool>> lambda2 = x => x.Id > 5;
                Expression<Func<People, bool>> lambda3 = lambda1.And(lambda2);
                Expression<Func<People, bool>> lambda4 = lambda1.Or(lambda2);
                Expression<Func<People, bool>> lambda5 = lambda1.Not();
                Do1(lambda3);
                Do1(lambda4);
                Do1(lambda5);
            }
            #endregion