I have a method:
public static void GetObjects()
{
using(MyContext context = new MyContext())
{
var objects = context.Bars.Where(b => b.Prop1
The reason it is running slower is because you are passing in a Func<Bar, bool>
which forces the context to retrive ALL Bars and then run the Func on the returned result set. A way to make this run better is to pass in Expression<Func<Bar, bool>>
Putting that all together will result in the following:
public static void GetObjectsV2(Expression<Func<Bar, bool>> whereFunc, Expression<Func<Bar, string>> selectPropFunc)
{
using(MyContext context = new MyContext())
{
var objects = context.Bars.Where(whereFunc)
.Select(selectPropFunc)
.ToList();
foreach(var object in objects)
{
// do something with the object
}
}
}
As I discovered in my own question, .Where(o => whereFunc(o))
is not the same as .Where(whereFunc)
in the Entity Framework.
The first one, .Where(Expression<Func<Bar, bool>>)
works like any other linq call, simply appending the expression to the expression tree.
In the second case, .Where(Func<Bar, bool>>)
, it will compile and evaluate the linq call (which so far is just context.Bars
) before applying the whereFunc
predicate.
So, to answer your question, the second one is much slower because it is pulling the entire Bars
table into memory before doing anything with it. Using .Where(o => whereFunc(o))
instead should fix that
(or, as Mark suggests, change the type of whereFunc to Expression<Func<Bar, bool>>
, which Func<Bar, bool>
is implicitly convertible to)