How can I factor out clauses in a parameterized Expression?

Hey all. I'm trying to optimize a Linq to Entities call by statically caching and reusing a compiled query. The query checks the same thing for a variable number of filter arguments, and the only way to compile query arguments like that is to explicitly use a number of arguments (rather than some Contains()-type logic, which in SQL can't be parameterized).

This works great and gives me a major performance boost. The problem is that the code is UGLY. I repeat the same chunk of code a number of times for each of the possible parameters. I.e:

           Expression<Func<Entities, string, string, string, string, IQueryable<Instrument>>> query = 
(context, searchTerm0, searchTerm1, searchTerm2, searchTerm3) =>
                context.Instruments
                    .Where(
                        (searchTerm0 == null ||
                            instr.FullName.IndexOf(searchTerm0) > -1 ||
                            instr.ShortName.IndexOf(searchTerm0) > -1 ||
                            instr.Strategi开发者_运维问答es.OrderBy(st => st.Level).Select(st => st.Name).Take(2).Any(strat => strat.IndexOf(searchTerm0) > -1))
                        &&
                        (searchTerm1 == null ||
                            instr.FullName.IndexOf(searchTerm1) > -1 ||
                            instr.ShortName.IndexOf(searchTerm1) > -1 ||
                            instr.Strategies.OrderBy(st => st.Level).Select(st => st.Name).Take(2).Any(strat => strat.IndexOf(searchTerm1) > -1))
                        &&
                        (searchTerm2 == null ||
                            instr.FullName.IndexOf(searchTerm2) > -1 ||
                            instr.ShortName.IndexOf(searchTerm2) > -1 ||
                            instr.Strategies.OrderBy(st => st.Level).Select(st => st.Name).Take(2).Any(strat => strat.IndexOf(searchTerm2) > -1))
                        &&
                        (searchTerm3 == null ||
                            instr.FullName.IndexOf(searchTerm3) > -1 ||
                            instr.ShortName.IndexOf(searchTerm3) > -1 ||
                            instr.Strategies.OrderBy(st => st.Level).Select(st => st.Name).Take(2).Any(strat => strat.IndexOf(searchTerm3) > -1))
                .Take(50);

I thought I'd be able to refactor this by dynamically creating the filter expressions, but it's seeming impossible. I want to do something like this:

    var filterExpression = (instr, searchTerm) =>
        searchTerm == null ||
        instr.FullName.IndexOf(searchTerm) > -1 ||
        instr.ShortName.IndexOf(searchTerm) > -1 ||
        instr.Strategies.OrderBy(st => st.Level).Select(st => st.Name).Take(2).Any(strat => strat.IndexOf(searchTerm) > -1);

    Expression<Func<Entities, string, string, string, string, IQueryable<Instrument>>> query = (context, searchTerm0, searchTerm1, searchTerm2, searchTerm3) =>
        context.Instruments
            .Where(i => filterExpression(i, searchTerm0))
            .Where(i => filterExpression(i, searchTerm1))
            .Where(i => filterExpression(i, searchTerm2))
            .Where(i => filterExpression(i, searchTerm3))
        .Take(50);

But of course that won't compile because filterExpression is an expression and can't be called into like that (and it can't just be a Func because Linq to Entities won't recognize it as a translatable method).

I also can't capture the parameters in closures outside the expression, because if I reuse the compiled expression, the values from the last call will be hard-coded and re-used. I.e., that's not a parameterized query.

Am I stuck writing out the whole thing for every term? I'd like to support a maximum of 14. Is it possible to factor out clauses that take parameters in this way?

Check out Predicate Builder. The docs are pretty good.

I've used it to support dozens of predicates and the resulting code is small when well-factored.