此 LINQ 代码是否对原始数据执行多次查找？

Question

我们在使用 LINQ 的一段代码中遇到了轻微的性能问题，它提出了一个关于 LINQ 在查找方面如何工作的问题

我的问题是这样的（请注意，我已经更改了所有代码，因此这是代码的指示性示例，而不是真实场景）：

给定

public class Person {
 int ID;
 string Name;
 DateTime Birthday; 
 int OrganisationID;
}

如果我有一个包含 10 万个 Person 对象的列表，然后是一个日期列表，比如说 1000，我运行以下代码：

var personBirthdays = from Person p in personList
    where p.OrganisationID = 123
    select p.Birthday;

foreach (DateTime d in dateList)
{
    if (personBirthdays.Contains(d))
        Console.WriteLine(string.Format("Date: {0} has a Birthday", d.ToShortDateString()));
}

生成的代码将是以下代码的迭代：

100k（需要执行的循环以查找组织 ID 为 123 的用户）
乘以
1000（列表中的日期数量）
乘以
x（当日要检查组织ID 123 的用户数量）

这是很多迭代！

如果我将 personBirthdays 的代码更改为：

List<DateTime> personBirthdays = 
        (from Person p in personList
        where p.OrganisationID = 123
        select p.Birthday).ToList();

这应该将 100k 作为倍数删除，并且只执行一次？

所以你会得到 100k + (1000 * x) 而不是 (100k * 1000 * x)。

问题是这似乎太容易了，我确信 LINQ 在某处做了一些聪明的事情，这应该意味着这不会发生。

如果没有人回答，我会进行一些测试并报告。

清晰度更新： 我们不考虑数据库查找，personList 对象是内存中列表对象。这都是 LINQ-to-Objects。

Answer 1

这应该将 10k 作为倍数删除，并且只执行一次？

这意味着不是迭代 personList 100k 次，而是执行 where 和 select 操作对于每个迭代，您将迭代生成的 List 100k 次，where 和 select 操作将只对底层数据源执行一次。

问题是这似乎太容易了，我确信 LINQ 在某处做了一些聪明的事情，这应该意味着这不会发生。

不，您的第一个查询只是您不应该使用 LINQ 执行的操作，如果您计划多次迭代它们，您应该获取查询结果并将它们放入数据结构中（这就是你变了）。

您可以通过使用适当的数据结构进一步改进此查询。在List 上搜索效率相当低，因为它需要进行线性搜索。最好使用HashSet 来存储查询结果。在平均情况下，HashSet 的搜索速度为 O(1)，而 List 的搜索时间为 O(n)。

var dates = new HashSet<DateTime>(from Person p in personList
                                  where p.OrganisationID = 123
                                  select p.Birthday);

foreach (DateTime d in dateList.Where(date => dates.Contains(date)))
{
    Console.WriteLine(string.Format("Date: {0} has a Birthday", d.ToShortDateString()));
}

Answer 2

这是典型的select n+1 问题，在您应用.ToList() 后，您已经部分解决了它。下一步可能是：您不断迭代personBirthdays 列表，将其替换为HashSet，您可以更快地执行Contains(d) 并删除重复项：

var personBirthdays = new HashSet<DateTime>((from Person p in personList
    where p.OrganisationID = 123
    select p.Birthday).ToArray());

Answer 3

我假设您指的是 LINQ-to-Objects，因为每个 LINQ 提供程序都有自己的实现（LINQ-to-SQL、LINQ-to-Entities、LINQ-to-XML、LINQ-to-anything )。

以personBirthdays 为例，创建该表达式的目的是为了遍历整个结果集并不是一个定论，因此 LINQ 无法自动将结果具体化为数组或列表。

这些操作非常不同：

personBirthdays.Distinct()
personBirthdays.FirstOrDefault(b => b.Month == 7)
personBirthdays.Select(b => b.Year).Distinct()

LINQ 作为一种“聪明”的技术，它允许构造表达式树并推迟执行。这就是防止 - 在上面的第三个示例中 - 100k 迭代来获得生日，然后再 100k 来选择年份，然后是最终的、昂贵的传递来组装不同的值。

LINQ 使用者（您）必须拥有表达式的命运。如果您知道结果集将被迭代多次，那么您有责任将它们具体化为数组或列表。