lambda Expresiones

Question

¿Cómo hago para unir dos expresiones lambda como theese:

Expression<Func<string, bool>> expr1 = a => a.Length > 100; 
Expression<Func<string, bool>> expr2 = b => b.Length < 200; 

... en una expresión como esta:

Expression<Func<string, bool>> expr3 = s => s.Length < 100 && s.Length < 200; 

Es decir, unirse a ellos con un operador AndAlso . (O cualquier otro operador para el caso ...)

En realidad tuve éxito con algunos desagradables recursivos reemplazo de parámetros lambda y luego unirse con el método Expression.AndAlso. Pero estoy buscando algo más simple.

Por ejemplo algo como: (. Lo que obviamente no funciona)

Expression<Func<string, bool>> expr3 = c => expr1(a) && expr2(b); 

Answer 1

Su "algo así como" funcionaría si se trata de delegados normales. Pero si tiene que usar árboles de expresión, no veo ninguna otra solución que el reemplazo recursivo.

En .NET 4, puede usar System.Linq.Expressions.ExpressionVisitor para hacer este tipo de reemplazo recursivo mucho más fácil. Para .NET 3.5, eche un vistazo a esta muestra: http://msdn.microsoft.com/en-us/library/bb882521.aspx

Al usar ExpressionVisitor, solo tiene que anular los métodos para los tipos de nodo que desea reemplazar y el árbol circundante se reconstruirá automáticamente.

Si se trata de condiciones para usar con LINQ, una solución mucho más fácil para combinar dinámicamente las condiciones es simplemente llamar a Where() varias veces.

Answer 2

Acabo de descubrir cómo hacer esto con .NET 4 usando un nuevo método de actualización. Dado que es un método nuevo, supongo que también deben haberlo necesitado. Estoy muy contento con eso, porque la solución de .NET 3.5 es realmente fea. (Nota: esta solución no funciona de todos modos Compruebe comentarios..)

Expression<Func<string, bool>> expr1 = a => a.Length > 100; 
Expression<Func<string, bool>> expr2 = b => b.Length < 200; 

// This produces a new expression where the parameter b is replaced with a 
expr2 = expr2.Update(expr1.Body, expr1.Parameters); 

// So now we can join the bodies and produce a new lambda expression. 
Expression<Func<string, bool>> expr3 = Expression.Lambda<Func<string, bool>>(Expression.AndAlso(expr1.Body, expr2.Body), expr1.Parameters); 

Answer 3

No es tan malo con Expression.Invoke ...:

var strings = (new [] { "a", "bb", "ccc", "dddd", "eeeee", "fffff" }); 
Expression<Func<string, bool>> expr1 = a => a.Length > 1; 
Expression<Func<string, bool>> expr2 = b => b.Length < 4; 

ParameterExpression p = expr1.Parameters[0]; 

var andAlso = System.Linq.Expressions.Expression.AndAlso(Expression.Invoke(expr1, p), Expression.Invoke(expr2, p)); 
var lambda = LambdaExpression.Lambda<Func<string, bool>>(andAlso, p); 
var filteredStrings = strings.AsQueryable().Where(lambda);