Nehmen wir die folgenden Demoklassen an.Lambdas in Linq AST - warum unterschiedliches Verhalten?
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;
}
}
Sie sind in einem einfachen Linq Join zusammen.
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);
Nun wird die Abfrage durch eine Erweiterung implementiert
IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
{
if (expression == null)
throw new ArgumentNullException("expression");
return new ExpressionQueryImpl<TElement>(DataContextInfo, expression);
}
Die Einzelheiten der Durchführung sind irrelevant: meine Frage ist nur für den Ausdruck im Zusammenhang von der IQueryable abgeleitet. Es gibt zwei Lambdas: Eines ("visible") wird als Argument des Ausdrucks mit einem NodeType Quote
generiert, das sehr einfach zu analysieren ist, während das andere ("invisible") als zweites Argument des Ausdrucks mit generiert wird "where" -Klausel von NodeType Invoke
, die in Bezug auf seine SQL-Rendering fast unsichtbar ist. Warum passiert das und gibt es einen Weg, um zu arbeiten und es zu touren?
Sie sprechen über 'Expression's, aber zeigen Beispiele mit' Func's. Bitte aktualisieren Sie Ihre Post entsprechend und lassen Sie nur die relevanten Informationen, die den Fall darstellen. –
@IvanStoev Getan, für die "unsichtbare" LambdaExpression, die eine, die relevanter ist, weil es die Ursache für das "Problem" –
Nun sehe ich, was Sie meinen, aber Ausdrücke, die ** zurückkehren ** -Funktionen sind ziemlich seltsam, so bin ich nicht überrascht, dass der Abfrageanbieter sie nicht verwenden kann. Man beachte beispielsweise, dass 'Queryable.Where'' Expression> 'erwartet, d. H. Lambda, das den' T'-Parameter akzeptiert und 'bool' (nicht' Func'!) Zurückgibt. –