原文：bit.ly/3fwlKQJ
作者：Jeremy Likness
译者：精致码农-王亮
LINQ 是 Language Integrated Query（语言集成查询）的缩写，是我最喜欢的 .NET 和 C# 技术之一。使用 LINQ，开发者可以直接在强类型代码中编写查询。LINQ 提供了一种标准的语言和语法，使不同的数据源的查询编码方法一致。
一些基础
考虑如下这个 LINQ 查询（你可以把它粘贴到一个控制台应用程序中运行）。
using System;
using System.Linq;
public class Program
{
public static void Main()
{
var someNumbers = new int[]{4, 8, 15, 16, 23, 42};
var query =
from num in someNumbers
where num > 10
orderby num descending
select num.ToString();
Console.WriteLine(string.Join('-', query.ToArray()));
// 42-23-16-15
}
}
因为 someNumbers 是一个 IEnumerable<int>，该查询是被 LINQ to Objects 解析的。同样的查询语法可用于像 Entity Framework Core 这样的工具，生成针对关系型数据库运行的 T-SQL。LINQ 可以使用两种语法来编写：查询语法（如上所示）和（扩展）方法语法。这两种语法在语义上是相同的，你使用哪一种语法取决于你的偏好。上面同样的查询可以用方法语法写成这样：
var secondQuery = someNumbers.Where(n => n > 10)
.OrderByDescending(n => n)
.Select(n => n.ToString());
每个 LINQ 查询都有三个阶段：
- 设置一个数据源，称为提供者（provider），供查询时使用。例如，到目前为止的代码使用了内置的
LINQ to Objects提供者。你的 EF Core 项目使用的是 EF Core 提供者，它映射到你的数据库。 - 查询被定义并转变成一个表达式树(expression tree)，我将在稍后介绍。
- 查询被执行，数据被返回。
第 3 步很重要，因为 LINQ 使用了所谓的延迟执行(deferred execution)。在上面的例子中，secondQuery 定义了一个表达式树，但还没有返回任何数据。事实上，在你开始迭代数据之前，实际上什么都没有发生。这很重要，因为它允许提供者通过只提供所要求的数据。例如，假设你想用 secondQuery 找到一个特定的字符串，所以你做了这样的事情：
var found = false;
foreach(var item in secondQuery.AsEnumerable())
{
if (item == "23")
{
found = true;
break;
}
}
一个提供者通过枚举器(enumerator)访问，这样它就可以一次输入一个元素的数据。如果你在第三次迭代时得到了想要的值，可能实际上只有三条数据从数据库中返回。另一方面，当你使用 .ToList() 扩展方法时，所有的数据都会立即被取出并填充到列表中。
难题
我作为我们公司的 .NET 项目经理，我经常与客户交谈，了解他们的需求。最近，我与一位客户进行了讨论，他想在他们的网站上使用第三方控件来建立业务规则。更具体地说，业务规则是“谓词”（predicates，译注：也可以翻译成判断语句）或一组条件，可解析为 true 或 false。该工具可以用 JSON 或 SQL 格式生成规则。SQL 很香，可以持久化到给数据库，但他们的要求是将“谓词”应用于内存对象，作为服务器上的一个过滤器。他们正在考虑使用一种工具，将 SQL 翻译成表达式（其实就是动态生成 LINQ）。我建议使用 JSON 格式，因为它可以被解析成 LINQ 表达式，针对内存中的对象运行，或者很容易应用到 Entity Framework Core 集合，相对 SQL 数据库是更好的选择。
我只要处理工具产生的 JSON：
{
"condition": "and",
"rules": [
{
"label": "Category",
"field": "Category",
"operator": "in",
"type": "string",
"value": ["Clothing"]
},
{
"condition": "or",
"rules": [
{
"label": "TransactionType",
"field": "TransactionType",
"operator": "equal",
"type": "boolean",
"value": "income"
},
{
"label": "PaymentMode",
"field": "PaymentMode",
"operator": "equal",
"type": "string",
"value": "Cash"
}
]
},
{
"label": "Amount",
"field": "Amount",
"operator": "equal",
"type": "number",
"value": 10
}
]
}
结构很简单：有一个 AND 或 OR 条件，包含一组规则，要么是比较，要么是嵌套条件。我的目标有两个：学习更多关于 LINQ 表达式的知识，以便更好地了解 EF Core 和相关技术；提供一个简单的例子，说明如何在不依赖第三方工具的情况下使用 JSON。
动态表达式
我创建了一个简单的控制台应用程序来测试我的假设，即解析 JSON 信息直接生成 LINQ 查询。
https://github.com/JeremyLikness/ExpressionGenerator
译注：建议参照此 GitHub 源代码阅读本文，方便理解。
在本文的第一部分，将启动项目设置为 ExpressionGenerator。如果你从命令行运行它，请确保 rules.json 在你的当前目录中。
我将样本 JSON 嵌入为 rules.json。使用 System.Text.Json 来解析文件，就是这么简单：
var jsonStr = File.ReadAllText("rules.json");
var jsonDocument = JsonDocument.Parse(jsonStr);
然后我创建了一个 JsonExpressionParser 来解析 JSON 并创建一个表达式树。因为动态表达式是一个谓词，所以表达式树是由二元表达式 BinaryExpression 的实例构成的，这些实例计算一个左表达式和一个右表达式。这个计算可能是一个逻辑门（AND 或 OR），或一个比较（equal 或 greaterThan），或一个方法调用。对于 In 的情况，即我们想让属性 Category 出现在一个列表中，我使用 Contains。从概念上讲，引用的 JSON 看起来像这样：
/-----------AND-----------\
| |
/-AND-\ |
Category IN ['Clothing'] Amount eq 10.0 /-OR-\
TransactionType EQ 'income' PaymentMode EQ 'Cash'
注意，每个节点都是二元的。让我们开始解析吧！
引入 Transaction
注意，这不是 System.Transaction（这里的 Transaction 不是指事务，而是指交易）。这是示例项目中使用的一个自定义类。我没有在供应商的网站上花很多时间，所以我根据规则猜测实体可能的样子。我想出了这个：
public class Transaction
{
public int Id { get; set; }
public string Category { get; set; }
public string TransactionType { get; set; }
public string PaymentMode { get; set; }
public decimal Amount { get; set; }
}
我还添加了一些额外的方法，以使其易于生成随机实例。你可以自己在 GitHub 代码中看到这些。
参数表达式
主要方法返回一个谓词(predicate)函数。下面是该方法开始部分的代码：
public Func<T, bool> ParsePredicateOf<T>(JsonDocument doc)
{
var itemExpression = Expression.Parameter(typeof(T));
var conditions = ParseTree<T>(doc.RootElement, itemExpression);
}
第一步是创建谓词参数。谓词可以传递给 Where 子句，如果我们自己写的话，它看起来就像这样：
var query = ListOfThings.Where(t => t.Id > 2);
t => 是一个参数，代表列表中一个条目的类型。因此，我们为该类型创建一个参数。然后我们递归地遍历 JSON 节点来建立树。
逻辑表达式
解析器的开头看起来像这样：
private Expression ParseTree<T>(
JsonElement condition,
ParameterExpression parm)
{
Expression left = null;
var gate = condition.GetProperty(nameof(condition)).GetString();
JsonElement rules = condition.GetProperty(nameof(rules));
Binder binder = gate == And ? (Binder)Expression.And : Expression.Or;
Expression bind(Expression left, Expression right) =>
left == null ? right : binder(left, right);
gate 变量是条件，即“and”或“or”。规则语句得到一个节点，是相关规则的列表。我们正在跟踪表达式的左边和右边。Binder 签名是二元表达式的简写，定义如下：
private delegate Expression Binder(Expression left, Expression right);
binder 变量简单地设置了顶层表达式：Expression.And 或 Expression.Or。两者都使用左边和右边表达式来计算。
bind 函数更有趣一点。当我们遍历树时，我们需要建立各种节点。如果我们还没有创建一个表达式（left 是 null），我们就从创建的第一个表达式开始。如果我们有一个现有的表达式，我们就用这个表达式来合并两边的内容。
现在，left 是 null，然后我们开始列举属于这个条件的规则：
foreach (var rule in rules.EnumerateArray())
属性表达式
第一条规则是一个相等规则，所以我现在跳过条件部分。大致情况是下面这样的：
string @operator = rule.GetProperty(nameof(@operator)).GetString();
string type = rule.GetProperty(nameof(type)).GetString();
string field = rule.GetProperty(nameof(field)).GetString();
JsonElement value = rule.GetProperty(nameof(value));
var property = Expression.Property(parm, field);
首先，我们得到运算符（in）、类型（string）、字段（Category）和值（一个以Clothing为唯一元素的数组）。注意对 Expression.Property 的调用。这个规则的 LINQ 看起来是这样的：
var filter = new List<string> { "Clothing" };
Transactions.Where(t => filter.Contains(t.Category));
该属性是 t.Category，所以我们根据父属性（t）和字段名来创建它。
常量和调用表达式
接下来，我们需要建立对 Contains 的调用。为了简化，我在这里创建了一个对该方法的引用：
private readonly MethodInfo MethodContains = typeof(Enumerable).GetMethods(
BindingFlags.Static | BindingFlags.Public)
.Single(m => m.Name == nameof(Enumerable.Contains)
&& m.GetParameters().Length == 2);
这就动态提取了 Enumerable 的 Contains 方法，该方法需要两个参数：要使用的集合和要检查的值。接下来的逻辑看起来像这样：
if (@operator == In)
{
var contains = MethodContains.MakeGenericMethod(typeof(string));
object val = value.EnumerateArray().Select(e => e.GetString())
.ToList();
var right = Expression.Call(
contains,
Expression.Constant(val),
property);
left = bind(left, right);
}
首先，我们使用 Enumerable.Contains 模板来创建一个 Enumerable<string>。接下来，我们获取值的列表，把它变成一个 List<string>。最后，建立我们的调用，需要传递：
- 要调用的方法（
contains） - 要检查的参数的值（带有
Clothing的列表，或者Expression.Constant(val)） - 要对其进行检查的属性（
t.Category）。
我们的表达式树已经相当深了，有参数、属性、调用和常量。记住，left 仍然是空的，所以对 bind 的调用只是将 left 设置为我们刚刚创建的调用表达式。到目前为止，看起来像这样：
Transactions.Where(t => (new List<string> { "Clothing" }).Contains(t.Category));
循环往复，下一个规则是一个嵌套条件。关键代码如下：
if (rule.TryGetProperty(nameof(condition), out JsonElement check))
{
var right = ParseTree<T>(rule, parm);
left = bind(left, right);
continue;
}
目前，left 被分配给 in 表达式。right 将被分配为解析新条件的结果。现在，我们的 binder 被设置为 Expression.And，所以当函数返回时，bind 的调用结果是这样的：
Transactions.Where(t => (new List<string> { "Clothing" }).Contains(t.Category) && <something>);
我们再来看看这里的“something”。
比较表达式
首先，递归调用确定了一个新的条件存在，这次是一个逻辑 OR。binder 被设置为 Expression.Or，规则开始运算。第一条规则是关于 TransactionType 的。它被设置为布尔值，但根据我的推断，它意味着用户在界面中可以选择一个值或切换到另一个值。因此，我把它实现为一个简单的字符串比较。下面是建立比较的代码：
object val = (type == StringStr || type == BooleanStr) ?
(object)value.GetString() : value.GetDecimal();
var toCompare = Expression.Constant(val);
var right = Expression.Equal(property, toCompare);
left = bind(left, right);
该值被解析为字符串或小数（后面的规则将使用小数格式）。然后，该值被转换成一个常数，然后创建比较。注意它是通过属性比较的。现在的变量看起来像这样：
Transactions.Where(t => t.TransactionType == "income");
在这个嵌套循环中，left 仍然是空的。解析器计算了下一条规则，即 PaymentMode。bind 函数把它变成了这个“或”语句：
Transactions.Where(t => t.TransactionType == "income" || t.PaymentMode == "Cash");
其余的应该是不言自明的。表达式的一个很好的特点是它们可以重载 ToString() 来展现输出。下面就是我们的表达式的样子（为了方便查看，我手动进行了格式化）：
(
(value(System.Collections.Generic.List`1[System.String]).Contains(Param_0.Category)
And (
(Param_0.TransactionType == "income")
Or
(Param_0.PaymentMode == "Cash"))
)
And
(Param_0.Amount == 10)
)
它看起来不错…但我们还没有完成！
Lambda 表达式和编译
接下来，我创建一个 lambda 表达式。这里定义了解析后的表达式的形状，它将是一个谓词（Func<T,bool>）。最后，返回编译后的委托：
var conditions = ParseTree<T>(doc.RootElement, itemExpression);
if (conditions.CanReduce)
{
conditions = conditions.ReduceAndCheck();
}
var query = Expression.Lambda<Func<T, bool>>(conditions, itemExpression);
return query.Compile();
为了测试，我生成了 1000 个 Transaction。然后我应用过滤器并迭代结果，这样我就可以手动测试条件是否满足：
var predicate = jsonExpressionParser
.ParsePredicateOf<Transaction>(jsonDocument);
var transactionList = Transaction.GetList(1000);
var filteredTransactions = transactionList.Where(predicate).ToList();
filteredTransactions.ForEach(Console.WriteLine);
正如你所看到的，结果出来了（我平均每次运行约 70 次“命中”）。
从内存到数据库
生成的委托并不只是用于对象。我们也可以用它来访问数据库。
在这篇文章的其余部分，将启动项目设置为 DatabaseTest。如果你从命令行运行它，要确保 databaseRules.json 在你的当前目录中。
首先，我重构了代码。还记得表达式是如何要求一个数据源的吗？在前面的例子中，我们编译了表达式，最后得到了一个对对象工作的委托。为了使用不同的数据源，我们需要在编译表达式之前将其传递给它。这允许数据源对其进行编译。如果我们传递已编译的数据源，数据库提供者将被迫从数据库中获取所有行，然后解析返回的列表。我们希望数据库来做这些工作。我把大部分代码移到一个名为 ParseExpressionOf<T> 的方法中，该方法返回 lambda。我把原来的方法重构成这样：
public Func<T, bool> ParsePredicateOf<T>(JsonDocument doc)
{
var query = ParseExpressionOf<T>(doc);
return query.Compile();
}
ExpressionGenerator 程序使用编译后的查询，DatabaseTest 使用原始的 lambda 表达式。它将其应用于一个本地的 SQLite 数据库，以演示 EF Core 是如何解析表达式的。在数据库中创建并插入 1000 条 Transaction 后，通过下面代码查询总数：
var count = await context.DbTransactions.CountAsync();
Console.WriteLine(quot;Verified insert count: {count}.");
这会生成以下 SQL 语句：
SELECT COUNT(*)
FROM "DbTransactions" AS "d"
谓词被解析（这次是来自 databaseRules.json 中的一组新规则）并传递给 Entity Framework Core 提供者。
var parser = new JsonExpressionParser();
var predicate = parser.ParseExpressionOf<Transaction>(
JsonDocument.Parse(
await File.ReadAllTextAsync("databaseRules.json")));
var query = context.DbTransactions.Where(predicate)
.OrderBy(t => t.Id);
var results = await query.ToListAsync();
打开 Entity Framework Core 日志记录开关，我们能够检索到生成的 SQL，看到数据条目是如何被一次性获取和在数据库引擎中如何计算的。注意 PaymentMode 被检查为“Credit”而不是“Cash”。
SELECT "d"."Id", "d"."Amount", "d"."Category", "d"."PaymentMode", "d"."TransactionType"
FROM "DbTransactions" AS "d"
WHERE ("d"."Category" IN ('Clothing') &
((("d"."TransactionType" = 'income') AND "d"."TransactionType" IS NOT NULL) |
(("d"."PaymentMode" = 'Credit') AND "d"."PaymentMode" IS NOT NULL))) &
("d"."Amount" = '10.0')
ORDER BY "d"."Id"
该示例应用程序还打印了一个实体，以进行抽查。
总结
LINQ 表达式是一个非常强大的工具，可以过滤和转换数据。我希望这个例子有助于理解表达式树是如何构建的。当然，解析表达式树感觉有点像魔术。Entity Framework Core 是如何在表达式树上行走以产生有意义的 SQL？我正在自己探索这个问题，并得到了 ExpressionVisitor 类的帮助。我将陆续发表更多关于这个问题的文章。