转换LINQ扩展方法以使用L2E

Question

I am working on a search page where users are able to use wildcards * in their search criteria. The wildcard can be placed at the beginning, or end of a string. Since there are several fields I need this to be applied to, I figured an extension method would be the best way. The code I came up with currently works, but not with IQueryable .

public static class Helper
{
    public static IEnumerable<string> MyExtMethod(this IEnumerable<string> items, string searchString)
    {
        var searchType = -1;    
        if(searchString.IndexOf("*") == -1) //No wildcard
        {
            searchType = 0;
        }
        else if(searchString.IndexOf("*") == 0 && searchString.LastIndexOf("*") == searchString.Length - 1)//start and end
        {
            searchType = 1;
        }
        else if(searchString.IndexOf("*") == 0)//ends with
        {
            searchType = 2;
        }
        else if(searchString.LastIndexOf("*") == searchString.Length - 1) //starts with
        {
            searchType = 3;
        }

        var search = searchString.Replace("*", "");

        foreach(var i in items)
        {
            switch(searchType)
            {
                case 0: yield return i;
                break;
                case 1: if(i.Contains(search))
                            yield return i;
                break;
                case 2: if(i.EndsWith(search))
                            yield return i;
                break;
                case 3: if(i.StartsWith(search))
                            yield return i;
                break;
            }
        }
    }
}

I only use string manipulation and extension methods that are already supported by L2E Contains , StartsWith , EndsWith . Can this be converted to work with entities? If so, what needs to be done? Thanks.

EDIT: If possible, I would love to be able to use this as such:

db.SomeTable.Where(s => s.SomeField.MyExtMethod(somestring));

Bonus points for reference sources.

Answer 1

EF uses IQueryable<T> - not IEnumerable<T>

So something like this should do:

public static class Helper
{
  public static IQueryable<Table> SearchText(
    this IQueryable<Table> q,
    string searchString
  )
  {
    var searchType = -1;    
    if(searchString.IndexOf("*") == -1)
    {
        searchType = 0; // No wildcard
    }
    else if(searchString.IndexOf("*") == 0 &&
      searchString.LastIndexOf("*") == searchString.Length - 1)
    {
        searchType = 1; // start and end
    }
    else if(searchString.IndexOf("*") == 0)
    {
        searchType = 2; // ends with
    }
    else if(searchString.LastIndexOf("*") == searchString.Length - 1)
    {
        searchType = 3; // starts with
    }

    var search = searchString.Replace("*", "");

    switch(searchType)
    {
      default:
      case 0: return q.Where( o => o == search );
      case 1: return q.Where( o => o.Text.Contains( search ) );
      case 2: return q.Where( o => o.Text.EndsWith( search ) );
      case 3: return q.Where( o => o.Text.StartsWith( search ) );
    }
  }
}

Where Table.Text is the property you want to search.

Then you can use it like this:

IQueryable<Table> q = dbContext.Table;

var matches = q.SearchText( searchString ).ToList();

Answer 2

I've found some base code around the internet and modified it slightly to work as I need it to.

• abc : matches "abc" exactly
• *abc : matches if string ends with "abc"
• abc* : matches if string starts with "abc"
• *abc* : matches if string contains "abc"

public static class LinqExtensions
{
public static IQueryable<TSource> WhereLike<TSource>(
    this IQueryable<TSource> source,
    Expression<Func<TSource, string>> valueSelector,
    string value,
    char wildcard)
{
    return source.Where(BuildLikeExpression(valueSelector, value, wildcard));
}

        public static Expression<Func<TElement, bool>> BuildLikeExpression<TElement>(
            Expression<Func<TElement, string>> valueSelector,
            string value,
            char wildcard)
        {
            if (valueSelector == null)
                throw new ArgumentNullException("valueSelector");

            var method = GetLikeMethod(value, wildcard);

            value = value.Trim(wildcard);
            var body = Expression.Call(valueSelector.Body, method, Expression.Constant(value));

            var parameter = valueSelector.Parameters.Single();
            return Expression.Lambda<Func<TElement, bool>>(body, parameter);
        }

        private static MethodInfo GetLikeMethod(string value, char wildcard)
        {
            var methodName = "Equals";

            var textLength = value.Length;
            value = value.TrimEnd(wildcard);
            if (textLength > value.Length)
            {
                methodName = "StartsWith";
                textLength = value.Length;
            }
            value = value.TrimStart(wildcard);
            if (textLength > value.Length)
            {
                methodName = (methodName == "StartsWith") ? "Contains" : "EndsWith";
                textLength = value.Length;
            }

            var stringType = typeof(string);
            return stringType.GetMethod(methodName, new Type[] { stringType });
        }
    }