C# 表达式树详解

总目录

---

前言

在 C# 中，表达式树（Expression Trees）是一种强大的特性，允许开发者将代码表示为数据结构。这使得我们可以在运行时动态地创建和操作代码逻辑，广泛应用于 LINQ 查询、动态方法生成以及反射等领域。本文将深入探讨 C# 表达式树的创建、操作和应用场景。

---

一、什么是表达式树？

1. 定义

表达式树是一种树状数据结构，将代码表示为一棵树，其中每个节点代表一个操作或数据（如属性访问、方法调用、运算等）。例如，表达式 x + y 可拆解为三个节点：参数 x、参数 y 和加法运算符。

在 C# 中，表达式树由 System.Linq.Expressions 命名空间中的类来表示。表达式树在C#中广泛应用于动态LINQ查询、动态编译等领域。

表达式树是一种数据结构，用于表示代码的逻辑结构(代码中的逻辑和运算)。与普通的委托不同，表达式树不是直接执行代码，而是将其转换为一个可查询和操作的对象模型。这使得我们可以动态地构建、分析和修改代码逻辑。

2. 表达式树的基本组件

• Expression：表示表达式树的根节点或子表达式。
  • ParameterExpression：表示方法的参数。
  • MemberExpression：表示对对象成员（如属性或字段）的访问。
  • MethodCallExpression：表示对方法的调用。
  • BinaryExpression：表示二元运算（如加法、比较等）。
  • UnaryExpression：表示一元运算（如取反、递增等）。
  • ConstantExpression：表示常量值。
  • LambdaExpression：表示Lambda表达式主体。

2. 与委托和 Lambda 的区别

特性	表达式树	委托
表现形式	可分析的树结构	编译后的IL指令
运行时行为	可动态修改和重组	固定不可变
主要用途	代码生成、动态查询	直接方法调用
执行方式	需编译为委托后执行	直接调用

• 委托：编译时确定的函数指针，直接执行代码。
• Lambda 表达式：可隐式转换为委托或表达式树。
• 表达式树：将代码逻辑存储为数据结构，支持运行时动态解析和修改。

3. 核心特性

• 不可变性：创建后无法修改，每次操作生成新树。
• 可编译性：通过 Compile() 方法生成委托执行。
• 高效性：相比反射，编译后的表达式树性能接近原生代码。

4. 表达式树的组成部分

一个典型的表达式树包含以下几个部分：

• 参数：使用 ParameterExpression 定义lambda表达式的参数。
• 主体：表达式树的主体可以是单一的表达式或多个表达式的组合，例如二元表达式 BinaryExpression 用于表示加法、乘法等操作。
• lambda表达式：将参数和主体组合成一个lambda表达式，使用 Expression.Lambda 方法创建。

二、表达式树构建方式

1. 通过Lambda自动转换

Expression<Func<int, bool>> expr = num => num > 10 && num < 20;

public class Program
{public static void Main(){Expression<Func<int, bool>> expr = num => num > 10 && num < 20;Console.WriteLine(expr.ToString()); //输出：num => ((num > 10) AndAlso (num < 20))//编译并执行表达式树Func<int, bool> func = expr.Compile();        Console.WriteLine(func.Invoke(18)); //输出：True}
}

2. 手动构建表达式树

1）创建简单的表达式树

示例 1

表达式树通常使用 System.Linq.Expressions 命名空间中的类来构建。以下是一个简单的例子，展示如何创建一个基本的表达式树：

using System;
using System.Linq.Expressions;public class Program
{public static void Main(){// 创建参数表达式 xParameterExpression param = Expression.Parameter(typeof(int), "x");// 创建常量表达式 5ConstantExpression five = Expression.Constant(5, typeof(int));// 创建二元表达式 x + 5BinaryExpression add = Expression.Add(param, five);// 创建表达式树 x => (x + 5)Expression<Func<int, int>> expressionTree = Expression.Lambda<Func<int, int>>(add, param);Console.WriteLine(expressionTree);  // 输出: x => (x + 5)// 编译并执行表达式树Func<int, int> compiledFunc = expressionTree.Compile();Console.WriteLine(compiledFunc(10)); // 输出: 15}
}

示例 2

以下示例展示了如何创建一个简单的表达式树，该树表示两个数相加的表达式：

public class Program
{public static void Main(){// 创建参数表达式ParameterExpression a = Expression.Parameter(typeof(int), "a");ParameterExpression b = Expression.Parameter(typeof(int), "b");// 创建加法表达式BinaryExpression add = Expression.Add(a, b);// 创建 lambda 表达式Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(add, a, b);Console.WriteLine(lambda);  // 输出：(a, b) => (a + b)// 编译并调用表达式树Func<int, int, int> func = lambda.Compile();int result = func(2, 3);Console.WriteLine($"Result: {result}"); // 输出: Result: 5}
}

2）构建复杂的表达式树

除了简单的算术运算，我们还可以构建更复杂的表达式树，例如条件判断、方法调用等。

示例1：基本组合

using System;
using System.Linq.Expressions;
public class Program
{public static void Main(){// 定义参数ParameterExpression x = Expression.Parameter(typeof(int), "x");// 创建表达式：x * 2BinaryExpression multiply = Expression.Multiply(x, Expression.Constant(2));// 创建表达式：x * 2 + 3BinaryExpression add = Expression.Add(multiply, Expression.Constant(3));// 创建lambda表达式Expression<Func<int, int>> lambda = Expression.Lambda<Func<int, int>>(add, x);// 输出lambda表达式Console.WriteLine(lambda); // 输出: x => (x * 2 + 3)// 编译lambda表达式Func<int, int> compiledLambda = lambda.Compile();// 执行编译后的lambda表达式int result = compiledLambda(5);Console.WriteLine($"Result of compiled lambda: {result}"); // 输出: 13}
}

示例2： 条件判断

下面的例子展示了如何构建一个包含条件判断的表达式树：

using System;
using System.Linq.Expressions;public class Program
{public static void Main(){// 创建参数表达式 xParameterExpression param = Expression.Parameter(typeof(int), "x");// 创建常量表达式 10ConstantExpression ten = Expression.Constant(10, typeof(int));// 创建条件表达式 x > 10BinaryExpression greaterThan = Expression.GreaterThan(param, ten);// 创建 if-true 表达式 x * 2BinaryExpression trueResult = Expression.Multiply(param, Expression.Constant(2, typeof(int)));// 创建 if-false 表达式 x - 1BinaryExpression falseResult = Expression.Subtract(param, Expression.Constant(1, typeof(int)));// 创建条件表达式ConditionalExpression conditional = Expression.Condition(greaterThan, trueResult, falseResult);// 创建表达式树 x=>(x > 10)? (x * 2):(x - 1)Expression<Func<int, int>> expressionTree = Expression.Lambda<Func<int, int>>(conditional, param);Console.WriteLine(expressionTree);  // 输出：x => IIF((x > 10), (x * 2), (x - 1))// 编译并执行表达式树Func<int, int> compiledFunc = expressionTree.Compile();Console.WriteLine(compiledFunc(15)); // 输出: 30Console.WriteLine(compiledFunc(5));  // 输出: 4}
}

示例3：方法调用

表达式树还可以用于表示方法调用。以下是一个调用静态方法的例子：

using System;
using System.Linq.Expressions;public class Program
{public static int Add(int a, int b){return a + b;}public static void Main(){// 创建参数表达式 x 和 yParameterExpression paramX = Expression.Parameter(typeof(int), "x");ParameterExpression paramY = Expression.Parameter(typeof(int), "y");// 获取 Add 方法的信息MethodInfo addMethod = typeof(Program).GetMethod("Add", new[] { typeof(int), typeof(int) });// 创建方法调用表达式MethodCallExpression call = Expression.Call(addMethod, paramX, paramY);// 创建表达式树Expression<Func<int, int, int>> expressionTree = Expression.Lambda<Func<int, int, int>>(call, paramX, paramY);// 编译并执行表达式树Func<int, int, int> compiledFunc = expressionTree.Compile();Console.WriteLine(compiledFunc(3, 7)); // 输出: 10}
}

示例4：复杂表达式树的动态拼接

表达式树支持动态逻辑，例如根据条件生成查询：

using System;
using System.Linq.Expressions;
public class Person
{public int Age { get; set; }public string Name { get; set; }
}
public class Program
{public static void Main(){// 动态生成 "p.Age > 18 && p.Name == "Alice""// 创建参数表达式 pvar param = Expression.Parameter(typeof(Person), "p");// 创建条件表达式 p.Age > 18var ageCheck = Expression.GreaterThan(Expression.Property(param, "Age"), Expression.Constant(18));// 创建条件表达式 p.Name == "Alice"var nameCheck = Expression.Equal(Expression.Property(param, "Name"), Expression.Constant("Alice"));// 创建条件表达式 p.Age > 18 && p.Name == "Alice"var combined = Expression.AndAlso(ageCheck, nameCheck);// 创建Lambda表达式 p=>p.Age > 18 && p.Name == "Alice"var lambda = Expression.Lambda<Func<Person, bool>>(combined, param);Console.WriteLine(lambda);  // 输出：p => ((p.Age > 18) AndAlso (p.Name == "Alice"))// 编译并执行表达式树Func<Person, bool> compiledFunc = lambda.Compile();Console.WriteLine(compiledFunc(new Person { Age = 16, Name = "Jack" }));  // 输出: FalseConsole.WriteLine(compiledFunc(new Person { Age = 19, Name = "Alice" })); // 输出: True}
}

此特性在 ORM 框架（如 Entity Framework）中用于动态生成 SQL。

三、应用场景

1. 应用场景

• 动态查询：用于构建动态LINQ查询，特别适用于ORM框架。
• 动态代码生成与编译：在运行时生成并编译代码，适用于需要动态生成逻辑的应用场景。
• 元编程：通过解析和修改表达式树，实现高级编程模式，如方法拦截。
• 动态条件判断：根据外部输入或配置动态调整业务逻辑。
• 自定义运算符重载：扩展现有类型的运算符行为。

2. 应用场景示例

示例1：简单动态查询

表达式树最常见的一种应用是在动态查询中。例如，在LINQ to SQL中，表达式树被用来将C#查询转换为SQL查询。

using System;
using System.Linq;
using System.Linq.Expressions;public class Program
{public static void Main(){// 创建一个简单的列表var numbers = new[] { 1, 2, 3, 4, 5 };// 创建表达式树 x => x > 3ParameterExpression param = Expression.Parameter(typeof(int), "x");ConstantExpression three = Expression.Constant(3, typeof(int));BinaryExpression greaterThan = Expression.GreaterThan(param, three);Expression<Func<int, bool>> expressionTree = Expression.Lambda<Func<int, bool>>(greaterThan, param);// 使用表达式树进行查询var query = numbers.Where(expressionTree.Compile());Console.WriteLine(string.Join(",",query)); // 输出：4,5}
}

示例2：动态构建复杂查询条件

在 LINQ 查询中，表达式树可以用于动态构建查询条件，使得查询更加灵活。

using System;
using System.Collections.Generic;
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 Program
{public static void Main(){List<Product> products = new List<Product>{new Product { Id = 1, Name = "Laptop", Price = 999.99m },new Product { Id = 2, Name = "Mouse", Price = 19.99m },new Product { Id = 3, Name = "Keyboard", Price = 49.99m }};// 动态构建查询条件 p.Price >= 50.00ParameterExpression parameter = Expression.Parameter(typeof(Product), "p");MemberExpression priceMember = Expression.Property(parameter, "Price");ConstantExpression minPrice = Expression.Constant(50.00m);BinaryExpression condition = Expression.GreaterThanOrEqual(priceMember, minPrice);// 构建 lambda 表达式 p => p.Price >= 50.00Expression<Func<Product, bool>> predicate = Expression.Lambda<Func<Product, bool>>(condition, parameter);// 使用表达式树进行查询var expensiveProducts = products.Where(predicate.Compile());Console.WriteLine("Products with price >= 50.00:");foreach (var product in expensiveProducts){Console.WriteLine($"{product.Name}: {product.Price}");}}
}

运行结果：

Products with price >= 50.00:
Laptop: 999.99

示例3：动态生成代码

表达式树还可以用于在运行时生成并编译新的代码。这对于需要根据用户输入或配置动态生成逻辑的应用程序非常有用。

using System;
using System.Linq.Expressions;public class Program
{public static void Main(){// 动态生成一个 lambda 表达式 x => x * 2ParameterExpression param = Expression.Parameter(typeof(int), "x");BinaryExpression multiply = Expression.Multiply(param, Expression.Constant(2, typeof(int)));Expression<Func<int, int>> expressionTree = Expression.Lambda<Func<int, int>>(multiply, param);// 编译并执行表达式树Func<int, int> compiledFunc = expressionTree.Compile();Console.WriteLine(compiledFunc(5)); // 输出: 10}
}

示例4：元编程

表达式树可以用于元编程，即编写能够生成或修改其他代码的代码。例如，可以通过解析表达式树来实现AOP（面向切面编程）中的方法拦截功能。

假设我们有一个简单的日志拦截器，可以在方法调用前后记录日志。

using System;
using System.Linq.Expressions;
using System.Reflection;public class Program
{public static void Main(){// 创建表达式树来调用 Add 方法ParameterExpression paramX = Expression.Parameter(typeof(int), "x");ParameterExpression paramY = Expression.Parameter(typeof(int), "y");MethodInfo addMethod = typeof(Program).GetMethod("Add", BindingFlags.Public | BindingFlags.Static);MethodCallExpression call = Expression.Call(addMethod, paramX, paramY);// 创建带日志的表达式树Expression<Action<int, int>> logExpression = CreateLoggedExpression<int, int>(call, paramX, paramY);// 编译并执行表达式树Action<int, int> loggedAction = logExpression.Compile();loggedAction(3, 7);}public static int Add(int a, int b){Console.WriteLine($"Add：{a} + {b} ={a + b}");return a + b;}private static Expression<Action<T1, T2>> CreateLoggedExpression<T1, T2>(MethodCallExpression methodCall, ParameterExpression param1, ParameterExpression param2){//创建 代码块var block = Expression.Block(Expression.Call(null, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }), Expression.Constant("Entering Add")),methodCall,Expression.Call(null, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }), Expression.Constant("Exiting Add")));//以上功能类似于//Console.WriteLine("Entering Add");//Add(10,10);//Console.WriteLine("Exiting Add");return Expression.Lambda<Action<T1, T2>>(block, param1, param2);}
}

运行结果：

Entering Add
Add：3 + 7 =10
Exiting Add

示例5：动态条件判断

表达式树可以用于动态构建条件判断逻辑，适用于需要根据外部输入或配置动态调整业务逻辑的场景。

using System;
using System.Linq.Expressions;public class Program
{public static void Main(){// 创建参数表达式 xParameterExpression param = Expression.Parameter(typeof(int), "x");// 创建常量表达式 10ConstantExpression ten = Expression.Constant(10, typeof(int));// 创建条件表达式 x > 10BinaryExpression greaterThan = Expression.GreaterThan(param, ten);// 创建 if-true 表达式 x * 2BinaryExpression trueResult = Expression.Multiply(param, Expression.Constant(2, typeof(int)));// 创建 if-false 表达式 x - 1BinaryExpression falseResult = Expression.Subtract(param, Expression.Constant(1, typeof(int)));// 创建条件表达式ConditionalExpression conditional = Expression.Condition(greaterThan, trueResult, falseResult);// 创建表达式树Expression<Func<int, int>> expressionTree = Expression.Lambda<Func<int, int>>(conditional, param);// 编译并执行表达式树Func<int, int> compiledFunc = expressionTree.Compile();Console.WriteLine(compiledFunc(15)); // 输出: 30Console.WriteLine(compiledFunc(5));  // 输出: 4}
}

示例6：自定义运算符重载

表达式树可以用于实现自定义运算符重载，适用于需要扩展现有类型的行为的场景。

假设我们有一个自定义类型 Vector，并希望为其添加加法运算符。

using System;
using System.Linq.Expressions;public struct Vector
{public double X { get; set; }public double Y { get; set; }public Vector(double x, double y){X = x;Y = y;}public static Vector operator +(Vector v1, Vector v2){return new Vector(v1.X + v2.X, v1.Y + v2.Y);}
}public class Program
{public static void Main(){// 创建两个 Vector 实例Vector v1 = new Vector(1, 2);Vector v2 = new Vector(3, 4);// 创建表达式树来表示 v1 + v2ParameterExpression paramV1 = Expression.Parameter(typeof(Vector), "v1");ParameterExpression paramV2 = Expression.Parameter(typeof(Vector), "v2");BinaryExpression add = Expression.Add(paramV1, paramV2);// 创建表达式树Expression<Func<Vector, Vector, Vector>> expressionTree = Expression.Lambda<Func<Vector, Vector, Vector>>(add, paramV1, paramV2);// 编译并执行表达式树Func<Vector, Vector, Vector> compiledFunc = expressionTree.Compile();Vector result = compiledFunc(v1, v2);Console.WriteLine($"({result.X}, {result.Y})"); // 输出: (4, 6)}
}

3. 高级实战场景

场景1：动态查询构造

using System;
using System.Linq.Expressions;public class Person
{public int Age { get; set; }public string Name { get; set; }
}public class Program
{public static IQueryable<Person> BuildDynamicQuery(IQueryable<Person> source, string propertyName, object value){var param = Expression.Parameter(typeof(Person), "p");var property = Expression.Property(param, propertyName);var constant = Expression.Constant(value);var body = Expression.Equal(property, constant);var lambda = Expression.Lambda<Func<Person, bool>>(body, param);return source.Where(lambda);}public static void Main(){List<Person> people = new List<Person>{new Person { Name = "Alice", Age = 30 },new Person { Name = "Bob", Age = 25 },new Person { Name = "Charlie", Age = 35 },new Person { Name = "David", Age = 25 }};// 通过 BuildDynamicQuery 方法 可以动态筛选 特定属性等于特定值的数据var query = BuildDynamicQuery(people.AsQueryable(), "Age", 25);Console.WriteLine(string.Join(",",query.Select(x=>x.Name)));// 输出：Bob,David}
}

如果是在ORM中，则会通过如下形式调用：

// 使用示例
var query = BuildDynamicQuery(dbContext.Persons, "Age", 25);

场景2：高性能对象映射

using System;
using System.Collections.Concurrent;
using System.Linq.Expressions;
using System.Reflection;public static class Mapper<TSource, TTarget>
{private static readonly ConcurrentDictionary<(Type, Type), Func<TSource, TTarget>> _cache = new ConcurrentDictionary<(Type, Type), Func<TSource, TTarget>>();public static Func<TSource, TTarget> CreateMapper(){var cacheKey = (typeof(TSource), typeof(TTarget));return _cache.GetOrAdd(cacheKey, key =>{var sourceParam = Expression.Parameter(typeof(TSource), "source");var bindings = new List<MemberBinding>();foreach (var targetProp in typeof(TTarget).GetProperties(BindingFlags.Public | BindingFlags.Instance)){var sourceProp = typeof(TSource).GetProperty(targetProp.Name, BindingFlags.Public | BindingFlags.Instance);if (sourceProp == null || !sourceProp.CanRead || !targetProp.CanWrite)continue;// 检查属性类型是否匹配if (sourceProp.PropertyType != targetProp.PropertyType)continue;var propAccess = Expression.Property(sourceParam, sourceProp);bindings.Add(Expression.Bind(targetProp, propAccess));}var body = Expression.MemberInit(Expression.New(typeof(TTarget)),bindings);var lambda = Expression.Lambda<Func<TSource, TTarget>>(body, sourceParam);return lambda.Compile();});}
}// 示例类定义
public class Person
{public int Id { get; set; }public string Name { get; set; }public DateTime BirthDate { get; set; }
}public class PersonDto
{public int Id { get; set; }public string Name { get; set; }public DateTime BirthDate { get; set; }
}public class Program
{public static void Main(string[] args){var person = new Person{Id = 1,Name = "John Doe",BirthDate = new DateTime(1990, 1, 1)};var mapper = Mapper<Person, PersonDto>.CreateMapper();var dto = mapper(person);Console.WriteLine($"Id: {dto.Id}, Name: {dto.Name}, BirthDate: {dto.BirthDate}");}
}

四、高级技巧与优化

1. 表达式树缓存策略

private static ConcurrentDictionary<string, Delegate> _cache = new ConcurrentDictionary<string, Delegate>();public Func<TInput, TResult> GetOrCreateCompiler<TInput, TResult>(Expression<Func<TInput, TResult>> expr)
{string key = expr.ToString();return (Func<TInput, TResult>)_cache.GetOrAdd(key, _ => {return expr.Compile();});
}

2. 动态修改表达式树

public class Program
{public static void Main(string[] args){Expression<Func<int, int>> original = x => x * 2;var modifier = new ExpressionModifier();var modifiedExpr = (Expression<Func<int, int>>)modifier.Visit(original);Console.WriteLine(modifiedExpr);    //输出：x => (x + 2)var func = modifiedExpr.Compile();Console.WriteLine(func(1)); // 输出：3}
}class ExpressionModifier : ExpressionVisitor
{protected override Expression VisitBinary(BinaryExpression node){if (node.NodeType == ExpressionType.Multiply){return Expression.Add(node.Left, node.Right);}return base.VisitBinary(node);}
}

五、性能关键点

1. 编译性能对比

操作	耗时（μs）
直接调用	0.01
委托调用	0.03
首次编译表达式树	100-500
缓存后表达式树调用	0.05

2. 优化建议

• 预编译高频表达式：启动时编译常用表达式
• 避免重复编译：使用字典缓存编译结果，避免重复编译高频使用的表达式树。
• 减少闭包捕获：优先使用静态方法
• 使用Expression.Compile(preferInterpretation: true)：.NET Core 3.0+支持解释模式
• 避免过度动态化：静态代码在可预测场景下更高效。

六、使用须知

1. 注意事项

1）不可变性

修改需重新生成树结构

2）平台限制

• 平台兼容性：确保目标环境支持 System.Linq.Expressions。
• AOT编译环境（如iOS）：部分动态编译功能受限
• 部分表达式节点：在Entity Framework等Provider中不支持

3）安全风险

// 危险：允许用户输入表达式
var expr = "x => x.Name.Contains(\"" + userInput + "\")";
// 可能引发注入攻击，应使用白名单验证

4）调试复杂性

动态生成的树结构难以直接调试，需借助可视化工具。

2. 表达式树的优缺点

1）优点

• 动态性：允许在运行时动态生成和修改代码逻辑。
• 灵活性：适用于延迟执行和针对不同数据源的优化查询。
• 可分析性：表达式树可以被分析和转换，便于实现复杂的逻辑。
• 性能优化：通过编译表达式树生成的代码，可以获得接近直接编译代码的性能。
• 代码复用：表达式树可以复用现有的逻辑，减少重复代码的编写。

2）缺点

• 性能开销：表达式树的构建和编译需要额外的性能开销。
• 复杂性：表达式树的代码相对复杂，学习曲线较陡。

---

结语

回到目录页：C#/.NET 知识汇总
希望以上内容可以帮助到大家，如文中有不对之处，还请批评指正。

---

参考资料：
MSDN文档 表达式树
DLR (Dynamic Language Runtime)
c#:表达式树概念及应用场景(Expression)
c#:深入理解表达式树