如何将 C# 表达式转换为自定义嵌套类结构？

Question

我已经自定义了查询类，它将用于在 lambda 表达式的帮助下构建查询，如下所示

var query = new Query("Person").Where<Person>(p =>
(p.Name == "Maulik" && (p.Id == 2 || p.Age == 30)) || (p.Id == 2 && p.Name == "Maulik"));

通过基于此参考link 类实现ExpressionVisitor，我能够将翻译后的查询转换为字符串格式，如下所示

(((Name EqualTo "Maulik") AND ((Id EqualTo 2) OR (Age EqualTo 30))) OR ((Id EqualTo 2) AND (Name EqualTo 'Maulik')))

但是，我想将上面的表达式翻译成我的自定义嵌套类

public class Expression
{
    public List<Expression> Filters { get; } // Nested expression
    public Operator Operator { get; set; } //e.g AND/OR
    public List<Condition> Conditions { get; } // One Expression can have many conditions
}

public class Condition
{
    public string Name { get; set; }
    public Operator Operator { get; set; } //e.g <,> ==, != etc
    public object Value { get; set; }
}

表达式表示：(A > 5 && A < 10)，条件表示最内部的条件A > 5

我的意思是嵌套，一个表达式可以有子表达式，也可以有子子表达式等等，每个表达式可以有多个条件。

转换成这种结构的原因是为了处理各种 SQL/NoSQL 提供者，从这种类结构中将为所有不同的提供者创建单独的查询，因此不能完全改变这种类结构。

创建这个类结构是为了维护基于查询的AND和OR条件的括号顺序，因此相同级别的条件可以用单个表达式来俱乐部。

我正在寻找任何可以帮助将表达式转换为嵌套类结构的通用映射。

将表达式转换为自定义嵌套类结构的最佳方法是什么？如果有任何可用的实施示例，请分享。我还没有找到任何相关的例子。

Answer 1

我认为您的类没有正确反映表达式的结构。让我用EBNF 写下此类表达式的可能语法（不要求完整性）：

Expression = Term { ("AND" | "OR") Term }.
Term = "(" Expression ")" | Comparison.
Comparison = name ("=" | "!=" | "<" ...) Value.
Value = stringConstant | number.

我们看到的一件重要的事情是，Term 可以是 Expression 或 Comparison。这意味着我们必须能够将一个或另一个插入AND 或OR 的两侧。示例：Name = "Maulik" AND (Id = 2 OR Id = 3)。在AND 的左侧我们有一个比较，在右侧是一个表达式。

因此，我们必须使这两个事物的赋值兼容，例如，通过从同一个基类派生它们。

public abstract class Term
{
}

public Expression : Term
{
    public Term FirstTerm { get; set; }
    public List<(BooleanOperator operator, Term term)> SucceedingTerms { get; } = new();
}

public Comparison : Term
{
    public string Name { get; set; }
    public ComparisonOperator Operator { get; set; }
    public object Value { get; set; }
}

另一个重要的事实是语法是递归的。即，一个表达式包含术语，而术语可以包含另一个表达式。这对于能够表示具有多级嵌套的括号表达式是必要的。

语法的这种递归性质有两个后果：

1. 类结构必须允许递归结构。这是因为Expression 类有一个包含Terms 的列表，而这些列表又可以是Expressions。
2. 后面显示的解析器必须是递归的。它包含间接递归调用（ParseExpression 调用 ParseTerm 和 ParseTerm 调用 ParseExpression）。

请注意，我使用ValueTulpes 作为由运算符和术语组成的列表元素。

---

现在，到转换本身。你需要一个编译器。要么

• 手动构建您自己的自定义编译器。 Niklaus Wirth's book Compiler Construction (2 PDFs) 是对编译器构造理论和技术的介绍。它让您大致了解编译器是什么以及它的作用。
• 使用工具或库生成编译器：例如ANTLR。

---

由于语法简单，你可以自己编写编译器。

将任务分为词法分析（由词法分析器完成）和语法分析（由解析器完成）。除了分析语法外，解析器还创建所需的数据结构作为输出。词法分析器只返回一个符号流。例如

enum Symbol { EndOfInput, LeftPar, RightPar, AndOperator, OrOperator, Identifier, Number,
              StringLiteral, ...}

private string _input;
private int _currentPos;
private string _identifier;
private string _stringValue;
private decimal _number;
private Symbol _symbol;

/// Does the lexical analysis.
private void GetSymbol()
{
    // Get next `_symbol` (and associated variables) from `_input` at `_currentPos` and
    // update `_currentPos`.
}

使用此基本基础架构，您可以创建解析器。解析器由密切反映语法结构的方法组成（如上面的 EBNF 中给出的）。

// Expression = Term { ("AND" | "OR") Term }.
void Expression ParseExpression()
{
    var expression = new Expression();
    expression.FirstTerm = ParseTerm();
    while (_symbol == Symbol.AndOperator || _symbol == Symbol.OrOperator) {
        var op = _symbol == Symbol.AndOperator
            ? BooleanOperator.And
            : BooleanOperator.Or;
        GetSymbol();
        term = ParseTerm();
        expression.SucceedingTerms.Add((op, term));
    }
    return expression;
}

// Term = "(" Expression ")" | Comparison.
void Term ParseTerm()
{
    Term term = null;
    if (Symbol == Symbol.LeftPar) {
        GetSymbol();
        term = ParseExpression();
        if (Symbol == Symbol.RightPar) {
            GetSymbol();
        } else {
            Error("\")\" expected.");
        }
    } else {
        term = ParseComparison();
    }
    return term;
}

这并不完整，但你明白了。由于此解析器的结构取决于语法生成 (EBNF)，因此在确定确切语法之前不要从它开始。

注意在下一个符号给出的语法中始终具有可确定的路径。首先，我错了。我的任期是由Term = "(" Expression | Comparison ")" | Comparison. 给出的。这里的问题是表达式以术语开头，而术语可以是比较。比较从名称开始。因此，Expression 和Comparison 都可以以名称开头。当解析 Expression | Comparison 并且下一个符号是名称时，我们无法决定是否必须解析表达式或比较。

更新后的语法是Term = "(" Expression ")" | Comparison.。现在，我们知道如果下一个符号是左括号，我们必须解析表达式，否则解析比较。