C#Expression详解（⾼级）LINQ在本地查询IEnumerbale主要是⽤委托来作为传参，⽽解析型查询IQueryable则⽤Expression来作为传参：public static IEnumerable<T> Where<T>(this IEnumerable<T> enumable, Func<T, bool> func)public static IQueryable<T> Where<T>(this IQueryable<T> queryable, Expression<Func<T, bool>> func)⼀、Expression是什么1、如何定义Expression<Func<TSource, bool>>就是表达式⽬录树Expression不能带有⼤括号，只能有⼀⾏代码2、和委托的区别在委托外⾯包裹⼀层Expression<>就是表达式⽬录树表达式⽬录树可以通过Compile()转换成⼀个委托3、Expression本质表达式⽬录树是⼀个类的封装，描述了⼀个结构，有⾝体部分和参数部分⾝体部分分为左边和右边，内部描述了左边和右边之间的关系，可以不断的往下拆分，类似于⼆叉树表达式⽬录树展开后的每⼀个节点也是⼀个表达式⽬录树Expression<Func<People, bool>> expression = p => p.Id == 10;Func<People, bool> func = pile();bool bResult = func.Invoke(new People(){Id = 10,Name = "张三"});⼆、Expression与Expression Tree⾸先我们来写下⼀些代码：Expression<Func<int, int>> expression = (num) => num + 5;Console.WriteLine($"NodeType:{expression.NodeType}");Console.WriteLine($"Body:{expression.Body}");Console.WriteLine($"Body Type: {expression.Body.GetType()}");Console.WriteLine($"Body NodeType: {expression.Body.NodeType}");输出如下：NodeType:LambdaBody:(num + 5)Body Type: System.Linq.Expressions.SimpleBinaryExpressionBody NodeType: Add我们将expression转为LambdaExpression看看都有啥：if (expression.NodeType == mbda){var lambda = (LambdaExpression)expression;var parameter = lambda.Parameters.Single();Console.WriteLine($":{}");Console.WriteLine($"parameter.Type:{parameter.Type}");Console.WriteLine($"parameter.ReturnType:{lambda.ReturnType}");}输出如下：:numparameter.Type:System.Int32parameter.ReturnType:System.Int32由于我们知道expression.Body是BinaryExpression，那么我们就将其转为它，然后我们继续看下去：if (expression.Body.NodeType == ExpressionType.Add){var binaryExpreesion = (BinaryExpression)expression.Body;Console.WriteLine($"Left Type:{binaryExpreesion.Left.GetType()}");Console.WriteLine($"Left NodeType:{binaryExpreesion.Left.NodeType}");Console.WriteLine($"Right Type:{binaryExpreesion.Right.GetType()}");Console.WriteLine($"Right NodeType:{binaryExpreesion.Right.NodeType}");if (binaryExpreesion.Left is ParameterExpression parameterExpreesion){Console.WriteLine($":{}");Console.WriteLine($"parameterExpreesion.Type:{parameterExpreesion.Type}");}if (binaryExpreesion.Right is ConstantExpression constantExpreesion){Console.WriteLine($"constantExpreesion.Value:{constantExpreesion.Value}" );}}输出如下：Left Type:System.Linq.Expressions.PrimitiveParameterExpression`1[System.Int32]Left NodeType:ParameterRight Type:System.Linq.Expressions.ConstantExpressionRight NodeType:Constant:numparameterExpreesion.Type:System.Int32constantExpreesion.Value:5最后我们将表达式树转为委托：var @delegate = pile();Console.WriteLine(@delegate?.Invoke(2));输出：7 //2+5实际上，通过Expression<Func<int, int>> expression = (num) => num + 5;，赋值后的expression变成了⼀个表达式树，它的结构是这样的：⽽有意思的是⼆元表达式树BinaryExpression是⼀个⼆叉树，⽽LambdaExpression则是⼀个⽀持参数的表达式，能够通过其Parameters属性知道传⼊的参数的类型和数量，通过ReturnType知道返回值是什么类型⽽我们再看看整个关于Expression的继承关系链：因此，我们也可以显式的通过各⾃Expreesion的实现⼦类来创建跟lambda表达式⼀样的结果：var parameterExpreesion1 = Expression.Parameter(typeof(int), "num");BinaryExpression binaryExpression1 = Expression.MakeBinary(ExpressionType.Add, parameterExpreesion1, Expression.Constant(5));Expression<Func<int, int>> expression1 = mbda<Func<int, int>>(binaryExpression1, parameterExpreesion1);if (expression1.Body.NodeType == ExpressionType.Add){var binaryExpreesion1 = (BinaryExpression)expression1.Body;Console.WriteLine($"Left Type:{binaryExpreesion1.Left.GetType()}");Console.WriteLine($"Left NodeType:{binaryExpreesion1.Left.NodeType}");Console.WriteLine($"Right Type:{binaryExpreesion1.Right.GetType()}");Console.WriteLine($"Right NodeType:{binaryExpreesion1.Right.NodeType}");if (binaryExpreesion1.Left is ParameterExpression parameterExpreesion2){Console.WriteLine($":{}");Console.WriteLine($"parameterExpreesion.Type:{parameterExpreesion2.Type}");}if (binaryExpreesion1.Right is ConstantExpression constantExpreesion1){Console.WriteLine($"constantExpreesion.Value:{constantExpreesion1.Value}");}var @delegate1 = pile();Console.WriteLine(@delegate1(2));输出结果：Left Type:System.Linq.Expressions.PrimitiveParameterExpression`1[System.Int32]Left NodeType:ParameterRight Type:System.Linq.Expressions.ConstantExpressionRight NodeType:Constant:numparameterExpreesion.Type:System.Int32constantExpreesion.Value:5result:7我们则发现，结果是⼀模⼀样的，但是费劲了很多，因此⽤lamda构建表达式树是⼀个⾮常愉快的语法糖，让你能够愉快的在使⽤表达式和表达式树三、Expression动态拼装1、最基础版本Expression<Func<int>> expression = () => 123 + 234;//常量表达式ConstantExpression expression1 = Expression.Constant(123);ConstantExpression expression2 = Expression.Constant(234);//⼆元表达式BinaryExpression binaryExpression = Expression.Add(expression1, expression2);Expression<Func<int>> expressionReslut = mbda<Func<int>>(binaryExpression);Func<int> func = pile();int iResult = func.Invoke();2、带参数版本Expression<Func<int, int>> expression1 = m => m + 1;Func<int, int> func = pile();int iResult = func.Invoke(5);//参数表达式ParameterExpression parameterExpression = Expression.Parameter(typeof(int), "m");//常量表达式ConstantExpression constant = Expression.Constant(1, typeof(int));//⼆元表达式BinaryExpression addExpression = Expression.Add(parameterExpression, constant);Expression<Func<int, int>> expression = mbda<Func<int, int>>(addExpression, new ParameterExpression[1]{parameterExpression});Func<int, int> func1 = pile();int iResult1 = func1.Invoke(5);3、带有多个参数Expression<Func<int, int, int>> expression = (m, n) => m * n + 2;Func<int, int, int> func = pile();int iResult = func.Invoke(10, 20);//参数表达式ParameterExpression parameterExpressionM = Expression.Parameter(typeof(int), "m");ParameterExpression parameterExpressionN = Expression.Parameter(typeof(int), "n");//⼆元表达式BinaryExpression multiply = Expression.Multiply(parameterExpressionM, parameterExpressionN);//常量表达式ConstantExpression constantExpression = Expression.Constant(2);//⼆元表达式BinaryExpression plus = Expression.Add(multiply, constantExpression);Expression<Func<int, int, int>> expression1 = mbda<Func<int, int, int>>(plus, new ParameterExpression[2]{parameterExpressionM,parameterExpressionN});Func<int, int, int> func1 = pile();int iResult1 = func1.Invoke(10, 20);4、对象字段值⽐较类似于这种⽐较复杂的，建议⼤家可以反编译看看Expression<Func<People, bool>> predicate = c => c.Id == 10;Func<People, bool> func = pile();bool bResult = func.Invoke(new People(){Id = 10});//参数表达式ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "c");//反射获取属性FieldInfo fieldId = typeof(People).GetField("Id");//通过parameterExpression来获取调⽤IdMemberExpression idExp = Expression.Field(parameterExpression, fieldId);//常量表达式ConstantExpression constant10 = Expression.Constant(10, typeof(int));//⼆元表达式BinaryExpression expressionExp = Expression.Equal(idExp, constant10);Expression<Func<People, bool>> predicate1 = mbda<Func<People, bool>>(expressionExp, new ParameterExpression[1] {parameterExpression});Func<People, bool> func1 = pile();bool bResult1 = func1.Invoke(new People(){Id = 10});5、多条件如果遇到很长的表达式⽬录树，拼装建议从右往左拼装Expression<Func<People, bool>> predicate = c => c.Id.ToString() == "10" && .Equals("张三") && c.Age > 35; Func<People, bool> func = pile();bool bResult = func.Invoke(new People(){Id = 10,Name = "张三",Age = 36});ParameterExpression parameterExpression = Expression.Parameter(typeof(People), "c");//c.Age > 35ConstantExpression constant35 = Expression.Constant(35);PropertyInfo propAge = typeof(People).GetProperty("Age");MemberExpression ageExp = Expression.Property(parameterExpression, propAge);BinaryExpression cagExp = Expression.GreaterThan(ageExp, constant35);//.Equals("张三")ConstantExpression constantrichard = Expression.Constant("张三");PropertyInfo propName = typeof(People).GetProperty("Name");MemberExpression nameExp = Expression.Property(parameterExpression, propName);MethodInfo equals = typeof(string).GetMethod("Equals", new Type[] { typeof(string) });MethodCallExpression NameExp = Expression.Call(nameExp, equals, constantrichard);//c.Id.ToString() == "10"ConstantExpression constantExpression10 = Expression.Constant("10", typeof(string));FieldInfo fieldId = typeof(People).GetField("Id");var idExp = Expression.Field(parameterExpression, fieldId);MethodInfo toString = typeof(int).GetMethod("ToString", new Type[0]);var toStringExp = Expression.Call(idExp, toString, Array.Empty<Expression>());var EqualExp = Expression.Equal(toStringExp, constantExpression10);//c.Id.ToString() == "10"&& .Equals("张三")&& c.Age > 35var plus = Expression.AndAlso(EqualExp, NameExp);var exp = Expression.AndAlso(plus, cagExp);Expression<Func<People, bool>> predicate1 = mbda<Func<People, bool>>(exp, new ParameterExpression[1] {parameterExpression});Func<People, bool> func1 = pile();bool bResult1 = func1.Invoke(new People(){Id = 10,Name = "张三",Age = 36});四、Expression应⽤之Mapper映射需求：需要把People字段值映射到PeopleCopy字段1、硬编码性能好，不灵活；不能共⽤PeopleCopy peopleCopy0 = new PeopleCopy(){Id = people.Id,Name = ,Age = people.Age};2、反射灵活，但是性能不好using System;namespace MyExpression.MappingExtend{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 propIn = tIn.GetType().GetProperty();itemOut.SetValue(tOut, propIn.GetValue(tIn));}foreach (var itemOut in tOut.GetType().GetFields()){var fieldIn = tIn.GetType().GetField();itemOut.SetValue(tOut, fieldIn.GetValue(tIn));}return tOut;}}}调⽤PeopleCopy peopleCopy1 = ReflectionMapper.Trans<People, PeopleCopy>(people);3、序列化灵活，但是性能不好using Newtonsoft.Json;namespace MyExpression.MappingExtend{public class SerializeMapper{/// <summary>/// 序列化/// </summary>/// <typeparam name="TIn"></typeparam>/// <typeparam name="TOut"></typeparam>public static TOut Trans<TIn, TOut>(TIn tIn){string strJson = JsonConvert.SerializeObject(tIn);return JsonConvert.DeserializeObject<TOut>(strJson);}}}调⽤PeopleCopy peopleCopy2 = SerializeMapper.Trans<People, PeopleCopy>(people);4、Expression动态拼接+普通缓存把People变成PeopleCopy的过程封装在⼀个委托中，这个委托通过表达式⽬录树Compile出来，过程动态拼装适应不同的类型第⼀次⽣成的时候，保存⼀个委托在缓存中，如果第⼆次来，委托就可以直接从缓存中获取到，直接运⾏委托，效率⾼using System;using System.Collections.Generic;using System.Linq.Expressions;namespace MyExpression.MappingExtend{public class ExpressionMapper{/// <summary>/// 字典缓存，保存的是委托，委托内部是转换的动作/// </summary>private static Dictionary<string, object> _Dic = new Dictionary<string, object>();/// <summary>/// Expression动态拼接+普通缓存/// </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 = $"funckey_{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());MemberBinding memberBinding = Expression.Bind(item, property);memberBindingList.Add(memberBinding);foreach (var item in typeof(TOut).GetFields()){MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField());MemberBinding memberBinding = Expression.Bind(item, property);memberBindingList.Add(memberBinding);}MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray()); Expression<Func<TIn, TOut>> lambda = mbda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[] {parameterExpression});Func<TIn, TOut> func = pile();//拼装是⼀次性的_Dic[key] = func;}return ((Func<TIn, TOut>)_Dic[key]).Invoke(tIn);}}}调⽤PeopleCopy peopleCopy3 = ExpressionMapper.Trans<People, PeopleCopy>(people);5、Expression动态拼接+泛型缓存泛型缓存，就是为每⼀组类型的组合，⽣成⼀个副本，性能最⾼using System;using System.Collections.Generic;using System.Linq.Expressions;namespace MyExpression.MappingExtend{/// <summary>/// Expression动态拼接+泛型缓存/// </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());MemberBinding memberBinding = Expression.Bind(item, property);memberBindingList.Add(memberBinding);}foreach (var item in typeof(TOut).GetFields()){MemberExpression property = Expression.Field(parameterExpression, typeof(TIn).GetField());MemberBinding memberBinding = Expression.Bind(item, property);memberBindingList.Add(memberBinding);}MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberBindingList.ToArray()); Expression<Func<TIn, TOut>> lambda = mbda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[] {parameterExpression});_FUNC = pile();//拼装是⼀次性的}public static TOut Trans(TIn t){return _FUNC(t);}}}调⽤PeopleCopy peopleCopy4 = ExpressionGenericMapper<People, PeopleCopy>.Trans(people);6、性能⽐较Expression动态拼接+泛型缓存性能⾼，⽽且灵活long common = 0;long generic = 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 = ,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");运⾏结果common = 32 msreflection = 1026 msserialize = 2510 mscache = 236 msgeneric = 31 ms五、ExpressionVisitor解析Expression1、Expression解析Expression是通过访问者模式进⾏解析的，官⽅提供了ExpressionVisitor抽象类ExpressionVisitor的Visit⽅法是解析表达式⽬录树的⼀个⼊⼝，Visit⽅法判断Expression是⼀个什么表达式⽬录树，⾛不同的细分⽅法进⾏进⼀步解析ExpressionVisitor的VisitBinary⽅法是对⼆元表达式的解析，所有复杂的表达式都会拆解成⼆元表达式进⾏解析2、Expression修改⾃定义⼀个OperationsVisitor，继承⾃ExpressionVisitor，复写⽗类的VisitBinary⽅法，修改Expression的解析OperationsVisitor定义using System.Linq.Expressions;namespace MyExpression{/// <summary>/// ⾃定义Visitor/// </summary>public class OperationsVisitor : ExpressionVisitor{/// <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);}}}Expression解析转换Expression<Func<int, int, int>> exp = (m, n) => m * n + 2;Console.WriteLine(exp.ToString());OperationsVisitor visitor = new OperationsVisitor();Expression expNew = visitor.Visit(exp);Console.WriteLine(expNew.ToString());运⾏结果(m, n) => ((m * n) + 2)(m, n) => ((m / n) - 2)3、封装多条件连接扩展⽅法扩展⽅法实现/// <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){if (expr1 == null || expr2 == null){throw new Exception("null不能处理");}ParameterExpression newParameter = Expression.Parameter(typeof(T), "x");NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);Expression left = visitor.Visit(expr1.Body);Expression right = visitor.Visit(expr2.Body);BinaryExpression body = Expression.And(left, right);return mbda<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) {if (expr1 == null || expr2 == null){throw new Exception("null不能处理");}ParameterExpression newParameter = Expression.Parameter(typeof(T), "x");NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);Expression left = visitor.Visit(expr1.Body);Expression right = visitor.Visit(expr2.Body);BinaryExpression body = Expression.Or(left, right);return mbda<Func<T, bool>>(body, newParameter);}/// <summary>/// 表达式取⾮/// </summary>/// <typeparam name="T"></typeparam>/// <param name="expr"></param>/// <returns></returns>public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr){if (expr == null){throw new Exception("null不能处理");}ParameterExpression newParameter = expr.Parameters[0];UnaryExpression body = Expression.Not(expr.Body);return mbda<Func<T, bool>>(body, newParameter);}}⾃定义Visitorinternal class NewExpressionVisitor : ExpressionVisitor{public ParameterExpression _NewParameter { get; private set; }public NewExpressionVisitor(ParameterExpression param){this._NewParameter = param;}protected override Expression VisitParameter(ParameterExpression node){return this._NewParameter;}}数据过滤⽅法定义/// <summary>/// 筛选数据执⾏/// </summary>/// <param name="func"></param>private static void Do(Expression<Func<People, bool>> func){List<People> people = new List<People>(){new People(){Id=4,Name="123",Age=4},new People(){Id=5,Name="234",Age=5},new People(){Id=6,Name="345",Age=6},};List<People> peopleList = people.Where(pile()).ToList();}Expression拼接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();//⾮Do(lambda3);Do(lambda4);Do(lambda5);六、ExpressionVisitor应⽤之ToSql需求：实现ORM框架Expression映射成SQL⾃定义⼀个ConditionBuilderVisitor继承⾃ExpressionVisitor，复写⽗类的⽅法，Expression解析过程中实现SQL的拼接using System;using System.Collections.Generic;using System.Linq.Expressions;using System.Reflection;namespace MyExpression{public class ConditionBuilderVisitor : ExpressionVisitor{private Stack<string> _StringStack = new Stack<string>();/// <summary>/// 返回拼装好的sql条件表达式/// </summary>/// <returns></returns>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(" " + ToSqlOperator(node.NodeType) + " ");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");if (node.Expression is ConstantExpression){var value1 = this.InvokeValue(node);var value2 = this.ReflectionValue(node);this._StringStack.Push("'" + value2 + "'");}else{this._StringStack.Push(" [" + + "] ");}return node;}private string ToSqlOperator(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("不⽀持该⽅法");}}private object InvokeValue(MemberExpression member){var objExp = Expression.Convert(member, typeof(object));//struct需要return mbda<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 (){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;}}}ConstantSqlString泛型缓存缓存⽣成的sqlusing System;using System.Linq;namespace MyExpression{public class ConstantSqlString<T>{/// <summary>/// 泛型缓存，⼀个类型⼀个缓存/// </summary>private static string FindSql = null;/// <summary>/// 获取查询sql/// </summary>static ConstantSqlString(){Type type = typeof(T);FindSql = $"Select {string.Join(',', type.GetProperties().Select(c => $"[{}]").ToList())} from {}";}/// <summary>/// 获取查询sql+条件筛选/// </summary>/// <param name="exp"></param>/// <returns></returns>public static string GetQuerySql(string exp){return $"{FindSql} where {exp}";}}}普通多条件Expression<Func<People, bool>> lambda = x => x.Age > 5&& x.Id > 5&& .StartsWith("1") // like '1%'&& .EndsWith("1") // like '%1'&& .Contains("1");// like '%1%'ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();vistor.Visit(lambda);string sql = ConstantSqlString<People>.GetQuerySql(vistor.Condition());Console.WriteLine(sql);外部参数变量string name = "AAA";Expression<Func<People, bool>> lambda = x => x.Age > 5 && == name || x.Id > 5;ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();vistor.Visit(lambda);string sql = ConstantSqlString<People>.GetQuerySql(vistor.Condition());Console.WriteLine(sql);内部常量多条件Expression<Func<People, bool>> lambda = x => x.Age > 5 || ( == "A" && x.Id > 5);ConditionBuilderVisitor vistor = new ConditionBuilderVisitor();vistor.Visit(lambda);string sql = ConstantSqlString<People>.GetQuerySql(vistor.Condition());Console.WriteLine(sql);运⾏结果Select [Age],[Name] from People where ((((( [Age] > 5) AND ( [Id] > 5)) AND ( [Name] LIKE '1%')) AND ( [Name] LIKE '%1')) AND ( [Name] LIKE '%1%')) Select [Age],[Name] from People where ((( [Age] > 5) AND ( [Name] = 'AAA')) OR ( [Id] > 5))Select [Age],[Name] from People where (( [Age] > 5) OR (( [Name] = A) AND ( [Id] > 5)))七、多条件拼接⽰例1、动态拼接lambda表达式/// <summary>/// Lambda表达式拼接扩展类/// </summary>public static class Utility{/// <summary>/// Lambda表达式拼接/// </summary>/// <typeparam name="T"></typeparam>/// <param name="first"></param>/// <param name="second"></param>/// <param name="merge"></param>。
