表达式目录树
文章目录：
1、简单的表达式树实现以及声明方式
2、表达式树条件拼接
3、表达式树关系映射
4、表达式树访问者
5、表达式树扩展
简单介绍表达式树
相信大家使用EF框架的时候，对实体集延迟查询对象IQueryable一定不陌生，对实体集操作的时候，参数要求传递一个Expression<TDelegate>的泛型类，泛型参数是一个委托Expression；然后Expression<TDelegate>又继承自LambdaExpression抽象类，其父类是Expression抽象类，Expression抽象类就是我们所说的表达式目录树基类，如下图所示。
1、简单的表达式树实现以及声明方式
首先我们看以下一段代码
//普通的Lambda表达式
Func<int,int,int> func = (x,y)=> x + y - 2;
//表达式目录树的Lambda表达式声明方式
Expression<Func<int, int, int>> expression = (x, y) => x + y - 2;
//表达式目录树的拼接方式实现
ParameterExpression parameterx = Expression.Parameter(typeof(int), "x");
ParameterExpression parametery = Expression.Parameter(typeof(int), "y");
ConstantExpression constantExpression = Expression.Constant(2, typeof(int));
BinaryExpression binaryAdd = Expression.Add(parameterx, parametery);
BinaryExpression binarySubtract = Expression.Subtract(binaryAdd, constantExpression);
Expression<Func<int, int, int>> expressionMosaic = Expression.Lambda<Func<int, int, int>>(binarySubtract, new ParameterExpression[]
{
parameterx,
parametery
});
int ResultLambda = func(5, 2);
int ResultExpression = expression.Compile()(5, 2);
int ResultMosaic = expressionMosaic.Compile()(5, 2);
Console.WriteLine($"func:{ResultLambda}");
Console.WriteLine($"expression:{ResultExpression}");
Console.WriteLine($"expressionMosaic:{ResultMosaic}");
上面这段代码分别用普通的委托，表达式目录树的lambda实现方式，表达式目录树的拼接方式实现了两个变量相加再减去一个常量。结果很显然都是5如下图：
上面两段代码相信就不用解释了，让我们来看一下目录树拼接这段代码，
ParameterExpression parameterx = Expression.Parameter(typeof(int), "x");//声明一个参数表达式，int类型，名字叫“x”
ConstantExpression constantExpression = Expression.Constant(2, typeof(int));//声明一个常量表达式，int类型，值为2
BinaryExpression binaryAdd = Expression.Add(parameterx, parametery); //二进制运算符表达式相加 BinaryExpression binarySubtract = Expression.Subtract(binaryAdd, constantExpression);//二进制运算符表达式相减
//将表达式树翻译成lambda表达式，并将变量参数传入
Expression<Func<int, int, int>> expressionMosaic = Expression.Lambda<Func<int, int, int>>(binarySubtract, new ParameterExpression[]
{
parameterx,
parametery
});
//编译执行 int ResultMosaic = expressionMosaic.Compile()(5, 2);
让我们再来看一个例子
//目录树的Lambda声明方式
Expression<Func<Book, bool>> expressionLambda = x => x.Id.ToString().Equals("6");
//目录树的变量声明拼接方式
ParameterExpression parameterExpression = Expression.Parameter(typeof(Book), "x"); //声明一个参数表达式，Book类型，名字叫“x”
Expression<Func<Book, bool>> expression = Expression.Lambda<Func<Book, bool>>(
Expression.Call( //Expression.Call创建一个表示带参数的方法调用
Expression.Call(
Expression.Property(parameterExpression, typeof(Book).GetProperty("Id")), //反射拿到Id属性
typeof(Int32).GetMethod("ToString", new Type[] { }), //反射拿到Int类型的Tostring方法
new Expression[0]), //这里是没有参数的
typeof(string).GetMethod("Equals", new Type[] { typeof(string) }), //反射拿到String的Equals 方法
new Expression[]
{
Expression.Constant("6",typeof(string)) //反射拿到String的Equals 5
})
, new ParameterExpression[] //最后一个参数，代表传入的book
{
parameterExpression
});
bool a = expressionLambda.Compile()(new Book { Id = 4, Name = "C#高级编程", Price = 100 });
bool b = expressionLambda.Compile()(new Book { Id = 6, Name = "CLR Via C#", Price = 100 });
bool c = expression.Compile()(new Book { Id = 4, Name = "C#高级编程", Price = 100 });
bool d = expression.Compile()(new Book { Id = 6, Name = "CLR Via C#", Price = 100 });
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
Console.Read();
相信到这里，对表达式目录树拼接有一个基本的认识了，第一个例子这个过程有点像后缀表达式（逆波兰式）的执行。5+2-2 从左往右遍历入栈，遇到运算符出栈运算后入栈。
2、表达式树条件拼接
平时业务中，经常要根据用户的输入参数进行数据过滤，下面两种方法我们一起对比一下
//这里用List 然后AsQueryable转下 偷个懒。。
List<Book> books = new List<Book> { new Book{Id = 1,Name ="C#高级编程第1版",Price=100}, new Book{Id = 2,Name ="C#高级编程第2版",Price=110}, new Book{Id = 3,Name ="C#高级编程第3版",Price=120}, new Book{Id = 4,Name ="C#高级编程第5版",Price=130}, new Book{Id = 5,Name ="C#高级编程第5版",Price=140}, new Book{Id = 6,Name ="C#高级编程第5版",Price=150}, new Book{Id = 6,Name ="C#高级编程第7版",Price=160}, }; //这里我们查询三个条件 QueryDto query = new QueryDto { Id = 3, Name = "第5版", Price = 140 }; //我们一般用EF查询时候 var entitys = books.AsQueryable(); if (query.Id.HasValue) entitys = entitys.Where(t => t.Id == query.Id.Value); if (!string.IsNullOrEmpty(query.Name)) entitys = entitys.Where(t => t.Name.Contains(query.Name)); if (query.Price.HasValue) entitys = entitys.Where(t => t.Price == query.Price.Value); //表达式树拼接方式 Expression<Func<Book, bool>> expression = t => true; ParameterExpression parameterExpression = Expression.Parameter(typeof(Book), "x"); var ee = typeof(int).GetMethods(); if (query.Id.HasValue) { MemberExpression memberExpressionId = Expression.Property(parameterExpression, typeof(Book).GetProperty("Id")); MethodCallExpression method = Expression.Call(memberExpressionId , typeof(int).GetMethod("Equals", new Type[] { typeof(int) }) , new Expression[] { Expression.Constant(query.Id.Value, typeof(int)) }); expression = Expression.Lambda<Func<Book, bool>>(method, new ParameterExpression[] { parameterExpression }); } if (!string.IsNullOrEmpty(query.Name)) { MemberExpression memberExpressionName = Expression.Property(parameterExpression, typeof(Book).GetProperty("Name")); MethodCallExpression method = Expression.Call(memberExpressionName , typeof(string).GetMethod("Contains", new Type[] { typeof(string) }) , new Expression[] { Expression.Constant(query.Name, typeof(string)) }); expression = Expression.Lambda<Func<Book, bool>>(method, new ParameterExpression[] { parameterExpression }); } if (query.Price.HasValue) { MemberExpression memberExpressionId = Expression.Property(parameterExpression, typeof(Book).GetProperty("Price")); MethodCallExpression method = Expression.Call(memberExpressionId , typeof(double).GetMethod("Equals", new Type[] { typeof(double) }) , new Expression[] { Expression.Constant(query.Price.Value, typeof(double)) }); expression = Expression.Lambda<Func<Book, bool>>(method, new ParameterExpression[] { parameterExpression }); } var entity = books.AsQueryable().Where(expression);
大家可以对比下这两种方式那种比较好。第二种虽然要多写代码，但是防止了数据暴露的风险。
这里借鉴 腾飞（Jesse）前辈的几张图，博客地址=》 http://www.cnblogs.com/jesse2013/p/expressiontree-part1.html
3、表达式树关系映射
平时工作中，经常会有这样的需求，就是数据库实体映射为DTO，返回给前端。例如这里的Book是我们的数据库实体类，BookCopy 是Dto类
public class Book
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public double Price { get; set; }
}
public class BookCopy
{
public int Id { get; set; }
public string Name { get; set; }
public double Price { get; set; }
}
最简单粗暴的方法应该是这样。
//写死的属性映射
Book book = new Book
{
Id = 1,
Name = "C#高级编程",
Price = 100.00
};
BookCopy bookCopy = new BookCopy
{
Id = book.Id,
Name = book.Name,
Price = book.Price
};
//目录树的方式
Expression<Func<Book, BookCopy>> expression = b =>
new BookCopy
{
Id = b.Id,
Name = b.Name,
Price = b.Price
};
但是这样写的话特别不灵活，还是写死的。假如我们的Book类又添加一个属性"Press"，那又得改动代码，所以我们可以用反射的放射+表达式树参数拼接来实现
//参数拼接的方式
ParameterExpression parameterExpression = Expression.Parameter(typeof(Book), "book");
List<MemberBinding> memberbindingList = new List<MemberBinding>(); //表示绑定的类派生自的基类，这些绑定用于对新创建对象的成员进行初始化(vs的注解。太生涩了，我这样的小白解释不了，大家将就着看)
foreach (var item in typeof(BookCopy).GetProperties()) //遍历BookCopy的所有属性
{
MemberExpression property = Expression.Property(parameterExpression, typeof(Book).GetProperty(item.Name));//拿到Book的这个属性
MemberBinding memberBinding = Expression.Bind(item, property); //初始化这个属性
memberbindingList.Add(memberBinding);
}
foreach(var item in typeof(BookCopy).GetFields())
{
MemberExpression filed = Expression.Field(parameterExpression, typeof(Book).GetField(item.Name));//拿到book的这个字段，这里book类没有字段。。
MemberBinding memberBinding = Expression.Bind(item, filed);
memberbindingList.Add(memberBinding);
}
MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(BookCopy)), memberbindingList);//初始化创建新对象
Expression<Func<Book,BookCopy>> ExpressionRun = Expression.Lambda<Func<Book, BookCopy>>(memberInitExpression, new ParameterExpression[]{
parameterExpression
});
var ExpressionbookCopy = ExpressionRun.Compile()(book);
结果如上图所示，但是问题又来了，我们不可能只有一个类，也不可能只有一个Dto，那我们应该怎么实现呢？ 对 ，可以用泛型来实现
public class ExpressionMapper<TIn,TOut>
{
public static Func<TIn, TOut> _FuncCatch = null; //我们这里利用静态类的特性作为一个缓存，静态类跟随类的初始化创建，而且有CLR保证单例的
static ExpressionMapper()
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(TIn), "entity");
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 filed = Expression.Field(parameterExpression, typeof(TIn).GetField(item.Name));
MemberBinding memberBinding = Expression.Bind(item, filed);
memberbindingList.Add(memberBinding);
}
MemberInitExpression memberInitExpression = Expression.MemberInit(Expression.New(typeof(TOut)), memberbindingList);
Expression<Func<TIn, TOut>> ExpressionRun = Expression.Lambda<Func<TIn, TOut>>(memberInitExpression, new ParameterExpression[]{
parameterExpression
});
_FuncCatch = ExpressionRun.Compile(); //静态构造函数，每一次只有Tin或者Tout不同的时候才会创建新的变量_FuncCatch
}
public static TOut Mapping(TIn t) //取出TOut,静态变量是一个Func,参数是传入的Tin 实例
{
return _FuncCatch(t);
}
让我们来测试一波性能如何=》
4、表达式树访问者
这里先让我们看下IQueryable对象，IQueryable有三个属性，Provider属性就是拿到当前解析的表达式树，并将表达式树交给Expression（个人理解，不对地方希望大家指正）。
C#给我们提供了一个抽象类，ExpressionVisitor，我们可以通过这个继承抽象类，重写这个抽象类的方法来访问表达式树中的各个节点，达到自己预定义的效果
public class MyOperationVisitor : ExpressionVisitor //定义自己的表达式树访问者类，继承ExpressionVisitor抽象类
{
public Expression Modify(Expression expression) //对外公开的方法
{
return this.Visit(expression);
}
protected override Expression VisitBinary(BinaryExpression node) //假如这里是个二元运算，代码运行我们重写VisitBinary方法的逻辑
{
if(node.NodeType == ExpressionType.Add) //假如这里是个加法运算我们给它改成一个减法
{
Expression left = this.Visit(node.Left);
Expression right = this.Visit(node.Right);
return Expression.Subtract(left, right);
}
if(node.NodeType == ExpressionType.LessThan) //假如这里是个<运算我们给它改成>
{
Expression left = this.Visit(node.Left);
Expression right = this.Visit(node.Right);
return Expression.GreaterThan(left, right);
}
return base.VisitBinary(node);
}
protected override Expression VisitConstant(ConstantExpression node) //假如节点中存在常量,我们打印个hahahah
{
Console.WriteLine("hahahah");
return base.VisitConstant(node);
}
}
这里的 x*y+2目录树的访问方式就像右图我画的那样，二叉树的中序遍历。这里再借用腾飞前辈博客里面的一张图
接下来，趁热打铁，让我们来根据表达式树的条件生成自定义SQL脚本===================华丽的分割线====================================================
public class MyConditionVisitor: ExpressionVisitor
{
private Queue<string> _queueCommand = new Queue<string>(); //这里我们用一个队列来保存生成的脚本
public string Condition() //返回脚本
{
string condition = string.Concat(_queueCommand.ToArray());
this._queueCommand.Clear();
return condition;
}
/// <summary>
/// 处理二元表达式
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override Expression VisitBinary(BinaryExpression node)
{
if (node == null)
throw new ArgumentException("BinaryExpression");
this._queueCommand.Enqueue("(");
base.Visit(node.Left);
this._queueCommand.Enqueue($" {node.NodeType.ToSqlCommandString()} ");
base.Visit(node.Right);
this._queueCommand.Enqueue(")");
return node;
}
/// <summary>
/// 访问每一个成员
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override Expression VisitMember(MemberExpression node)
{
if(node ==null)
throw new ArgumentException("MemberExpression");
this._queueCommand.Enqueue($"[{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");
switch (node.Value.GetType().Name)
{
case "String":
this._queueCommand.Enqueue($" ' {node.Value} '");
break;
case "Boolean":
this._queueCommand.Enqueue((bool)node.Value ? "1" : "0");
break;
default:
this._queueCommand.Enqueue(node.Value.ToString());
break;
}
return node;
}
/// <summary>
/// 方法表达式
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node == null)
throw new ArgumentNullException("MethodCallExpression");
string format = string.Empty;
switch (node.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(node.NodeType + " is not supported!");
}
this.Visit(node.Object);
this.Visit(node.Arguments[0]);
this._queueCommand.Enqueue(string.Format(format, node.Object, node.Arguments[0]));
return node;
}
}
这里我们把二元运算符用扩展方法的形式标识，代码如下
/// <summary>
/// 使用一个扩展方法处理二元运算符
/// </summary>
public static class CommandCreaterHelper
{
public static string ToSqlCommandString(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("不支持该方法");
}
}
}
让我们来测试下、、
5、表达式树扩展
1 /// <summary> 2 /// 合并表达式 And Or Not扩展 3 /// </summary> 4 public static class ExpressionExtend 5 { 6 /// <summary> 7 /// 合并表达式 expr1 AND expr2 8 /// </summary> 9 /// <typeparam name="T"></typeparam> 10 /// <param name="expr1"></param> 11 /// <param name="expr2"></param> 12 /// <returns></returns> 13 public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2) 14 { 15 //return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expr1.Body, expr2.Body), expr1.Parameters); 16 ParameterExpression newParameter = Expression.Parameter(typeof(T), "c"); 17 NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter); 18 19 var left = visitor.Replace(expr1.Body); 20 var right = visitor.Replace(expr2.Body); 21 var body = Expression.And(left, right); 22 return Expression.Lambda<Func<T, bool>>(body, newParameter); 23 24 } 25 /// <summary> 26 /// 合并表达式 expr1 or expr2 27 /// </summary> 28 /// <typeparam name="T"></typeparam> 29 /// <param name="expr1"></param> 30 /// <param name="expr2"></param> 31 /// <returns></returns> 32 public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2) 33 { 34 35 ParameterExpression newParameter = Expression.Parameter(typeof(T), "c"); 36 NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter); 37 38 var left = visitor.Replace(expr1.Body); 39 var right = visitor.Replace(expr2.Body); 40 var body = Expression.Or(left, right); 41 return Expression.Lambda<Func<T, bool>>(body, newParameter); 42 } 43 public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr) 44 { 45 var candidateExpr = expr.Parameters[0]; 46 var body = Expression.Not(expr.Body); 47 48 return Expression.Lambda<Func<T, bool>>(body, candidateExpr); 49 } 50 } 51 52 53 54 55 /// <summary> 56 /// 建立新表达式 57 /// </summary> 58 internal class NewExpressionVisitor : ExpressionVisitor 59 { 60 public ParameterExpression _NewParameter { get; private set; } 61 public NewExpressionVisitor(ParameterExpression param) 62 { 63 this._NewParameter = param; 64 } 65 public Expression Replace(Expression exp) 66 { 67 return this.Visit(exp); 68 } 69 protected override Expression VisitParameter(ParameterExpression node) 70 { 71 return this._NewParameter; 72 } 73 }
相关链接
https://www.cnblogs.com/castyuan/category/1033520.html
https://www.cnblogs.com/liumengchen-boke/p/7900766.html
