5

（较早的问题Recursively (?) compose LINQ predicates into a single predicate与此类似，但我实际上问错了问题......那里的解决方案满足了提出的问题，但实际上并不是我需要的。他们不过是不同的。诚实的。）

给定以下搜索文本：

"keyword1 keyword2 ... keywordN"

我想以以下 SQL 结束：

SELECT [columns] FROM Customer 
  WHERE (
        Customer.Forenames LIKE '%keyword1%' 
        OR 
        Customer.Forenames LIKE '%keyword2%'
        OR
        ...
        OR
        Customer.Forenames LIKE '%keywordN%'
    ) AND (
        Customer.Surname LIKE '%keyword1%' 
        OR 
        Customer.Surname LIKE '%keyword2%'
        OR
        ....
        OR
        Customer.Surname LIKE '%keywordN%'
    )

实际上，我们将搜索文本拆分为空格，修剪每个标记，基于 each 构造一个多部分 OR 子句，然后将这些子句“与”在一起。

我在 Linq-to-SQL 中执行此操作，但我不知道如何根据任意长的子谓词列表动态组合谓词。对于已知数量的子句，手动组合谓词很容易：

dataContext.Customers.Where(
    ( 
      Customer.Forenames.Contains("keyword1") 
      ||
      Customer.Forenames.Contains("keyword2")
    ) && (
      Customer.Surname.Contains("keyword1") 
      ||
      Customer.Surname.Contains("keyword2")
    )
);

简而言之，我需要一种技术，在给定两个谓词的情况下，将返回一个由提供的运算符组成两个源谓词的单个谓词，但仅限于 Linq-to-SQL 明确支持的运算符。有任何想法吗？

4

2 回答 2

6

你可以使用PredicateBuilder类

IQueryable<Customer> SearchCustomers (params string[] keywords)
{
  var predicate = PredicateBuilder.False<Customer>();

  foreach (string keyword in keywords)
  {
    // Note that you *must* declare a variable inside the loop
    // otherwise all your lambdas end up referencing whatever
    // the value of "keyword" is when they're finally executed.
    string temp = keyword;
    predicate = predicate.Or (p => p.Forenames.Contains (temp));
  }
  return dataContext.Customers.Where (predicate);
}

（这实际上是PredicateBuilder页面中的示例，我只是根据您的情况对其进行了调整...）

编辑：

实际上我误读了您的问题，上面的示例仅涵盖了解决方案的一部分...以下方法应该可以满足您的要求：

IQueryable<Customer> SearchCustomers (string[] forenameKeyWords, string[] surnameKeywords)
{
    var predicate = PredicateBuilder.True<Customer>();

    var forenamePredicate = PredicateBuilder.False<Customer>();
    foreach (string keyword in forenameKeyWords)
    {
      string temp = keyword;
      forenamePredicate = forenamePredicate.Or (p => p.Forenames.Contains (temp));
    }
    predicate = PredicateBuilder.And(forenamePredicate);

    var surnamePredicate = PredicateBuilder.False<Customer>();
    foreach (string keyword in surnameKeyWords)
    {
      string temp = keyword;
      surnamePredicate = surnamePredicate.Or (p => p.Surnames.Contains (temp));
    }
    predicate = PredicateBuilder.And(surnamePredicate);

    return dataContext.Customers.Where(predicate);
}

你可以这样使用它：

var query = SearchCustomers(
    new[] { "keyword1", "keyword2" },
    new[] { "keyword3", "keyword4" });

foreach (var Customer in query)
{
    ...
}
于 2010-09-23T22:34:38.153 回答
0

通常你会链式调用.Where(...). 例如：

var a = dataContext.Customers;
if (kwd1 != null)
    a = a.Where(t => t.Customer.Forenames.Contains(kwd1));
if (kwd2 != null)
    a = a.Where(t => t.Customer.Forenames.Contains(kwd2));
// ...
return a;

LINQ-to-SQL 会将它们全部重新组合到一个WHERE子句中。

但是，这不适用于OR。您可以使用联合和交集，但我不确定 LINQ-to-SQL（或 SQL Server）是否足够聪明，可以将其折叠回单个WHERE子句。OTOH，性能不受影响也没关系。无论如何，它看起来像这样：

<The type of dataContext.Customers> ff = null, ss = null;

foreach (k in keywords) {
    if (keywords != null) {
        var f = dataContext.Customers.Where(t => t.Customer.Forenames.Contains(k));
        ff = ff == null ? f : ff.Union(f);

        var s = dataContext.Customers.Where(t => t.Customer.Surname.Contains(k));
        ss = ss == null ? s : ss.Union(s);
    }
}
return ff.Intersect(ss);
于 2010-09-23T22:25:55.593 回答