LINQ to Objects 的奇怪行为

Question

我在代码中看到了奇怪的行为，这里有一个使用苹果和人的类似示例，但代码基本相同：

List<Apple> apples = ...
var selectableApples = apples.Select(a => new SelectableApple { SelectedByPerson = null, Apple = a });

foreach (Person person in persons)
{
    foreach (var unselectedApple in selectableApples.Where(aa => aa.SelectedByPerson == null))
    {
        if (/*the person satisfies some conditions*/)
        {
            // This gets executed like 100 times:
            unselectedApple.SelectedByPerson = person;
        }
    }
}

foreach (var selectedApple in selectableApples.Where(aa => aa.SelectedByPerson != null))
{
    Unreachable code - the collection is empty... WTF???
}

SelectableApple 类只是一个没有逻辑的普通 C# 类，并且具有公共 getter以及所有属性的设置器。

为什么会发生这种情况？

提前致谢！

Answer 1

selectedApples 不是一个包含对象的集合，它是一个动态创建集合的表达式。这意味着您对对象所做的更改将被丢弃，并且当您再次循环 selectedApples 时，它将从头开始重新创建。

使用 ToList 方法将其设为集合：

var selectableApples = apples.Select(a => new SelectableApple { SelectedByPerson = null, Apple = a }).ToList();

Answer 2

这里有几个问题。首先，Where 语句不会生成对象列表。它是一个表达式语句。

表达式语句会动态计算，因此每次运行该语句时都会丢弃对生成的对象所做的更改。不管你相信与否，这都是一个理想的结果。这使您能够以更高效、更优雅的方式处理复杂的嵌套 for 语句。

回答您的问题的最佳方法是分析您所编写的内容并修改一些代码以向您展示更好的方法。

在您的代码中：

List<Apple> apples = ...
var selectableApples = apples.Select(a => new SelectableApple { SelectedByPerson = null, Apple = a });

foreach (Person person in persons)
{
    foreach (var unselectedApple in selectableApples.Where(aa => aa.SelectedByPerson == null))
    {
        // This will ideally give all apples to the first person who
        // meets the conditions. As such this if condition can be moved
        // out side of the above the foreach loop.
        if (/*the person satisfies some conditions*/)
        {
            // This gets executed like 100 times:
            unselectedApple.SelectedByPerson = person;
        }
    }
}

foreach (var selectedApple in selectableApples.Where(aa => aa.SelectedByPerson != null))
{
    Unreachable code - the collection is empty... WTF???
}

因此，如果我们重新编写此代码，以便 if 语句位于内部循环之外。您的代码将执行相同的逻辑操作。请注意，这还不能解决问题，但可以让您更近一步。代码如下所示：

List<Apple> apples = ...
var selectableApples = apples.Select(a => new SelectableApple { SelectedByPerson = null, Apple = a });

foreach (Person person in persons)
{
    // Now we can see that since this will all apples to the first person
    // who satisfies the below conditions we are still doing to much. And it
    // still does not work.
    if (/*the person satisfies some conditions*/)
    {
        foreach (var unselectedApple in selectableApples.Where(aa => aa.SelectedByPerson == null))
        {
            // This gets executed like 100 times:
            unselectedApple.SelectedByPerson = person;
        }
    }
}

foreach (var selectedApple in selectableApples.Where(aa => aa.SelectedByPerson != null))
{
    Unreachable code - the collection is empty... WTF???
}

现在我们已经开始对事物进行分组，以便可以看到更简单的答案。因为if语句意味着只有第一个满足条件的人才能得到所有的苹果。因此，让我们摆脱外部 foreach 循环并将其压缩为 LINQ。

List<Apple> apples = ...
var selectableApples = apples.Select(a => new SelectableApple { SelectedByPerson = null, Apple = a }); 
var selectedPerson = persons.Where(p => /*the person satisfies some conditions*/).First()

if(selectedPerson != null)
{
    foreach (var unselectedApple in selectableApples.Where(aa => aa.SelectedByPerson == null))
    {
        // This gets executed like 100 times:
        unselectedApple.SelectedByPerson = person;
    }
}

foreach (var selectedApple in selectableApples.Where(aa => aa.SelectedByPerson != null))
{
    Unreachable code - the collection is empty... WTF???
}

看看上面的代码，我们现在可以看到内部循环只是对原始 select 的修改。让我们看一下：

List<Apple> apples = ...
var selectedPerson = persons.Where(p => /*the person satisfies some conditions*/).First()
var selectableApples = apples.Select(a => new SelectableApple { SelectedByPerson = selectedPerson, Apple = a }); 


foreach (var selectedApple in selectableApples.Where(aa => aa.SelectedByPerson != null))
{
    // This should now run provided that some person passes the condition.
}

现在您的代码将根据需要运行，并且您可以利用 LINQ 中提供的延迟加载和循环优化。