Csharp中表达式树

Csharper中的表达式树

这节课来了解一下表示式树是什么？

在C#中，表达式树是一种数据结构，它可以表示一些代码块，如Lambda表达式或查询表达式。表达式树使你能够查看和操作数据，就像你可以查看和操作代码一样。它们通常用于创建动态查询和解析表达式。

一、认识表达式树

为什么要这样说？它和委托有什么区别？

创建一个简单的表达式树和委托

  public class ExpressionDemo
  {

      void Show()
      {
          Func<int, bool> fun1 = x => x > 10;
          Expression<Func<int, bool>> expression1 = x => x > 10;
      }
  }

然后f12转到定义

public sealed class Expression<TDelegate> : LambdaExpression

尝试用大括号定义一个表达式树

debug运行后，用vs查看一下定义的表达式树对象.

发现表达式树一些特点:

可以通过lambda表达式来声明
是一个泛型类的接口，类型参数是一个委托
Expression声明中，不能包含大括号.
通过VS展开查看，包含body(lamubda的主体部分)，描述了参数的名称和类型，描述了返回值的名称和类型；展开body, body包含左边是什么，右边是什么，式子的操作类型是什么.

结论:

表达式树,是一个计算式的描述，按照常规的计算逻辑，通过类的属性来进行描述多个节点之间的关系；形似于一个树形结构----二叉树；二叉树不断地去分解，可以得到这个式子中的任何一个独立的元素；----是一个二叉树，是一个数据结构；如果需要可以把这个结构不断的拆解；得到中间的最小元素；在需要的时候，也可以通过每个元素，组装起来；

委托是一个类，而表达式树是一个二叉树的数据结构。

为了更加深入的了解表达式树，这里也使用ilspy进行反编译，以便于更加了解表达式树的本质.

这里使用一个比较复杂的表达式树的语句来方便我们去理解

Expression<Func<int ,int ,int>> expression2= (x, y) => x *y+2+3;

优化一下这段代码

//定义2个变量
ParameterExpression parameterExpression = Expression.Parameter(typeof(int), "x");
ParameterExpression parameterExpression2 = Expression.Parameter(typeof(int), "y");
//定义常量
var contact1 = Expression.Constant(2, typeof(int));
var contact2= Expression.Constant(3, typeof(int));
//定义表达式 x*y
var MultiplyXy= Expression.Multiply(parameterExpression, parameterExpression2);
//定义表达式 x*y的结果+2
var add1 = Expression.Add(MultiplyXy, contact1);

//定义表达式 x*y+2的结果+3
var add2 = Expression.Add(add1, contact2);
//定义最终的lambda表达式
Expression<Func<int, int, int>> expression2 = Expression.Lambda<Func<int, int, int>>(add2, new ParameterExpression[2]
{
    parameterExpression,
    parameterExpression2
});

如图所示的解析:

已经将相应的代码粘贴到上方，就是类似二叉树结构的因式分解，转换成为最小的子问题，最后解决一个需要解决的大问题。

二、动态拼装Expression

我们自己去拼装一个表达式树去理解表达式树的秘密.

首先创建一个People类

public class People
{
    public int Age { get; set; }
    public string Name { get; set; }
    public int Id;
}

下面来拼接一个比较复杂的表达式

Expression<Func<People, bool>> predicate = c => c.Id == 10 && c.Name.ToString().Equals("张三");

对应的表达式树的代码

  //定义一个People类型的参数
  ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "c");
  //获取People的Id属性
  PropertyInfo? propertyId = typeof(People).GetProperty("Id");
  //定义10这个常量
  ConstantExpression constantExpression = Expression.Constant(10, typeof(int));                
  //定义c.Id>10这个表达式    
  BinaryExpression left =Expression.GreaterThan(Expression.Property(parameterExpression, propertyId), constantExpression);
  //获取People的Name属性
  PropertyInfo? propertyName = typeof(People).GetProperty("Name");
  //c.Name
  MemberExpression memName = Expression.Property(parameterExpression, propertyName);
  //to string方法
  MethodInfo? methodtostring=typeof(string).GetMethod("ToString",new Type[0]);
  //调用tostring方法
  MethodCallExpression instance =Expression.Call(memName, methodtostring,Array.Empty<Expression>());
  //获取equals方法
  MethodInfo? methodEquals = typeof(string).GetMethod("Equals", new Type[] { typeof(string) });
  //定义c.Name.ToString().Equals("张三")这个表达式
  MethodCallExpression right = Expression.Call(instance, methodEquals, Expression.Constant("张三", typeof(string)));
  //定义c.Age<25这个表达式
  PropertyInfo? propertyAge = typeof(People).GetProperty("Age");
  ConstantExpression constantExpression2 = Expression.Constant(25, typeof(int));
  BinaryExpression right2 = Expression.LessThan(Expression.Property(parameterExpression, propertyAge), constantExpression2);
  //定义c.Id>10 && c.Name.ToString().Equals("张三") && c.Age<25这个表达式
  BinaryExpression and1 = Expression.AndAlso(left, right);
  BinaryExpression and2 = Expression.AndAlso(and1, right2);
  //定义最终的lambda表达式
  Expression<Func<People, bool>> expression = Expression.Lambda<Func<People, bool>>(and2, new ParameterExpression[1]
  {
      parameterExpression
  });
  //编译表达式
  Func<People, bool> func = expression.Compile();
  //调用表达式
  People people = new People()
  {
      Id = 11,
      Name = "张三",
      Age = 20
  };
  Console.WriteLine(func(people));

这样就拼接出来了需要的表达式树.

三、表达式树的应用价值

为什么要拼装这个表达式目录树呢?

现在主流的是Linq:
Linq to Sql -----把相同的逻辑封装，把不同的逻辑通过表达式目录树来传递；
传递表达式目录树：对应的是查询条件；在传递之前就应该把查询的条件拼装好；

例子

 Expression<Func<People, bool>> expression2 = p => p.Id == 10 && p.Name.Equals("阳光下的微笑");

拼接后的结果

//按关键字是否存在来拼装；
Expression<Func<People, bool>> exp = p=> true;
Console.WriteLine("用户输入个名称，为空就跳过");
string name = Console.ReadLine();
if (!string.IsNullOrWhiteSpace(name))
{
    //exp = p => p.Name.Contains(name);
    exp= exp.And(c=>c.Name.Contains(name));
}
Console.WriteLine("用户输入个最小年纪，为空就跳过");
string age = Console.ReadLine();
if (!string.IsNullOrWhiteSpace(age) && int.TryParse(age, out int iAge))
{
   //  exp = p => p.Age > iAge;
    exp = exp.And(p => p.Age > iAge);
}

例子2

//Expression<Func<People, bool>> newExpress = x => x.Age > 5 && x.Id > 5

现在使用表达式树进行链接

 Expression<Func<People, bool>> lambda1 = x => x.Age > 5;
 Expression<Func<People, bool>> lambda2 = x => x.Id > 5;

 //Expression<Func<People, bool>> newExpress = x => x.Age > 5 && 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();//非

这里实现了常见的且、或、非逻辑运算符的表达式

 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)
     {
         //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);
     }
 }

 internal class NewExpressionVisitor : ExpressionVisitor
{
    public ParameterExpression _NewParameter { get; private set; }
    public NewExpressionVisitor(ParameterExpression param)
    {
        this._NewParameter = param;
    }
    public Expression Replace(Expression exp)
    {
        return this.Visit(exp);
    }
    protected override Expression VisitParameter(ParameterExpression node)
    {
        return this._NewParameter;
    }
}

现在有一个新的需求，需要把People拷贝到NewPeople这个新的类，来看下效率怎么样?

People和PeopleCopy类

 public class People
 {
     public int Age { get; set; }
     public string Name { get; set; }
     public int Id;
 }
 /// <summary>
 /// 实体类Target
 /// PeopleDTO
 /// </summary>
 public class PeopleCopy
 {

     public int Age { get; set; }
     public string Name { get; set; }
     public int Id;
 }

直接赋值的方式

 PeopleCopy peopleCopy1 = new PeopleCopy()
 {
     Id = people.Id,
     Name = people.Name,
     Age = people.Age
 };

反射赋值的方式

 public class ReflectionMapper
 {
     /// <summary>
     /// 反射
     /// </summary>
     /// <typeparam name="TIn"></typeparam>
     /// <typeparam name="TOut"></typeparam>
     /// <param name="tIn"></param>
     /// <returns></returns>
     public static TOut Trans<TIn, TOut>(TIn tIn)
     {
         TOut tOut = Activator.CreateInstance<TOut>();
         foreach (var itemOut in tOut.GetType().GetProperties())
         {
             var propName = tIn.GetType().GetProperty(itemOut.Name);
             itemOut.SetValue(tOut, propName.GetValue(tIn)); 
         }

         foreach (var itemOut in tOut.GetType().GetFields())
         {
             var fieldName = tIn.GetType().GetField(itemOut.Name);
             itemOut.SetValue(tOut, fieldName.GetValue(tIn)); 
         }
         return tOut;
     }
 }
 PeopleCopy peopleCopy2= ReflectionMapper.Trans<People, PeopleCopy>(people);

json序列化的方式

public class SerializeMapper
{
    /// <summary>
    /// 序列化反序列化方式
    /// </summary>
    /// <typeparam name="TIn"></typeparam>
    /// <typeparam name="TOut"></typeparam>
    public static TOut Trans<TIn, TOut>(TIn tIn)
    { 
        string strTin = JsonConvert.SerializeObject(tIn); 
        return JsonConvert.DeserializeObject<TOut>(strTin);
    }
}
 PeopleCopy peopleCopy3 = SerializeMapper.Trans<People, PeopleCopy>(people);

表达式目录树的方式


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))
        {
            #region 这里是拼装---赋属性值的代码 
            ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "p");
            //MemberBinding: 就是一个表达式目录树
            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
            });

            #endregion


            Func<TIn, TOut> func = lambda.Compile();//拼装是一次性的
            _Dic[key] = func;
        }
        return ((Func<TIn, TOut>)_Dic[key]).Invoke(tIn);
    }
}
PeopleCopy peopleCopy4 = ExpressionMapper.Trans<People, PeopleCopy>(people);

表达式+反射+泛型类的方式

    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);
        }
    }
}
PeopleCopy peopleCopy5 = ExpressionGenericMapper<People, PeopleCopy>.Trans(people);

最后运行一百万次，来看一下效率。

{
    People people = new People()
    {
        Id = 11,
        Name = "Richard",
        Age = 31
    };
    long common = 0;
    long generic = 0;
    long cache = 0;
    long reflection = 0;
    long serialize = 0;
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < 1_000_000; i++)
        {
            PeopleCopy peopleCopy = new PeopleCopy()
            {
                Id = people.Id,
                Name = people.Name,
                Age = people.Age
            };
        }
        watch.Stop();
        common = watch.ElapsedMilliseconds;
    }
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < 1_000_000; i++)
        {
            PeopleCopy peopleCopy = ReflectionMapper.Trans<People, PeopleCopy>(people);
        }
        watch.Stop();
        reflection = watch.ElapsedMilliseconds;
    }
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < 1_000_000; i++)
        {
            PeopleCopy peopleCopy = SerializeMapper.Trans<People, PeopleCopy>(people);
        }
        watch.Stop();
        serialize = watch.ElapsedMilliseconds;
    }
    {

        Stopwatch watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < 1_000_000; i++)
        {
            PeopleCopy peopleCopy = ExpressionMapper.Trans<People, PeopleCopy>(people);
        }
        watch.Stop();
        cache = watch.ElapsedMilliseconds;
    }
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < 1_000_000; i++)
        {
            PeopleCopy peopleCopy = ExpressionGenericMapper<People, PeopleCopy>.Trans(people);
        }
        watch.Stop();
        generic = watch.ElapsedMilliseconds;
    }

    Console.WriteLine($"common = {common} ms");        //性能最高，但是不能通用；
    Console.WriteLine($"reflection = {reflection} ms");
    Console.WriteLine($"serialize = {serialize} ms");
    Console.WriteLine($"cache = {cache} ms");
    Console.WriteLine($"generic = {generic} ms"); //性能好，而且扩展性也好===又要马儿跑，又要马儿不吃草。。。
}

看运行后的结果

核心：动态生成硬编码；----代码运行的时候生成了一段新的逻辑；

四、表达式树和sql

为什么要使用表达式目录树来拼装解析呢？
可以提供重用性

如果封装好一个方法，接受一个表达式树，在解析的时候，其实就是不断的访问，访问的时候，会按照固定的规则，避免出错;

任何的一个表达式树都可以用一个通用的方法解析并且支持泛型,更加容易去封装;

例子:

需要的扩展类

 public class OperationsVisitor : ExpressionVisitor
 {
     public Expression Modify(Expression expression)
     {
         Console.WriteLine(expression.ToString()) ;

         //ExpressionVisitor:
         //1.Visit方法--访问表达式目录树的入口---分辨是什么类型的表达式目录
         //2.调度到更加专业的方法中进一步访问,访问一遍之后，生成一个新的表达式目录   ---有点像递归，不全是递归；
         //3.因为表达式目录树是个二叉树，ExpressionVisitor一直往下访问，一直到叶节点；那就访问了所有的节点
         //4.在访问的任何一个环节，都可以拿到对应当前环节的内容(参数名称、参数值。。)，就可以进一步扩展
         return this.Visit(expression);
     }

     /// <summary>
     /// 覆写父类方法
     /// </summary>
     /// <param name="b"></param>
     /// <returns></returns>
     protected override Expression VisitBinary(BinaryExpression b)
     {
        
         if (b.NodeType == ExpressionType.Add)
         {
             Expression left = this.Visit(b.Left);
             Expression right = this.Visit(b.Right);
             return Expression.Subtract(left, right);
         }
         else if (b.NodeType==ExpressionType.Multiply) //如果是相乘
         {
             Expression left = this.Visit(b.Left);
             Expression right = this.Visit(b.Right);
             return Expression.Divide(left, right); //相除
         } 
         return base.VisitBinary(b);
     }

     /// <summary>
     /// 覆写父类方法
     /// </summary>
     /// <param name="node"></param>
     /// <returns></returns>
     protected override Expression VisitConstant(ConstantExpression node)
     {
         return base.VisitConstant(node);
     }

对应的表达式解析

 Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;
 OperationsVisitor visitor = new OperationsVisitor();
 //visitor.Visit(exp);
 Expression expNew = visitor.Modify(exp);

同时表达式树中已经通过使用观察者模式封装好了Visit方法.

Visit方法--访问表达式树的入口---分辨是什么类型的表达式目录
调度到更加专业的方法中进一步访问，访问一边以后，生成一个新的表达式目录. --- 有点像递归，不全是递归
因为表达式目录树是一个二叉树，ExpreesionVistor一直往下访问，一直到叶子节点;通过二叉树的遍历就访问了所有的节点.
在访问的任何一个环节，都可以拿到对应当前环节的内容(参数名称、参数值...)就可以进一步扩展.

现在开始将表达式树跟sql语句进行连接

例子:
扩展类

 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() + " ");
         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; 
         if (node.Expression is ConstantExpression)
         {
             var value1 = this.InvokeValue(node);
             var value2 = this.ReflectionValue(node);
             //this.ConditionStack.Push($"'{value1}'");
             this._StringStack.Push("'" + value2 + "'");
         }
         else
         {
             this._StringStack.Push(" [" + node.Member.Name + "] ");
         }
         return node;
     }


     private object InvokeValue(MemberExpression member)
     {
         var objExp = Expression.Convert(member, typeof(object));//struct需要
         return Expression.Lambda<Func<object>>(objExp).Compile().Invoke();
     }

     private object ReflectionValue(MemberExpression member)
     {
         var obj = (member.Expression as ConstantExpression).Value;
         return (member.Member as FieldInfo).GetValue(obj);
     }

     /// <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;
     }
 }

对应的sql语句的解析

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

    string sql = string.Format("Delete From [{0}] WHERE [Age]>5 AND [ID] >5"
        , typeof(People).Name
        , " [Age]>5 AND [ID] >5");

    ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();
    vistor.Visit(lambda);
    Console.WriteLine(vistor.Condition());
}
{
    //  ((( [Age] > '5') AND( [Name] =  [name] )) OR( [Id] > '5' )) 
    string name = "AAA";
    Expression<Func<People, bool>> lambda = x => x.Age > 5 && x.Name == name || 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());
}

在我自己的看法，使用表达式树而不是传统的方式去解析sql语句的优点

通过二叉树的方式表达，更加的有条理性
使用泛型等技术更方式实现一个通用的sql语句的解析。
会有类型检查，出错后也能使用异常处理。

2024-04-12 11:45:08【出处】：https://www.cnblogs.com/wenlong-4613615/p/18084777

=======================================================================================

posted on 2024-04-12 11:45 jack_Meng 阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部

Jack_孟