如何使用 LINQ 延迟加载 where 条件

Question

I'm new to LINQ

I'm trying to execute a dynamic where using the lazy loading, but I can't understand how to do it.

This is my code

protected int AnimalCount(System.Func<Animal, bool> expression = null, System.Func<Animal, bool> additionalExpression= null)
    {
    var records = (from temp in DbContext.Animal select temp);
    if (expression != null) records = records.Where(expression).AsQueryable();
    if (additionalExpression != null) records = records.Where(additionalExpression).AsQueryable();
    return records.Count();
}

Now, the problem is that the query is very slow, I think it's because the where clause are applied on the SELECT * FROM Animal list queried

Answer 1

• You should be using System.Linq.Expression<System.Func<Animal, bool>> instead of System.Func<Animal, bool> , this is required for use with EF and I am assuming you want the expressions applied as SQL and not in memory.
• You can change the signature to use params and an array of expressions and then iterate over them to apply them.

Changed code:

protected int AnimalCount(params System.Linq.Expression<System.Func<Animal, bool>>[] expressions)
{
    var records = DbContext.Animal as IQueryable<Animal>;
    foreach (var expression in expressions)
      records = records.Where(expression);
    return records.Count();
}

Answer 2

Linq to entity builds the expression tree and when you request the actual data from it - it applies your request against the database and returns the result. So it's a lazy loading by default.

var request = DbContext.Animal.AsQeriable();

if (predicate != null) 
    request = request.Where(predicate);

return request.Count();

You could also go with accepting params array of your predicates as

Foo(params Expression<Func<Animal, bool>>[] predicates)

And then use them inside your function like this:

foreach(var predicate in predicates) 
      request = request.Where(predicate);