How to create Expression by comparing Func with int

Question

I have a DbContext with a lot of DbSets. Every DbSet should have a function to get a page of items from the set, with a given pageSize and ordered by a specific sortOrder. Something like:

var pageItems = dbContext.Posts
    .Where(post => post.BlogId == blogId)
    .OrderBy(some sortorder)
    .Skip(pageNr * pageSize)
    .Take(pageSize);

I want to be able to do this with all my DbSets, so I have created an extension method where one of the parameters specifies the foreign key to compare and another the value this foreign key should have.

public static IQueryable<TSource> GetPage<TSource>(this IQueryable<TSource> source,
    int pageNr, int pageSize,
    Expression<Func<TSource, Tproperty>> keySelector, Tproperty comparisonValue)
{
    return  source
    .Where( ??? )
    .OrderBy(some sortorder)
    .Skip(pageNr * pageSize)
    .Take(pageSize);
}

How to convert the keySelector in a predicate suitable for Where?

Answer 1

How to convert the keySelector in a predicate suitable for Where?

This is quite easy, but I have no idea how are you going to handle ordering. Anyway, here is how you can do what are you asking for:

public static IQueryable<TSource> GetPage<TSource, TKey>(this IQueryable<TSource> source,
    int pageNr, int pageSize,
    Expression<Func<TSource, TKey>> keySelector, TKey comparisonValue)
{
    var predicate = Expression.Lambda<Func<TSource, bool>>(
        Expression.Equal(keySelector.Body, Expression.Constant(comparisonValue)),
        keySelector.Parameters);

    return source
        .Where(predicate)
        //.OrderBy(some sortorder) ??
        .Skip(pageNr * pageSize)
        .Take(pageSize);
}

Answer 2

You're looking for a way to get an Expression<Func<TSource, boolean>> from an Expression<Func<TSource, Tproperty>> keySelector and a Tproperty comparisonValue in such a way that it can be translated in to a store expression by the Entity Framework.

That means that the trivial

public static Expression<Func<TSource, bool>> KeyPredicateNaive<TSource, Tproperty>(Expression<Func<TSource, Tproperty>> keySelector, Tproperty comparisonValue)
{
  return (TSource source) =>EqualityComparer<Tproperty>.Default.Equals(keySelector.Compile()(source), comparisonValue);
}

won't work. This can't be translated to a store expression.

We need to construct the expression manually. What we need is an equality expression with the key selector as its left value, and a constant expression with the comparison value as value as its right value. We can construct that as follows:

public static Expression<Func<TSource, bool>> KeyPredicate<TSource, Tproperty>(Expression<Func<TSource, Tproperty>> keySelector, Tproperty comparisonValue)
{
  var bd = Expression.Equal(keySelector.Body, Expression.Constant(comparisonValue));
  return Expression.Lambda<Func<TSource, bool>>(bd, keySelector.Parameters);
}

The result of that can be passed to your where class. Slimmed down (so that it'll compile and run), your method will look like

public static IQueryable<TSource> GetPage<TSource>(this IQueryable<TSource> source,
    int pageSize,
    Expression<Func<TSource, Tproperty>> keySelector, Tproperty comparisonValue)
{
    return source
    .Where(KeyPredicate(keySelector, comparisonValue)
    .Take(pageSize);
}

Would I use this? Probably not. It's easier all round to pass the predicate as a lambda to the function directly rather than constructing the expression yourself. But it's certainly a possibility.

Answer 3

You are writing extension to queryable source, yes? So just pass expressions and filter source:

public static IQueryable<TSource> GetPage<TSource, TKey>(this IQueryable<TSource> source,
    Expression<Func<TSource, bool>> predicate,
    Expression<Func<TSource, TKey>> keySelector,
    int pageNr, int pageSize
    )
{
    return  source
       .Where(predicate)
       .OrderBy(keySelector)
       .Skip(pageNr * pageSize)
       .Take(pageSize);
}

Usage:

db.Posts.GetPage(p => p.Author == "Bob", p => p.Date, 5, 10);

Note: in your approach you have problem with sorting (second expression) and all you get is passing two parameters p => p.Author, "Bob" instead of passing one ready-to use expression p => p.Author == "Bob".

---

But I would move predicate and keySelector out of GetPage method. Let this method focus on paging only (as method name states):

public static IQueryable<TSource> GetPage<TSource, TKey>(this IQueryable<TSource> source,
    int pageNr, int pageSize)
{
    return  source.Skip(pageNr * pageSize).Take(pageSize);
}

Usage:

db.Posts.Where(p => p.Author == "Bob").OrderBy(p => p.Date).GetPage(5, 10);

Or if you have repository

postsRepository.GetByAuthor("Bob").GetPage(5, 10);

Answer 4

try this and see if it helps

Expression<Func<TSource, bool>> keySelector

or simply

Func<TSource, bool> keySelector

Answer 5

Given this code:

sealed class SwapVisitor : ExpressionVisitor
{
    private readonly Expression _from;
    private readonly Expression _to;

    public SwapVisitor(Expression from, Expression to)
    {
        _from = from;
        _to = to;
    }

    public override Expression Visit(Expression node)
    {
        return node == _from ? _to : base.Visit(node);
    }
}

static Expression<Func<TInput, bool>> Combine<TInput, TOutput>(
    Expression<Func<TInput, TOutput>> transform,
    Expression<Func<TOutput, bool>> predicate)
{
    var swap = new SwapVisitor(predicate.Parameters[0], transform.Body);
    return Expression.Lambda<Func<TInput, bool>>(
        swap.Visit(predicate.Body), transform.Parameters);
}

You can:

 .Where(Combine(keySelector, key => key == comparisonValue))

So that is creating a new Expression, with the body of the passed expression keySelector and the new expression for the comparison.

Thanks to Combine Lambda Expressions