Dynamic Query Execution Using Predicate Builder
No problem Seth 
I'll see if I can get it to work and if not, what it does behind the scenes to the expression trees so I have a better overview and if I have to add something to make it work
Otis wrote:
No problem Seth
I'll see if I can get it to work and if not, what it does behind the scenes to the expression trees so I have a better overview and if I have to add something to make it work
Any news? I'm also trying to build a dynamic predicate system, to combine expression with and/or.
It simply chokes on the InvocationExpression instances created by the predicatebuilder. Frankly I have no idea why they create these expressions, it might be something that works just with linq to sql which might deal with the invocationexpressions.
I'll spend a brief moment checking whether I can either change the predicatebuilder source or add some support for invocationexpressions in this case, but you all have to realize that this is very very very frustrating. We spend 9 months full time writing a linq provider without any documentation whatsoever, and figuring out how 3rd party software works on linq to sql so we can copy the behavior on our own framework is therefore a matter of tedious trial/error and that added to the countless times we already had to use that way of doing software engineering with linq and expression trees, it's getting a bit too much. We did our very best to provide the best 3rd party linq provider out there, but I have to say there's a limit to what we can do.
The invocationexpression instances in the tree apparently have to be converted into something, as the predicate expression IS created but the handler of the invocationexpression of that produced predicateexpression gives the error in the generic sourcecode for visiting expression trees: the FilterExpression (derived from Expression) isn't invokable because it's not an Expression<T> class.
Anyone who knows WHY on earth this doesn't work, please step forward.
(btw, the predicatebuilder contains 2 bugs as well, 'And' should be 'AndAlso' and 'Or' should be 'OrElse', because 'Or' is a bitwise or operator predicate. )
(edit). The invoke is apparently used to replace parameters in the rightside expression (expr2) with the parameters of expr1. I can do that differently. it now produces a query, but the alias is wrong due to the wrong parameter. The utility class 'ExpressionReplacer' in the linq provider will help )
Works.
[Test]
public void GetCustomersUsingPredicateBuilder()
{
var predicate = PredicateBuilder.Null<CustomerEntity>();
using(DataAccessAdapter adapter = new DataAccessAdapter())
{
LinqMetaData metaData = new LinqMetaData(adapter);
predicate = predicate.Or(c => c.City == "London");
predicate = predicate.Or(c => c.City == "Paris");
var q = metaData.Customer.Where(predicate);
foreach(var v in q)
{
Assert.IsTrue((v.City == "London") || (v.City == "Paris"));
}
}
}
New predicate builder class:
public static class PredicateBuilder
{
public static System.Linq.Expressions.Expression<Func<T, bool>> Null<T>() { return null; }
public static System.Linq.Expressions.Expression<Func<T, bool>> Or<T>(this System.Linq.Expressions.Expression<Func<T, bool>> expr1,
System.Linq.Expressions.Expression<Func<T, bool>> expr2)
{
if(expr1 == null)
{
return expr2;
}
ExpressionReplacer replacer = new ExpressionReplacer(CreateFromToReplaceSet(expr2.Parameters, expr1.Parameters), null, null, null, null);
LambdaExpression rightExpression = (LambdaExpression)replacer.HandleExpression(expr2);
return System.Linq.Expressions.Expression.Lambda<Func<T, bool>>
(System.Linq.Expressions.Expression.OrElse(expr1.Body, rightExpression.Body), expr1.Parameters);
}
public static System.Linq.Expressions.Expression<Func<T, bool>> And<T>(this System.Linq.Expressions.Expression<Func<T, bool>> expr1,
System.Linq.Expressions.Expression<Func<T, bool>> expr2)
{
if(expr1 == null)
{
return expr2;
}
ExpressionReplacer replacer = new ExpressionReplacer(CreateFromToReplaceSet(expr2.Parameters, expr1.Parameters), null, null, null, null);
LambdaExpression rightExpression = (LambdaExpression)replacer.HandleExpression(expr2);
return System.Linq.Expressions.Expression.Lambda<Func<T, bool>>
(System.Linq.Expressions.Expression.AndAlso(expr1.Body, rightExpression.Body), expr1.Parameters);
}
private static Dictionary<LinqExpression, LinqExpression> CreateFromToReplaceSet(IList<ParameterExpression> from,
IList<ParameterExpression> to)
{
Dictionary<LinqExpression, LinqExpression> toReturn = new Dictionary<LinqExpression, LinqExpression>();
for(int i = 0; i < from.Count; i++)
{
toReturn.Add(from[i], to[i]);
}
return toReturn;
}
}
required usings using LinqExpression = System.Linq.Expressions.Expression; using SD.LLBLGen.Pro.LinqSupportClasses.ExpressionHandlers;
**Please let me know if this works for you. **
Sorry for the whining in my previous post, though it sometimes get on my nerves how shabby the whole documentation around everything linq is... 
I did a wild guess with the lambda changes and it worked out ok. haven't tested it further.
You see that it doesn't have True/False methods anymore, this is because those would result in a constant bool as predicate, which isn't supported.
great! 
Joined: 09-Sep-2008
Thank you, Otis! It is really cool 
Joined: 10-Sep-2008
Hi there
I'm Joe, the guy who wrote PredicateBuilder.
Regarding InvocationExpressions, they're simply a way of calling another lambda expression. It shouldn't be hard to support that within your LINQ parser. Having said that, Entity Framework can't handle InvocationExpressions either, so maybe you're in good company (actually I'd argue you could in bad company 
but that's another story).
Cheers
Joe
joealbahari wrote:
Hi there
I'm Joe, the guy who wrote PredicateBuilder.
Regarding InvocationExpressions, they're simply a way of calling another lambda expression. It shouldn't be hard to support that within your LINQ parser. Having said that, Entity Framework can't handle InvocationExpressions either, so maybe you're in good company (actually I'd argue you could in bad company
Cheers
Joe
Hi Joe!
We do have support for them for some cases but not for the case you used them for. Indeed, adding support for them isn't that hard per se, the thing is that they might end up in various situations so figuring out all situations are covered is a different matter, unfortunately.
Luckily it didn't take that long to rewrite your idea to make it work on our code Thanks for the initial class!
Joined: 02-Mar-2006
Joined: 14-Oct-2008
Hi all,
I wanted to implement the Predicate Builder class, but I can't resolve the LinqExpression type
private static Dictionary<LinqExpression, LinqExpression> CreateFromToReplaceSet(
I have included the 2 dll's and placed the usings.
Please help
Kind regards, Wim
hypo wrote:
Hi all,
I wanted to implement the Predicate Builder class, but I can't resolve the LinqExpression type
private static Dictionary<LinqExpression, LinqExpression> CreateFromToReplaceSet(
I have included the 2 dll's and placed the usings.
Please help
Kind regards, Wim
try adding:
using LinqExpression = System.Linq.Expressions.Expression;
edit: Otis is faster than me!
Joined: 14-Oct-2008
Otis wrote:
required usings using LinqExpression = System.Linq.Expressions.Expression; using SD.LLBLGen.Pro.LinqSupportClasses.ExpressionHandlers;
I should start reading the posts a bit better 
Still thanks to both for the quick and correct reply
Kind regards, Wim
Joined: 09-Aug-2010
Joined: 09-Aug-2010