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查询都有三个阶段：

var found = false;
foreach(var item in secondQuery.AsEnumerable())
{
    if (item == "23")
    {
        found = true;
        break;
    }
}

提供程序可以处理枚举数，以便它一次将一个取出数据元素。如果在第三次迭代中找到该值，则可能实际上只从数据库返回了三项。另一方面，使用.ToList()扩展方法时，将立即获取所有数据以填充列表。

{
   "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。

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'

请注意，每个节点都是二进制的。让我们开始解析！

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; }
}

然后，我添加了一些其他方法来简化生成随机实例的过程。您可以自己在代码中看到这些内容。

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”。rules语句获取一个节点，该节点是相关规则的列表。我们一直在跟踪表达式的左侧和右侧。该Binder签名是一个二进制表达式的简写，并定义如下：

private delegate Expression Binder(Expression left, Expression right);

binder变量仅设置顶级表达式：Expression.And或Expression.Or。两者都采用左右表达式来求值。

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）和字段名称创建它。

private readonly MethodInfo MethodContains = typeof(Enumerable).GetMethods(
  BindingFlags.Static | BindingFlags.Public)
  .Single(m => m.Name == nameof(Enumerable.Contains)
      && m.GetParameters().Length == 2);

它获取了Enumerable上的方法，该方法有两个参数：要枚举的值和要检查的值。接下来的逻辑如下所示：

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>。最后，我们构建调用，并传递它：

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将被分配为解析新条件的结果。我碰巧知道这是一个OR条件。现在，我们的binder设置为Expression.And，以便当函数返回时，bind调用留给我们的是：

Transactions.Where(t => (new List<string> { "Clothing" }).Contains(t.Category) && <something>);

让我们看一下“something”。

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);

该值被解构为字符串或十进制（以后的规则将使用十进制格式）。然后将值转换为常数，然后创建比较。注意它是传递给属性的。变量right现在看起来像这样：

Transactions.Where(t => t.TransactionType == "income");

在此嵌套循环中，left仍为空。解析器评估下一条规则，即付款方式。该bind函数将其转换为以下“or”语句：

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)
)

看起来不错…但是我们还没有完成！

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 transactions （加权后包括应该匹配的几笔交易）。然后，我应用过滤器并迭代结果，以便可以手动测试是否满足条件。

var predicate = jsonExpressionParser
                .ParsePredicateOf<Transaction>(jsonDocument);
var transactionList = Transaction.GetList(1000);
var filteredTransactions = transactionList.Where(predicate).ToList();
filteredTransactions.ForEach(Console.WriteLine);

如您所见，结果全部签出（我平均每次运行约70次“匹配”。）

public Func<T, bool> ParsePredicateOf<T>(JsonDocument doc)
{
    var query = ParseExpressionOf<T>(doc);
    return query.Compile();
}

该ExpressionGenerator程序使用编译后的查询。DatabaseTest使用原始λ表达式。它将其应用于本地SQLite数据库，以演示EF Core如何解析该表达式。在将1000个transactions创建并插入数据库后，代码将检索count：

var count = await context.DbTransactions.CountAsync();
Console.WriteLine($"Verified insert count: {count}.");

这将导致以下SQL：

SELECT COUNT(*)
FROM "DbTransactions" AS "d"

如果您想知道为什么有两个上下文，那是由于日志。第一个上下文插入1000条记录，如果打开了日志记录，则在将插入内容写入控制台时它将运行非常慢。第二个上下文打开日志记录，因此您可以查看评估后的语句。

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"

该示例应用程序还将打印所选实体之一以进行抽查。