Expression abstraction

If you plan to use result of MatchMyModelFieldByStrategy with Entity Framework or LINQ2SQL, the selector must be an expression instead of delegate, because underlying LINQ providers won't recognize delegate during building entity command text.

Hence, you have to build expression yourself, something like this:

(assuming, that you have similar types:)

enum SearchStrategy
{
    Contains,
    StartsWith,
    EndsWith,
    Equals
}

class SearchItem
{
    public SearchStrategy SearchStrategy { get; set; }
    public string Value { get; set; }
}

Here's the code, which builds the filtering expression:

static class QueryBuilder
{
    private static readonly Lazy<MethodInfo> toLowerMethodInfo;
    private static readonly Dictionary<SearchStrategy, Lazy<MethodInfo>> searchStrategyToMethodInfoMap;

    static QueryBuilder()
    {
        toLowerMethodInfo = new Lazy<MethodInfo>(() => typeof(string).GetMethod("ToLower", new Type[0]));

        searchStrategyToMethodInfoMap = new Dictionary<SearchStrategy, Lazy<MethodInfo>>
        {
            { 
                SearchStrategy.Contains, 
                new Lazy<MethodInfo>(() => typeof(string).GetMethod("Contains", new[] { typeof(string) })) 
            },
            { 
                SearchStrategy.StartsWith, 
                new Lazy<MethodInfo>(() => typeof(string).GetMethod("StartsWith", new[] { typeof(string) })) 
            },
            { 
                SearchStrategy.EndsWith, 
                new Lazy<MethodInfo>(() => typeof(string).GetMethod("EndsWith", new[] { typeof(string) })) 
            },
            { 
                SearchStrategy.Equals, 
                new Lazy<MethodInfo>(() => typeof(string).GetMethod("Equals", new[] { typeof(string) })) 
            },
        };
    }

    public static Expression<Func<T, bool>> MatchMyModelFieldByStrategy<T>(SearchItem searchItem, Expression<Func<T, string>> selector)
    {
        // "doe"
        var searchItemKey = searchItem.Value.ToLower();
        // _.Name.ToLower()
        var toLowerCallExpr = Expression.Call(selector.Body, toLowerMethodInfo.Value);
        // a method we shall use for searching
        var searchMethodInfo = searchStrategyToMethodInfoMap[searchItem.SearchStrategy].Value;

        // _ => _.Name.ToLower().SomeSearchMethod("doe")
        return Expression.Lambda<Func<T, bool>>(
            Expression.Call(toLowerCallExpr, searchMethodInfo, Expression.Constant(searchItemKey)), 
            selector.Parameters);
    }
}

I've added a little laziness to cache reflection results, because for every MatchMyModelFieldByStrategy call they'll be the same.

Now the test entity type:

class MyEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
}

... and the sample code:

    static void Main(string[] args)
    {
        Console.WriteLine(QueryBuilder.MatchMyModelFieldByStrategy<MyEntity>(
            new SearchItem { SearchStrategy = SearchStrategy.Contains, Value = "doe" }, _ => _.Name));
        Console.WriteLine(QueryBuilder.MatchMyModelFieldByStrategy<MyEntity>(
            new SearchItem { SearchStrategy = SearchStrategy.StartsWith, Value = "doe" }, _ => _.Name));
        Console.WriteLine(QueryBuilder.MatchMyModelFieldByStrategy<MyEntity>(
            new SearchItem { SearchStrategy = SearchStrategy.EndsWith, Value = "doe" }, _ => _.Name));
        Console.WriteLine(QueryBuilder.MatchMyModelFieldByStrategy<MyEntity>(
            new SearchItem { SearchStrategy = SearchStrategy.Equals, Value = "doe" }, _ => _.Name));

        Console.ReadLine();
    }