Lambdas in Linq AST - why different behaviour? - linq

Question

Let's assume the following demo classes.
public class Foo {
public int key1 {get; set;}
public Foo(int _key1) {
key1 = _key1;
}
}
public class Bar {
public int key2 {get; set;}
public Bar(int _key2) {
key2 = _key2;
}
}
They are combined together in a simple Linq join.
Foo[]aSet = new Foo[3]{new Foo(1),new Foo(2),new Foo(3)};
Bar[]bSet = new Bar[3]{new Bar(1),new Bar(3),new Bar(5)};
Func<int,Func<Foo,bool>> VisibleLambda = w => x => x.key1 > w;
var pb = Expression.Parameter(typeof(Bar),"z");
var pf = Expression.Parameter(typeof(Foo), "y");
PropertyInfo BarId = typeof(Bar).GetProperty("key2");
PropertyInfo FooId = typeof(Foo).GetProperty("key1");
var eqexpr = Expression.Equal(Expression.Property(pb, BarId), Expression.Property(pf, FooId));
var lambdaInt = Expression.Lambda<Func<Bar, bool>>(eqexpr, pb);
var InvisibleLambda = Expression.Lambda<Func<Foo,Func<Bar, bool>>>( lambdaInt,pf);
var query = from a in aSet.Where(VisibleLambda(1))
from b in bSet.Where(InvisibleLambda.Compile()(a))
select new Tuple<Foo,Bar>(a,b);
Now, the query is implemented through an extension
IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
{
if (expression == null)
throw new ArgumentNullException("expression");
return new ExpressionQueryImpl<TElement>(DataContextInfo, expression);
}
The details of the implementation are irrelevant: my question is only related to the expression derived from the IQueryable.
There are two lambdas: one ("visible") is generated as an argument of the expression with a NodeType Quote that is very easy to analyse, while the other one ("invisible") is generated as a second argument of the expression with "where" clause of NodeType Invoke that is almost invisible in terms of its sql rendering.
Why is that happening and is there a way to work-around and d-tour it?

Answer 1

As pointed out by the comments 1 and 2 of Ivan Stoev, the different behaviour, and in particular the problem in the sql generation, was due to different signature expected from the Queryable.Where
Here is the solution from Igor Tkachev, for anyone who would be interested.
Everything boils down to implementing the helpful extension, where one can leverage the linq method with the appropriate signature: i.e the Queryable.GroupJoin :-)
static class ExpressionTestExtensions
{
public class LeftJoinInfo<TOuter,TInner>
{
public TOuter Outer;
public TInner Inner;
}
[ExpressionMethod("LeftJoinImpl")]
public static IQueryable<LeftJoinInfo<TOuter,TInner>> LeftJoin<TOuter, TInner, TKey>(
this IQueryable<TOuter> outer,
IEnumerable<TInner> inner,
Expression<Func<TOuter, TKey>> outerKeySelector,
Expression<Func<TInner, TKey>> innerKeySelector)
{
return outer
.GroupJoin(inner, outerKeySelector, innerKeySelector, (o, gr) => new { o, gr })
.SelectMany(t => t.gr.DefaultIfEmpty(), (o,i) => new LeftJoinInfo<TOuter,TInner> { Outer = o.o, Inner = i });
}
static Expression<Func<
IQueryable<TOuter>,
IEnumerable<TInner>,
Expression<Func<TOuter,TKey>>,
Expression<Func<TInner,TKey>>,
IQueryable<LeftJoinInfo<TOuter,TInner>>>>
LeftJoinImpl<TOuter, TInner, TKey>()
{
return (outer,inner,outerKeySelector,innerKeySelector) => outer
.GroupJoin(inner, outerKeySelector, innerKeySelector, (o, gr) => new { o, gr })
.SelectMany(t => t.gr.DefaultIfEmpty(), (o,i) => new LeftJoinInfo<TOuter,TInner> { Outer = o.o, Inner = i });
}
}
Having defined such an extension, my "generic join" will turn to
static internal IQueryable<ExpressionTestExtensions.LeftJoinInfo<T2,T1>> NewJoin<T1, T2, TKey>(Expression<Func<T2, TKey>> outer, Expression<Func<T1, TKey>> inner)
where T2: class
where T1 : class
{
using (var db = new MyContext()) {
var query = (from b in db.GetTable<T2>() select b).LeftJoin <T2,T1, TKey>((from f in db.GetTable<T1>() select f), outer, inner);
return query;
}
}
}
Finally, the elegant use case simply becomes
public static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//var queryList = Test.Join<Bar, Foo>(b => q => q.id == b.id);
var queryList = Test.NewJoin<Bar, Foo, int>(q => q.id, b => b.id);
foreach (var telement in queryList)
{
var bar = telement.Inner as Bar;
var element = telement.Outer as Foo;
Console.WriteLine(element.id.ToString() + " " + element.FromDate.ToShortDateString() +" "
+bar.id.ToString() + " " + bar.Name
);
}
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}