创建要在IQueryable上应用的动态搜索的最简单方法

Question

Consider the case of having a single table (called Car) with the following columns and the corresponding entity

string Make
string Model
string Owner

Now I want to create a search where the user can choose (by the use of checkboxes) which properties the search should be targetted to. If more than one is chosen, then it should be sufficient if the search string is found in at least one of them.

Moreover, if multiple search strings are given (separated by a space), the search should match only if every word is found (so for example, given search string "ter mist", a car with an owner "mister" would match).

After doing some research, I figured I'd create a list of Expression<Func<Car, bool>> for each of the chosen properties, add one for each word in the search string and then And all these together to create a single Expression<Func<Car, bool>> . Once I had these for all the chosen propeties, I would Or them together, to create the final filter. This, however, is where I am struggling.

In the end, the furthest I got was a NotSupportedException saying The LINQ expression node type 'Invoke' is not supported in LINQ to Entities.

Here are the helper functions I have for doing the combining (found from http://social.msdn.microsoft.com/Forums/en-US/linqprojectgeneral/thread/60a1f4c0-d4d9-4143-91aa-79d29dde7a7c/ ):

public static Expression<Func<T, bool>> Or<T>(params Expression<Func<T, bool>>[] predicates)
    {
        if (predicates.Length == 1)
            return predicates[0];

        Expression<Func<T, bool>> result = predicates[0];
        for (int i = 1; i < predicates.Length; i++)
        {
            result = OrTwo(result, predicates[i]);
        }

        return result;
    }
private static Expression<Func<T, bool>> OrTwo<T>(Expression<Func<T, Boolean>> expr1, Expression<Func<T, bool>> expr2)
    {
        var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
        return (Expression.Lambda<Func<T, Boolean>>(Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters));
    }

This is all getting surprisingly confusing as well, so I'm starting to think that there must be an easier way to go about this. So, what would be the easiest way to solve this?

---

Solution

After trying several things (LINQKit, Albahari's PredicateBuilder , fiddling with the expression trees myself), I finally ended up here . This universal version of the PredicateBuilder works without any other external dependencies, and is fully compatible with EF. It made solving the problem really trivial.

Answer 1

I decided to solve this problem myself a few weeks ago.

Check out my blog post:

http://jnye.co/Posts/5/generic-repository-search-function-with-expression-trees

Link Update: I have now created a new post which adds the search functionality as a extension method to IQueryable:

http://jnye.co/Posts/6/c%23-generic-search-extension-method-for-iqueryable

You should be able to adapt it to your needs.

Updated

Below is an extract of the Search function I created.

/// <summary>  
/// Performs a search on the supplied string property  
/// </summary>  
/// <param name="stringProperty">Property to search upon</param>  
/// <param name="searchTerm">Search term</param>  
public virtual IQueryable<T> Search(Expression<Func<T, string>> stringProperty, string searchTerm)  
{  
    var source = this.RetrieveAll();  

    if (String.IsNullOrEmpty(searchTerm))  
    {  
        return source;  
    }  

    //Create expression to represent T.[property] != null  
    var isNotNullExpression = Expression.NotEqual(stringProperty.Body, Expression.Constant(null));  

    //Create expression to represent T.[property].Contains(searchTerm)  
    var searchTermExpression = Expression.Constant(searchTerm);  
    var checkContainsExpression = Expression.Call(stringProperty.Body, typeof(string).GetMethod("Contains"), searchTermExpression);  

    //Join not null and contains expressions  
    var notNullAndContainsExpression = Expression.AndAlso(isNotNullExpression, checkContainsExpression);  

    //Build final expression  
    var methodCallExpression = Expression.Call(typeof (Queryable),   
                                               "Where",   
                                               new Type[] {source.ElementType},   
                                               source.Expression,   
                                               Expression.Lambda<Func<Club, bool>>(notNullAndContainsExpression, stringProperty.Parameters));  

    return source.Provider.CreateQuery<T>(methodCallExpression);  
}  

You should be able to refactor the code that generates the methodCallExpression to create multiple search expressions which you can then combine using Expression.OrElse() .