将表达式引用解析为实际值

Question

我想在表达式中记录实际值，而不是对表达式中使用的属性/字段/常量的引用。我在这里有一个小提琴：https://dotnetfiddle.net/7SNxAq 其代码（为后代）是：

using System;
using System.Linq.Expressions;

public class Program
{
    public static void Main()
    {
        var input = new Foo
        {
            Shape = "Sphere",
            SizeType = SizeType.Small
        };

        Expression<Func<Foo, bool>> expression = f =>
            f.Hue == Constants.Hues.Red &&
            f.Shape == input.Shape &&
            f.Size == input.SizeType.ToString() &&
            !f.IsDeleted;

        Console.WriteLine(expression);
    }
}

internal class Foo
{
    public string Hue { get; set; }
    public string Shape { get; set; }
    public bool IsDeleted { get; set; }
    public string Size { get; set; }
    public SizeType SizeType { get; set; }
}

internal enum SizeType
{
    Small, Medium, Large
}

internal class Constants
{
    public class Hues
    {
        public static string Red = "#f00";
    }
}

Console.WriteLine(expression) 的结果是：

f => ((((f.Hue == Hues.Red) AndAlso (f.Shape == value(Program+<>c__DisplayClass0_0).input.Shape)) AndAlso (f.Size == value(Program+<>c__DisplayClass0_0).input.SizeType.ToString())) AndAlso Not(f.IsDeleted))

但我希望看到这样的东西

f => ((((f.Hue == Hues.Red) AndAlso (f.Shape == "Sphere")) AndAlso (f.Size == "Small")) AndAlso Not(f.IsDeleted))

这可以做到吗，还是我错过了表达的重点？

Answer 1

所以我们需要摆脱闭包。为此，需要重写表达式树（请注意，表达式访问者中不会考虑所有情况）：

public static void Main()
{
    // ...

    var updated = (Expression<Func<Foo, bool>>)
        new ClosureResolver().Visit(expression);

    // Outputs:
    // f => ((((f.Hue == Hues.Red) AndAlso (f.Shape == "Sphere")) AndAlso (f.Size == "Small")) AndAlso Not(f.IsDeleted))
    Console.WriteLine(updated);
}


public class ClosureResolver : ExpressionVisitor
{
    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        if (node.Arguments.Count == 0)
        {
            var objExpr = Visit(node.Object);

            if (objExpr is ConstantExpression objConstExpr)
            {
                var res = node.Method.Invoke(objConstExpr.Value, new object[0]);
                return Expression.Constant(res);
            }
        }

        return base.VisitMethodCall(node);
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        var childExpr = Visit(node.Expression);

        if (childExpr is ConstantExpression constExpr)
        {
            if (node.Member is FieldInfo field)
            {
                var constVal = field.GetValue(constExpr.Value);
                return Expression.Constant(constVal);
            }
            else if (node.Member is PropertyInfo prop)
            {
                var constVal = prop.GetValue(constExpr.Value);
                return Expression.Constant(constVal);
            }
        }

        return base.VisitMember(node);
    }
}

一旦表达式树被重写 - 它将不再有闭包，因此在 input 已更改的情况下它的行为可能会有所不同：

static void ClosureDemo()
{
    var input = new Foo { Shape = "Sphere" };

    Expression<Func<Foo, bool>> expr = f =>
        f.Shape == input.Shape;

    var updated = (Expression<Func<Foo, bool>>) 
        new ClosureResolver().Visit(expr);

    var fn = expr.Compile();
    var updatedFn = updated.Compile();


    Console.WriteLine(fn(input)); // True
    Console.WriteLine(updatedFn(input)); // True

    input.Shape = "Cube";

    Console.WriteLine(fn(input)); // True
    Console.WriteLine(updatedFn(input)); // False
}