Заменить параметр в выражении константой - PullRequest
Новая
       18

Заменить параметр в выражении константой

2 голосов
/ 28 мая 2019

У меня есть выражение типа Expression<Func<TElement, TElement, bool>> и константа типа TElement.Мне нужно выражение типа Expression<Func<TElement, bool>> с одним из параметров, замененных константой.Другими словами, мне нужно тело для следующего метода: 

public static Expression<Func<TElement, bool>> ReplaceParameter<TElement>
(
    Expression<Func<TElement, TElement, bool>> inputExpression,
    TElement element
)
{
    ...
}

Если я позвоню ReplaceParameter((i1, i2) => i1 > i2, 5), я ожидаю, что результат будет i => i > 5.

Я думал, этоможет быть в состоянии рекурсивно деконструировать, а затем реконструировать входное выражение и заменить все вхождения второго параметра константным выражением.Поскольку существует так много различных выражений, я не уверен, как это сделать.

Ответы [ 3 ]

4 голосов
/ 28 мая 2019

ExpressionVisitor ваш друг: 

static void Main()
{
    Expression<Func<int, int, bool>> before = (x, y) => x * 2 == y + 1;
    var after = ReplaceParameter(before, 3);
    Console.WriteLine(after);
}
public static Expression<Func<TElement, bool>> ReplaceParameter<TElement>
(
    Expression<Func<TElement, TElement, bool>> inputExpression,
    TElement element
)
{
    var replacer = new Replacer(inputExpression.Parameters[0],
        Expression.Constant(element, typeof(TElement)));
    var body = replacer.Visit(inputExpression.Body);
    return Expression.Lambda<Func<TElement, bool>>(body,
        inputExpression.Parameters[1]);
}
class Replacer : ExpressionVisitor
{
    private readonly Expression _from, _to;
    public Replacer(Expression from, Expression to)
    {
        _from = from;
        _to = to;
    }
    public override Expression Visit(Expression node)
        => node == _from ? _to : base.Visit(node);
}

Обратите внимание, что это не приводит к автоматическому свертыванию чистых константных выражений, т. Е. Показанный код приводит к: 

y => ((3 * 2) == (y + 1))

Вы могли бы однако, если хотите, попробуйте поискать BinaryExpression, который имеет только ConstantExpression в качестве входных данных, и оцените узел напрямую, снова внутри Replacer.

3 голосов
/ 28 мая 2019

Вы должны использовать ExpressionVisitor, который поможет вам посетить выражение и заменить часть выражения. 

public class ReplaceParameterVisitor : ExpressionVisitor
{
    public static Expression<Func<TElement, bool>> ReplaceParameter<TElement>(
        Expression<Func<TElement, TElement, bool>> inputExpression, 
        TElement element)
    {

        Expression body = inputExpression.Body;
        ReplaceParameterVisitor visitor = 
            new ReplaceParameterVisitor(inputExpression.Parameters[1], 
                                        Expression.Constant(element, typeof(TElement)));
        Expression newBody = visitor.Visit(body);

        Expression<Func<TElement, bool>> newExpression = 
            Expression.Lambda<Func<TElement, Boolean>>(
                newBody, 
                new ParameterExpression[] { inputExpression.Parameters[0] });
        return newExpression;
    }

    private ReplaceParameterVisitor(
        ParameterExpression param, 
        ConstantExpression constant)
    {
        this._param = param;
        this._constant = constant;
    }

    private readonly ParameterExpression _param;
    private readonly ConstantExpression _constant;


    protected override Expression VisitParameter(ParameterExpression node)
    {
        if (node == this._param)
        {
            return this._constant;
        }
        else
        {
            return base.VisitParameter(node);
        }
    }
}

Тогда 

Expression<Func<Int32, Int32, Boolean>> f = (i1, i2) => i1 > i2;
Expression<Func<Int32, Boolean>> f2 = ReplaceParameterVisitor.ReplaceParameter(f, 5);
Boolean b = f2.Compile()(4);
0 голосов
/ 28 мая 2019

Вместо использования ExpressionVisitor вы можете создать фабрику Func, например: 

public static Expression<Func<TElement, bool>> ReplaceParameter<TElement>
(
    Expression<Func<TElement, TElement, bool>> inputExpression,
    TElement element
)
{
    var inner = Expression.Lambda<Func<TElement, bool>>
    (
        inputExpression.Body,
        inputExpression.Parameters[1]
    );
    var outer = Expression.Lambda<Func<TElement, Expression<Func<TElement, bool>>>>
    (
        inner,
        inputExpression.Parameters[0]
    );
    var factory = outer.Compile();
    return factory(element);
}

Чтобы сделать ее еще более полезной, вы можете сохранить factory и вызывать ее каждый раз, когда захотитечтобы заменить параметр: 

public static Func<TElement, Expression<Func<TElement, bool>>> CreateFactory<TElement>
(
    Expression<Func<TElement, TElement, bool>> inputExpression
)
{
    var inner = Expression.Lambda<Func<TElement, bool>>
    (
        inputExpression.Body,
        inputExpression.Parameters[1]
    );
    var outer = Expression.Lambda<Func<TElement, Expression<Func<TElement, bool>>>>
    (
        inner,
        inputExpression.Parameters[0]
    );
    return outer.Compile();
}

public static void Test()
{
    var factory = CreateFactory<int>((i1, i2) => i1 > i2);
    var greater5 = factory(5);
    var greater2 = factory(2);
}

Что на самом деле здесь происходит?
Когда inputExpression равно (i1, i2) => i1 > i2, тогда inner будет i1 => i1 > i2, а outer / factory будетi2 => i1 => i1 > i2.

...