Generic expression for where clause - "The LINQ expression node type 'Invoke' is not supported in LINQ to Entities."

Question

I am trying to write a really generic way to load EF entities in batches, using the Contains method to generate a SQL IN statement. I've got it working if I pass the entire expression in, but when I try to build the expression dynamically, I am getting a "The LINQ expression node type 'Invoke' is not supported in LINQ to Entities." So I know this means that EF thinks I'm calling an arbitrary method and it can't translate it into SQL, but I can't figure out how to get it to understand the underlying expression.

So If I do something like this (just showing the relevant snippets):

Function declaration:

public static List<T> Load<T>(IQueryable<T> entityQuery, int[] entityIds, Func<T, int> entityKey, int batchSize = 500, Func<T, bool> postFilter = null) where T : EntityObject
{
    var retList = new List<T>();

    // Append a where clause to the query passed in, that will use a Contains expression, which generates a SQL IN statement.  So our SQL looks something like
    // WHERE [ItemTypeId] IN (1921,1920,1922)
    // See http://rogeralsing.com/2009/05/21/entity-framework-4-where-entity-id-in-array/ for details
    Func<int[], Expression<Func<T, bool>>> containsExpression = (entityArray => (expr => entityArray.Contains(entityKey(expr))));

    // Build a new query with the current batch of IDs to retrieve and add it to the list we are returning
    newQuery = entityQuery.Where<T>(containsExpression(entityIds));
    retList.AddRange(newQuery.ToList());

    return retList;
} 

Call function:

var entities = BatchEntity.Load<ItemType>(from eItemType in dal.Context.InstanceContainer.ItemTypes
select eItemType
, itemTypeData
, (ek => ek.ItemTypeId)
);

I get "The LINQ expression node type 'Invoke' is not supported in LINQ to Entities."

But if I change it to be this:

Function declaration:

public static List<T> Load<T>(IQueryable<T> entityQuery, int[] entityIds, Func<int[], Expression<Func<T, bool>>> containsExpression, int batchSize = 500, Func<T, bool> postFilter = null) where T : EntityObject
{
    var retList = new List<T>();

    // Build a new query with the current batch of IDs to retrieve and add it to the list we are returning
    newQuery = entityQuery.Where<T>(containsExpression(entityIds));
    retList.AddRange(newQuery.ToList());

    return retList;
} 

Call function:

var entities = BatchEntity.Load<ItemType>(from eItemType in dal.Context.InstanceContainer.ItemTypes
select eItemType
, itemTypeData
, (entityArray => (ek => entityArray.Contains(ek.ItemTypeId)))
);

It works fine. Is there any way I can make EF understand the more generic version?

Answer 1

The problem, as you describe, is that the entityKey function in the first example is opaque since it is of type Func rather than Expression. However, you can get the behavior you want by implementing a Compose() method to combine two expressions. I posted the code to implement compose in this question: use Expression<Func<T,X>> in Linq contains extension.

With Compose() implemented, your function can be implemented as below:

public static List<T> Load<T>(this IQueryable<T> entityQuery, 
                              int[] entityIds, 
                              // note that this is an expression now
                              Expression<Func<T, int>> entityKey, 
                              int batchSize = 500, 
                              Expression<Func<T, bool>> postFilter = null) 
    where T : EntityObject
{
    Expression<Func<int, bool>> containsExpression = id => entityIds.Contains(id);
    Expression<Func<T, bool>> whereInEntityIdsExpression = containsExpression.Compose(entityKey);

    IQueryable<T> filteredById = entityQuery.Where(whereInEntityIdsExpression);

    // if your post filter is compilable to SQL, you might as well do the filtering
    // in the database
    if (postFilter != null) { filteredById = filteredById.Where(postFilter); }

    // finally, pull into memory
    return filteredById.ToList();
}