Question

我在很长一段时间内获得了最奇怪的调试体验。承认这有点令人尴尬，但它让我相信我的Linq查询在添加额外的Where子句时会产生更多结果。

我知道这是不可能的，所以我重构了我的违规功能以及属于它的单元测试：

[Test]
public void LoadUserBySearchString()
{
    //Setup
    var AllUsers = new List<User>
                       {
                           new User
                               {
                                   FirstName = "Luke",
                                   LastName = "Skywalker",
                                   Email = "luke@jedinet.org"
                               },
                           new User
                               {
                                   FirstName = "Leia",
                                   LastName = "Skywalker",
                                   Email = "faeryprincess@winxmail.com"
                               }
                       };


    //Execution
    List<User> SearchResults = LoadUserBySearchString("princess", AllUsers.AsQueryable());
    List<User> SearchResults2 = LoadUserBySearchString("princess Skywalker", AllUsers.AsQueryable());

    //Assertion
    Assert.AreEqual(1, SearchResults.Count); //test passed!
    Assert.AreEqual(1, SearchResults2.Count); //test failed! got 2 instead of 1 User???
}


//search CustID, fname, lname, email for substring(s)
public List<User> LoadUserBySearchString(string SearchString, IQueryable<User> AllUsers)
{
    IQueryable<User> Result = AllUsers;
    //split into substrings and apply each substring as additional search criterium
    foreach (string SubString in Regex.Split(SearchString, " "))
    {            
        int SubStringAsInteger = -1;
        if (SubString.IsInteger())
        {
            SubStringAsInteger = Convert.ToInt32(SubString);
        }

        if (SubString != null && SubString.Length > 0)
        {
            Result = Result.Where(c => (c.FirstName.Contains(SubString)
                                        || c.LastName.Contains(SubString)
                                        || c.Email.Contains(SubString)
                                        || (c.ID == SubStringAsInteger)
                                       ));
        }
    }
    return Result.ToList();
}

我调试了LoadUserBySearchString函数并断言第二次调用该函数实际上产生了一个带有两个where子句而不是一个的linq查询。所以似乎额外的where子句增加了结果的数量。

更奇怪的是，当我手动测试（来自数据库的真实用户）时，LoadUserBySearchString函数效果很好。它只显示运行单元测试时的这种奇怪行为。

我想我只需要一些睡眠（甚至是长假）。如果有人能帮助我解释一下，我可以不再质疑我的理智并重新开始工作。

谢谢，

阿德里安

编辑（澄清我到目前为止的几个回复）：我知道它看起来像是条款，但不幸的是它并不那么简单。 LoadUserBySearchString将搜索字符串拆分为多个字符串，并为每个字符串附加Where子句。 “天行者”与卢克和莱娅相匹配，但“公主”只与莱娅匹配。

这是搜索字符串“princess”的Linq查询：

+       Result  {System.Collections.Generic.List`1[TestProject.Models.User].Where(c => (((c.FirstName.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString) || c.LastName.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString)) || c.Email.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString)) || (c.ID = value(TestProject.Controllers.SearchController+<>c__DisplayClass3).SubStringAsInteger)))}  System.Linq.IQueryable<TestProject.Models.User> {System.Linq.EnumerableQuery<TestProject.Models.User>}

这是搜索字符串“princess Skywalker”的Linq子句

+       Result  {System.Collections.Generic.List`1[TestProject.Models.User].Where(c => (((c.FirstName.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString) || c.LastName.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString)) || c.Email.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString)) || (c.ID = value(TestProject.Controllers.SearchController+<>c__DisplayClass3).SubStringAsInteger))).Where(c => (((c.FirstName.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString) || c.LastName.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString)) || c.Email.Contains(value(TestProject.Controllers.SearchController+<>c__DisplayClass1).SubString)) || (c.ID = value(TestProject.Controllers.SearchController+<>c__DisplayClass3).SubStringAsInteger)))}    System.Linq.IQueryable<TestProject.Models.User> {System.Linq.EnumerableQuery<TestProject.Models.User>}

与上面相同，只有一个额外的where子句。

Answer 1

这是一个不错的小问题。

正在发生的是，由于匿名方法和延迟执行，您实际上并未过滤“公主”。相反，您正在构建一个过滤器，用于过滤subString变量的内容。

但是，然后，您更改此变量，并构建另一个过滤器，该过滤器再次使用相同的变量。

基本上，这就是你要执行的内容，简称：

Where(...contains(SubString)).Where(...contains(SubString))

所以，你实际上只是对两个中存在的最后一个词进行过滤，只是因为当实际应用这些过滤器时，只剩下一个SubString值，最后一个。

如果更改代码以便捕获循环范围内的SubString变量，它将起作用：

if (SubString != null && SubString.Length > 0)
{
    String captured = SubString;
    Int32 capturedId = SubStringAsInteger;
    Result = Result.Where(c => (c.FirstName.Contains(captured)
                                || c.LastName.Contains(captured)
                                || c.Email.Contains(captured)
                                || (c.ID == capturedId)
                               ));
}

Answer 2

您的算法相当于“选择与搜索字符串中的任何字词匹配的记录”。

这是因为延期执行。在调用.ToList（）之前，实际上不会执行查询。如果在循环中移动.ToList（），您将获得所需的行为。

为什么我的Linq Where子句产生的结果更多而不是更少？

2 个答案: