Question

让我们说我有一种特殊的方式来决定某些字符串是否“匹配”，如下所示：

public bool stringsMatch(string searchFor, string searchIn)
{
  if (string.IsNullOrEmpty(searchFor))
  {
    return true;
  }

  return searchIn != null &&
    (searchIn.Trim().ToLower().StartsWith(searchFor.Trim().ToLower()) ||
     searchIn.Contains(" " + searchFor));
}

我想使用Linq To Entities和这个助手从数据库中提取匹配项。但是，当我尝试这个时：

IQueryable<Blah> blahs = query.Where(b => stringsMatch(searchText, b.Name);

我得到“LINQ to Entities无法识别方法......”

如果我将代码重写为：

IQueryable<Blah> blahs = query.Where(b =>
      string.IsNullOrEmpty(searchText) ||
      (b.Name != null &&
        (b.Name.Trim().ToLower().StartsWith(searchText.Trim().ToLower()) ||
         b.Name.Contains(" " + searchText)));

这在逻辑上是等价的，那么事情就可以了。问题是代码不是可读的，我必须为我想要匹配的每个不同实体重写它。

据我所知this one这样的问题，我现在想做的事情是不可能的，但我希望我错过了什么，是吗？

Answer 1

如果您要过滤的所有'blahs'（类）具有相同的结构，您可以使用这样的简单方法。主要区别在于它返回一个Linq应该能够解析的Expression，它会引入整个实例并过滤Name，而不是只引入字符串名称。

    public static Expression<Func<T, bool>> BuildStringMatch<T>(string searchFor) where T : IHasName
    {
        return b =>
              string.IsNullOrEmpty(searchFor) ||
              (b.Name != null &&
                (b.Name.Trim().ToLower().StartsWith(searchFor.Trim().ToLower()) ||
                 b.Name.Contains(" " + searchFor)));
    }

您可以像这样使用该方法：

    IQueryable<Blah> blahs = query.Where(BuildStringMatch<Blah>(searchText));

假设您要过滤的所有类都实现了一些接口，例如：

    public interface IHasName
    {
        string Name { get; }
    }

如果你想过滤不同的属性，我认为你不能用这样的简单代码做些什么。我相信你需要自己用反射构建表达式（或者在使用反射的库的帮助下） - 它仍然可能但更难。

编辑：听起来你需要动态行为，所以我从dtb对this question的回答中借用了一些逻辑并得出了这个：

public static Expression<Func<T, bool>> BuildStringMatch<T>(Expression<Func<T, string>> property, string searchFor)
{
    var searchForExpression = Expression.Constant(searchFor, typeof(string));
    return
        Expression.Lambda<Func<T, bool>>(
            Expression.OrElse(
                Expression.Call(typeof(string), "IsNullOrEmpty", null, searchForExpression),
                Expression.AndAlso(
                    Expression.NotEqual(property.Body, Expression.Constant(null, typeof(string))),
                    Expression.OrElse(
                        Expression.Call(Expression.Call(Expression.Call(property.Body, "Trim", null), "ToLower", null), "StartsWith", null,
                            Expression.Call(Expression.Call(searchForExpression, "Trim", null), "ToLower", null)),
                        Expression.Call(property.Body, "Contains", null, Expression.Call(typeof(string), "Concat", null, Expression.Constant(" "), searchForExpression))
                    )
                )
            ),
            property.Parameters
        );
}

您可以使用它：

        IQueryable<Blah> blahs2 = query.Where(BuildStringMatch<Blah>(b => b.Name, searchText));

它冗长而冗长但你可以看到它与用直接C＃代码编写的原始方法类似。注意：我没有测试这段代码，因此可能存在一些小问题 - 但这是一般的想法。

Answer 2

使用名为LINQKit的免费库（如@Eranga所述），此任务变得合理。使用LINQKit我现在的代码如下：

protected Expression<Func<T, bool>> stringsMatch(string searchFor, Expression<Func<T, string>> searchIn)
{
  if (string.IsNullOrEmpty(searchFor))
  {
    return e => true;
  }

  return
    e =>
    (searchIn.Invoke(e) != null &&
      (searchIn.Invoke(e).Trim().ToLower().StartsWith(searchFor.Trim().ToLower()) ||
       searchIn.Invoke(e).Contains(" " + searchFor)));
}

需要像这样调用（注意AsExpandable（）调用）

IQueryable<Blah> blahs = query().AsExpandable().Where(StringsMatch(searchText, b => b.Name));

神奇的部分是searchIn.Invoke（e）调用和AsExpandable（）的使用，它添加了一个允许它们工作的包装层。

原作者here详细解释了AsExpandable（）位。

请注意，我对表达式的某些细节仍然有些模糊，所以如果可以做得更好/更短/更清楚，请添加评论/编辑此答案。

如何在使用LINQ to Entities和帮助方法时保持DRY？

2 个答案: