Cómo construir una LambdaExpression a partir de una LambdaExpression existente sin compilar

Question

Quiero combinar dos LambdaExpressions sin compilarlos.

Esto es lo que parece si hago compilarlas:

public Expression<Func<TContainer,bool>> CreatePredicate<TContainer,TMember>(
     Expression<Func<TContainer,TMember>> getMemberExpression, 
     Expression<Func<TMember,bool>> memberPredicateExpression) 
    { 
     return x => memberPredicateExpression.Compile()(getMemberExpression.Compile()(x)); 
    } 

Eso no es obviamente la manera más rápida para obtener la expresión de destino desde los argumentos proporcionados. Además, lo hace incompatible con proveedores de consultas como LINQ to SQL que no son compatibles con las llamadas al método C#.

Según lo que he leído, parece que el mejor enfoque es construir una clase ExpressionVisitor. Sin embargo, parece que podría ser una tarea bastante común. ¿Alguien sabe de una base de código fuente abierta existente que proporciona este tipo de funcionalidad? Si no, ¿cuál es la mejor manera de acercarse al ExpressionVisitor para que sea lo más genérico posible?

Answer 1

No sé si es la mejor manera, pero se puede hacer algo así:

public Expression<Func<TContainer,bool>> CreatePredicate<TContainer,TMember>(
    Expression<Func<TContainer,TMember>> getMemberExpression, 
    Expression<Func<TMember,bool>> memberPredicateExpression) 
{ 
    ParameterExpression x = Expression.Parameter(typeof(TContainer), "x"); 
    return Expression.Lambda<Func<TContainer, bool>>(
     Expression.Invoke(
      memberPredicateExpression, 
      Expression.Invoke(
       getMemberExpression, 
       x)), 
     x); 
} 

Uso:

var expr = CreatePredicate(
    (Foo f) => f.Bar, 
    bar => bar % 2 == 0); 

Resultado:

x => Invoke(bar => ((bar % 2) == 0), Invoke(f => f.Bar, x)) 

supongo sería mejor obtener algo como x => x.Bar % 2 == 0, pero probablemente sería significativamente más difícil ...

---

EDIT: en realidad no era tan duro con un visitante de la expresión:

public Expression<Func<TContainer,bool>> CreatePredicate<TContainer,TMember>(
    Expression<Func<TContainer,TMember>> getMemberExpression, 
    Expression<Func<TMember,bool>> memberPredicateExpression) 
{ 
    return CombineExpressionVisitor.Combine(
     getMemberExpression, 
     memberPredicateExpression); 
} 

class CombineExpressionVisitor : ExpressionVisitor 
{ 
    private readonly ParameterExpression _parameterToReplace; 
    private readonly Expression _replacementExpression; 
    private CombineExpressionVisitor(ParameterExpression parameterToReplace, Expression replacementExpression) 
    { 
     _parameterToReplace = parameterToReplace; 
     _replacementExpression = replacementExpression; 
    } 

    public static Expression<Func<TSource, TResult>> Combine<TSource, TMember, TResult>(
     Expression<Func<TSource, TMember>> memberSelector, 
     Expression<Func<TMember, TResult>> resultSelector) 
    { 
     var visitor = new CombineExpressionVisitor(
      resultSelector.Parameters[0], 
      memberSelector.Body); 
     return Expression.Lambda<Func<TSource, TResult>>(
      visitor.Visit(resultSelector.Body), 
      memberSelector.Parameters); 
    } 

    protected override Expression VisitParameter(ParameterExpression parameter) 
    { 
     if (parameter == _parameterToReplace) 
      return _replacementExpression; 
     return base.VisitParameter(parameter); 
    } 
} 

Se da la siguiente expresión:

f => ((f.Bar % 2) == 0)