C#表达式树（Expression Trees）动态构建指南
2023-03-091.2k 阅读
C# 表达式树基础
在 C# 中，表达式树（Expression Trees）以一种数据结构的形式来表示代码中的表达式。这使得我们能够在运行时动态地创建和操作代码，而不仅仅是像传统方式那样在编译时就确定好代码逻辑。表达式树的节点构成了一个树形结构，每个节点代表表达式的一个部分，例如方法调用、变量访问、常量值等。
表达式树类型
- Lambda 表达式：Lambda 表达式在 C# 中是一种简洁的匿名函数表示方式，它可以很自然地转换为表达式树。例如：
Func<int, int, int> add = (a, b) => a + b;
Expression<Func<int, int, int>> addExpression = (a, b) => a + b;
这里 add 是一个普通的委托，而 addExpression 是一个表达式树。Lambda 表达式被转换为表达式树后，我们就可以对其进行分析和修改。
- 表达式树类：C# 提供了一系列的类来表示表达式树节点，如
Expression类是所有表达式节点的基类。BinaryExpression用于表示二元操作符（如+,-,*等）的表达式，ConstantExpression表示常量值的表达式，ParameterExpression表示参数的表达式等。
表达式树的用途
- 动态查询：在 LINQ to SQL 或 Entity Framework 等数据访问技术中，表达式树被广泛用于构建动态查询。例如，当用户在应用程序中输入不同的查询条件时，可以动态构建表达式树来生成相应的 SQL 查询。
using System;
using System.Linq;
using System.Linq.Expressions;
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
}
public class DynamicQueryExample
{
public IQueryable<Product> FilterProducts(IQueryable<Product> products, string nameFilter, decimal? priceFilter)
{
Expression<Func<Product, bool>> filterExpression = product => true;
if (!string.IsNullOrEmpty(nameFilter))
{
Expression<Func<Product, bool>> nameFilterExpression = product => product.Name.Contains(nameFilter);
filterExpression = CombineExpressions(filterExpression, nameFilterExpression, Expression.AndAlso);
}
if (priceFilter.HasValue)
{
Expression<Func<Product, bool>> priceFilterExpression = product => product.Price <= priceFilter.Value;
filterExpression = CombineExpressions(filterExpression, priceFilterExpression, Expression.AndAlso);
}
return products.Where(filterExpression);
}
private Expression<Func<T, bool>> CombineExpressions<T>(Expression<Func<T, bool>> left, Expression<Func<T, bool>> right, Func<Expression, Expression, BinaryExpression> merge)
{
var parameter = Expression.Parameter(typeof(T));
var leftVisitor = new ReplaceExpressionVisitor(left.Parameters[0], parameter);
var leftExpression = leftVisitor.Visit(left.Body);
var rightVisitor = new ReplaceExpressionVisitor(right.Parameters[0], parameter);
var rightExpression = rightVisitor.Visit(right.Body);
var body = merge(leftExpression, rightExpression);
return Expression.Lambda<Func<T, bool>>(body, parameter);
}
private class ReplaceExpressionVisitor : ExpressionVisitor
{
private readonly Expression _oldValue;
private readonly Expression _newValue;
public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
{
_oldValue = oldValue;
_newValue = newValue;
}
public override Expression Visit(Expression node)
{
return node == _oldValue ? _newValue : base.Visit(node);
}
}
}
- 代码生成：可以通过表达式树动态生成代码逻辑，然后编译并执行。这在一些需要根据不同运行时条件生成特定功能代码的场景中非常有用，例如动态生成序列化/反序列化代码。
动态构建表达式树
动态构建表达式树需要深入理解表达式树的节点结构和如何组合这些节点。
构建简单表达式树
- 构建常量表达式：常量表达式是表达式树中最基础的节点之一，用于表示固定的值。
ConstantExpression constantExpression = Expression.Constant(42, typeof(int));
这里创建了一个表示整数 42 的常量表达式。
- 构建参数表达式：参数表达式用于表示表达式中的参数。
ParameterExpression parameterExpression = Expression.Parameter(typeof(int), "x");
这创建了一个名为 “x” 的整数类型参数表达式。
- 构建二元表达式：二元表达式用于表示包含两个操作数的操作，如加法、乘法等。
ParameterExpression a = Expression.Parameter(typeof(int), "a");
ParameterExpression b = Expression.Parameter(typeof(int), "b");
BinaryExpression addExpression = Expression.Add(a, b);
这里构建了一个 a + b 的二元表达式，其中 a 和 b 是参数。
构建复杂表达式树
- 方法调用表达式：在表达式树中，方法调用可以通过
MethodCallExpression类来构建。假设我们有一个简单的类和方法：
public class MathUtils
{
public static int Multiply(int a, int b)
{
return a * b;
}
}
可以这样构建调用 Multiply 方法的表达式树：
ParameterExpression num1 = Expression.Parameter(typeof(int), "num1");
ParameterExpression num2 = Expression.Parameter(typeof(int), "num2");
MethodCallExpression methodCallExpression = Expression.Call(
typeof(MathUtils).GetMethod("Multiply"),
num1,
num2
);
- 条件表达式：条件表达式（三元运算符
? :）在表达式树中由ConditionalExpression表示。例如：
ParameterExpression condition = Expression.Parameter(typeof(bool), "condition");
ParameterExpression ifTrue = Expression.Parameter(typeof(int), "ifTrue");
ParameterExpression ifFalse = Expression.Parameter(typeof(int), "ifFalse");
ConditionalExpression conditionalExpression = Expression.Condition(
condition,
ifTrue,
ifFalse
);
这构建了一个 condition? ifTrue : ifFalse 的条件表达式。
表达式树的编译与执行
构建好表达式树后，通常需要将其编译为可执行的代码。
编译表达式树
- Lambda 表达式编译：对于以 Lambda 表达式形式存在的表达式树，可以直接调用
Compile方法进行编译。
Expression<Func<int, int, int>> addExpression = (a, b) => a + b;
Func<int, int, int> addFunction = addExpression.Compile();
int result = addFunction(3, 5);
这里将 addExpression 编译为 Func<int, int, int> 类型的委托 addFunction，然后可以像调用普通方法一样调用它。
- 自定义表达式树编译：对于通过手动构建的复杂表达式树，同样可以编译。假设我们构建了一个复杂的表达式树，如
(a + b) * c：
ParameterExpression aParam = Expression.Parameter(typeof(int), "a");
ParameterExpression bParam = Expression.Parameter(typeof(int), "b");
ParameterExpression cParam = Expression.Parameter(typeof(int), "c");
BinaryExpression addExpr = Expression.Add(aParam, bParam);
MethodCallExpression multiplyExpr = Expression.Call(
typeof(MathUtils).GetMethod("Multiply"),
addExpr,
cParam
);
Expression<Func<int, int, int, int>> complexExpression = Expression.Lambda<Func<int, int, int, int>>(multiplyExpr, aParam, bParam, cParam);
Func<int, int, int, int> complexFunction = complexExpression.Compile();
int complexResult = complexFunction(2, 3, 4);
这里将复杂的表达式树编译为可执行的委托，并执行得到结果。
执行编译后的表达式
编译后的表达式以委托的形式存在，可以像调用普通方法一样调用它。委托的参数和返回值类型由表达式树的定义决定。例如上面编译后的 addFunction 和 complexFunction，可以根据其参数列表传入相应的值并获取返回结果。
表达式树的遍历与修改
在实际应用中，有时需要遍历表达式树以分析其结构，或者修改表达式树的节点。
遍历表达式树
- 递归遍历：通过递归的方式遍历表达式树是一种常见的方法。
ExpressionVisitor类是一个抽象类，我们可以继承它并实现Visit方法来遍历节点。
public class ExpressionTraverser : ExpressionVisitor
{
public override Expression Visit(Expression node)
{
if (node != null)
{
Console.WriteLine($"Visiting node: {node.NodeType}");
}
return base.Visit(node);
}
}
// 使用示例
Expression<Func<int, int, int>> addExpression = (a, b) => a + b;
ExpressionTraverser traverser = new ExpressionTraverser();
traverser.Visit(addExpression);
这里 ExpressionTraverser 类继承自 ExpressionVisitor，并重写了 Visit 方法，在遍历每个节点时输出节点类型。
- 深度优先与广度优先遍历：深度优先遍历会先深入到子节点，而广度优先遍历会先遍历同一层的所有节点。通过适当的数据结构（如栈或队列）可以实现不同的遍历方式。例如，使用栈实现深度优先遍历：
using System.Collections.Generic;
public class DepthFirstTraverser
{
public void Traverse(Expression expression)
{
Stack<Expression> stack = new Stack<Expression>();
stack.Push(expression);
while (stack.Count > 0)
{
Expression node = stack.Pop();
Console.WriteLine($"Visiting node: {node.NodeType}");
if (node is BinaryExpression binaryExpr)
{
stack.Push(binaryExpr.Left);
stack.Push(binaryExpr.Right);
}
else if (node is MethodCallExpression methodCallExpr)
{
foreach (var arg in methodCallExpr.Arguments)
{
stack.Push(arg);
}
}
}
}
}
修改表达式树
- 替换节点：有时需要替换表达式树中的某个节点。例如，我们想将表达式树中的某个常量值替换为另一个值。
public class ReplaceConstantVisitor : ExpressionVisitor
{
private readonly object _oldValue;
private readonly object _newValue;
public ReplaceConstantVisitor(object oldValue, object newValue)
{
_oldValue = oldValue;
_newValue = newValue;
}
public override Expression Visit(Expression node)
{
if (node is ConstantExpression constExpr && constExpr.Value.Equals(_oldValue))
{
return Expression.Constant(_newValue, constExpr.Type);
}
return base.Visit(node);
}
}
// 使用示例
Expression<Func<int, int>> expression = () => 5 + 3;
ReplaceConstantVisitor visitor = new ReplaceConstantVisitor(3, 7);
Expression newExpression = visitor.Visit(expression);
这里 ReplaceConstantVisitor 类继承自 ExpressionVisitor，在 Visit 方法中检查是否为目标常量节点，如果是则替换为新的常量节点。
- 插入节点：插入节点需要在遍历表达式树时，在合适的位置创建新节点并调整树的结构。例如，在二元表达式的两个操作数之间插入一个新的操作。
public class InsertNodeVisitor : ExpressionVisitor
{
private readonly Expression _newNode;
public InsertNodeVisitor(Expression newNode)
{
_newNode = newNode;
}
public override Expression VisitBinary(BinaryExpression node)
{
Expression left = Visit(node.Left);
Expression right = Visit(node.Right);
return Expression.Add(Expression.Add(left, _newNode), right);
}
}
// 使用示例
Expression<Func<int, int>> addExpression = () => 2 + 3;
InsertNodeVisitor insertVisitor = new InsertNodeVisitor(Expression.Constant(4));
Expression newAddExpression = insertVisitor.Visit(addExpression);
这里 InsertNodeVisitor 类重写了 VisitBinary 方法，在二元表达式的两个操作数之间插入了一个新的常量节点。
表达式树在实际项目中的应用案例
- 数据验证框架：在一个数据验证框架中，可以使用表达式树来动态构建验证逻辑。例如，对于不同类型的对象，根据其属性定义动态生成验证表达式。假设我们有一个用户类：
public class User
{
public string Name { get; set; }
public int Age { get; set; }
}
public class ValidationEngine
{
public Expression<Func<T, bool>> BuildValidationExpression<T>()
{
ParameterExpression parameter = Expression.Parameter(typeof(T), "obj");
Expression validationExpression = Expression.Constant(true);
if (typeof(T) == typeof(User))
{
MemberExpression nameExpr = Expression.Property(parameter, typeof(User).GetProperty("Name"));
MethodCallExpression nameLengthCheck = Expression.Call(nameExpr, typeof(string).GetMethod("Length"), new Expression[] { });
BinaryExpression nameLengthValid = Expression.GreaterThan(nameLengthCheck, Expression.Constant(0));
MemberExpression ageExpr = Expression.Property(parameter, typeof(User).GetProperty("Age"));
BinaryExpression ageValid = Expression.GreaterThan(ageExpr, Expression.Constant(0));
validationExpression = Expression.AndAlso(nameLengthValid, ageValid);
}
return Expression.Lambda<Func<T, bool>>(validationExpression, parameter);
}
}
这里 BuildValidationExpression 方法根据 T 的类型动态构建验证表达式树，对于 User 类型，验证用户名长度大于 0 且年龄大于 0。
- 动态规则引擎：在一个动态规则引擎中，表达式树可以用于表示不同的业务规则。例如，在一个订单处理系统中，根据订单金额、客户等级等条件动态生成处理规则。
public class Order
{
public decimal Amount { get; set; }
public int CustomerLevel { get; set; }
}
public class RuleEngine
{
public Expression<Func<Order, bool>> BuildDiscountRule()
{
ParameterExpression orderParam = Expression.Parameter(typeof(Order), "order");
MemberExpression amountExpr = Expression.Property(orderParam, typeof(Order).GetProperty("Amount"));
MemberExpression levelExpr = Expression.Property(orderParam, typeof(Order).GetProperty("CustomerLevel"));
BinaryExpression amountCondition = Expression.GreaterThan(amountExpr, Expression.Constant(100m));
BinaryExpression levelCondition = Expression.GreaterThan(levelExpr, Expression.Constant(2));
BinaryExpression discountRule = Expression.AndAlso(amountCondition, levelCondition);
return Expression.Lambda<Func<Order, bool>>(discountRule, orderParam);
}
}
这里 BuildDiscountRule 方法构建了一个表达式树，表示订单金额大于 100 且客户等级大于 2 时满足折扣规则。
通过以上详细的介绍，你应该对 C# 表达式树的动态构建有了较为深入的理解。从基础概念到动态构建、编译执行、遍历修改以及实际应用案例，表达式树为我们在运行时操作代码逻辑提供了强大的能力，在许多场景下都能发挥重要作用。