Question

MSDN文档有一个很好的example of parsing an expression tree：

// Create an expression tree.
Expression<Func<int, bool>> exprTree = num => num < 5;

// Decompose the expression tree.
ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];
BinaryExpression operation = (BinaryExpression)exprTree.Body;
ParameterExpression left = (ParameterExpression)operation.Left;
ConstantExpression right = (ConstantExpression)operation.Right;

Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
              param.Name, left.Name, operation.NodeType, right.Value);

但是我没有看到如何解析这样的事情的例子：

MyDomainObject foo;
Expression<Func<bool>> exprTree = () => ((foo.Scale < 5 || foo.Scale > 20) && foo.Scale <> -100) || foo.IsExempt;

我的目标是找到或构建一个实用程序，它可以（1）处理任何级别的括号嵌套，以及（2）生成一个包含等效SQL“where”子句的字符串作为解析表达式树的产品。任何人都有一个代码段，可以帮助或知道解决此问题的nuget包吗？

对于上面的嵌套表达式，假设一个名为“MyDomainObject”的数据库表，正确的SQL where子句字符串输出将为：

(( Scale < 5 or Scale > 20) and Scale != -100) or IsExempt = true

显然，在没有二元运算符的情况下，我的想象解析器会假设只是断言'true'，就像“IsExempt = true”

一样

Answer 1

所以听起来你的问题不是“解析”（因为表达式已被解析为C＃表达式），你想要的是遍历表达式树并输出一个SQL表达式。

如果可以避免，我建议您不要为自己编写代码。对于大多数人来说，LINQ to Entities可能是更好的方式as it basically does this for you，同时完全隐藏SQL。

如果您有其他要求（例如较低的.NET版本，或者您必须拥有SQL字符串），并且愿意自己编写代码，则可以使用递归函数执行此操作。此函数可以使用表达式并将SQL子句作为字符串返回。

有些事情（没有经过测试，将其视为伪代码）：

public string WriteClause(Expression exp)
{
    if (exp is ParameterExpression)
    {
        return (exp as ParameterExpression).Name;
    }
    else if (exp is BinaryExpression)
    {
        var binaryExpression = exp as BinaryExpression;

        return "(" +
               WriteClause(binaryExpression.Left) + " "
               GetSqlOperator(binaryExpression.Method) + " "
               WriteClause(binaryExpression.Right) +
               ")";
    }
    else if...

    ...etc...

}

public string GetSqlOperator(MethodInfo method)
{
    switch (method.Name)
    {
        case "Add":
            return "+";
        case "Or":
            return "or";

        ...etc...
    }
}

递归意味着这种方法应该处理任何级别的括号深度。这有点幼稚，所以它会提供比你需要的更多的括号。

Answer 2

这是一个至少将输入转换为有效SQL表达式的实现。您需要自己实现更多表达式类型，但它可以让您了解它的工作原理。

这个答案恰好与Kazetsukai的答案非常相似，但它使用Expression.NodeType来查找运算符，因为表达式树中没有MethodInfos。

另请注意，这会产生比实际需要更多的括号。为了减少括号的数量，需要进一步分析表达式，考虑SQL中的运算符优先级。

public static string GetSqlExpression(Expression expression)
{
    if (expression is BinaryExpression)
    {
        return string.Format("({0} {1} {2})",
            GetSqlExpression(((BinaryExpression)expression).Left),
            GetBinaryOperator((BinaryExpression)expression),
            GetSqlExpression(((BinaryExpression)expression).Right));
    }

    if (expression is MemberExpression)
    {
        MemberExpression member = (MemberExpression)expression;

        // it is somewhat naive to make a bool member into "Member = TRUE"
        // since the expression "Member == true" will turn into "(Member = TRUE) = TRUE"
        if (member.Type == typeof(bool))
        {
            return string.Format("([{0}] = TRUE)", member.Member.Name);
        }

        return string.Format("[{0}]", member.Member.Name);
    }

    if (expression is ConstantExpression)
    {
        ConstantExpression constant = (ConstantExpression)expression;

        // create a proper SQL representation for each type
        if (constant.Type == typeof(int) ||
            constant.Type == typeof(string))
        {
            return constant.Value.ToString();
        }

        if (constant.Type == typeof(bool))
        {
            return (bool)constant.Value ? "TRUE" : "FALSE";
        }

        throw new ArgumentException();
    }

    throw new ArgumentException();
}

public static string GetBinaryOperator(BinaryExpression expression)
{
    switch (expression.NodeType)
    {
        case ExpressionType.Equal:
            return "=";
        case ExpressionType.NotEqual:
            return "<>";
        case ExpressionType.OrElse:
            return "OR";
        case ExpressionType.AndAlso:
            return "AND";
        case ExpressionType.LessThan:
            return "<";
        case ExpressionType.GreaterThan:
            return ">";
        default:
            throw new ArgumentException();
    }
}

结果是：

(((([Scale] < 5) OR ([Scale] > 20)) AND ([Scale] <> -100)) OR ([IsExempt] = TRUE))

调用这样的方法：

string sqlExpression = GetSqlExpression(exprTree.Body);

我建议以更实用的方式构建表达式树。不应使用具体Func<bool>构建foo，而应使用Func<Foo, bool>。但是，无论如何它都会起作用。它看起来不对。

Expression<Func<Foo, bool>> exprTree =
    (foo) => ((foo.Scale < 5 || foo.Scale > 20) && foo.Scale != -100) || foo.IsExempt == true;

显然，当您可以使用LINQ to Entities时，通常不需要自己构建SQL文本。 LINQ to实体和表达式树都需要.NET 3.5，实际上你可以Translate LINQ to sql statement。

我不确定像IsExempt = TRUE这样的表达式是否适用于SQL Server。我认为它应该是IsExempt = 1，因为数据类型是bit。此外，Value == null或Value != null等表达式需要单独处理，因为您无法在SQL表达式中使用Value = NULL或Value <> NULL。必须是Value IS NULL或Value IS NOT NULL。

解析单语句布尔表达式树

2 个答案: