这两段代码实际上在做两件不同的事情。第一个版本将根据需要拉成员。第二个版本将在您开始对其进行任何操作之前将所有结果加载到内存中。

这个问题没有对错之分。哪一种更可取取决于具体情况。例如，如果您必须在一定时间内完成查询，并且需要对结果执行一些半复杂的操作，那么第二个版本可能更可取。但是要注意大的结果集，特别是在以32位模式运行这段代码时。在使用这个方法时，我已经被OutOfMemory异常咬了好几次。

要记住的关键是:区别在于效率。因此，您可能应该使用任何使代码更简单的方法，并且只在分析之后更改它。

在这种情况下，我将使用代码的版本2。由于您拥有可用产品的完整列表，而这正是此方法调用的“消费者”所期望的，因此需要将完整的信息发送回调用方。

如果该方法的调用者一次只需要“一个”信息，而下一个信息的消耗是按需的，那么使用yield return将是有益的，它将确保当一个单位的信息可用时，执行命令将返回给调用者。

可以使用yield return的例子如下:

复杂的，一步一步的计算，调用者每次等待一个步骤的数据 在GUI中分页-用户可能永远不会到达最后一页，只有子集的信息需要在当前页面上公开

为了回答你的问题，我会使用版本2。

yield的用法与关键字return类似，只是它将返回一个生成器。生成器对象只遍历一次。

Yield有两个好处:

您不需要读取这些值两次; 您可以获得许多子节点，但不必将它们全部放在内存中。

还有一种解释也许能帮到你。

Yield return对于需要遍历数百万个对象的算法来说非常强大。考虑以下示例，您需要计算可能的拼车行程。首先我们生成可能的行程:

    static IEnumerable<Trip> CreatePossibleTrips()
    {
        for (int i = 0; i < 1000000; i++)
        {
            yield return new Trip
            {
                Id = i.ToString(),
                Driver = new Driver { Id = i.ToString() }
            };
        }
    }

然后迭代每一次旅行:

    static void Main(string[] args)
    {
        foreach (var trip in CreatePossibleTrips())
        {
            // possible trip is actually calculated only at this point, because of yield
            if (IsTripGood(trip))
            {
                // match good trip
            }
        }
    }

如果您使用List而不是yield，您将需要为内存分配100万个对象(~190mb)，而这个简单的示例将花费~1400ms运行。但是，如果使用yield，就不需要将所有这些临时对象都放到内存中，而且算法速度会大大加快:本例只需要大约400ms就可以运行，完全不消耗内存。

作为理解何时应该使用yield的概念性示例，假设方法ConsumeLoop()处理ProduceList()返回/产生的项:

void ConsumeLoop() {
    foreach (Consumable item in ProduceList())        // might have to wait here
        item.Consume();
}

IEnumerable<Consumable> ProduceList() {
    while (KeepProducing())
        yield return ProduceExpensiveConsumable();    // expensive
}

如果没有yield，对ProduceList()的调用可能需要很长时间，因为你必须在返回之前完成列表:

//pseudo-assembly
Produce consumable[0]                   // expensive operation, e.g. disk I/O
Produce consumable[1]                   // waiting...
Produce consumable[2]                   // waiting...
Produce consumable[3]                   // completed the consumable list
Consume consumable[0]                   // start consuming
Consume consumable[1]
Consume consumable[2]
Consume consumable[3]

使用yield，它会重新排列，有点交错:

//pseudo-assembly
Produce consumable[0]
Consume consumable[0]                   // immediately yield & Consume
Produce consumable[1]                   // ConsumeLoop iterates, requesting next item
Consume consumable[1]                   // consume next
Produce consumable[2]
Consume consumable[2]                   // consume next
Produce consumable[3]
Consume consumable[3]                   // consume next

最后，正如之前许多人已经建议的那样，您应该使用版本2，因为您已经有了完整的列表。

这有点离题了，但由于这个问题被标记为最佳实践，我将继续发表我的意见。对于这种类型的东西，我非常喜欢把它变成一个属性:

public static IEnumerable<Product> AllProducts
{
    get {
        using (AdventureWorksEntities db = new AdventureWorksEntities()) {
            var products = from product in db.Product
                           select product;

            return products;
        }
    }
}

当然，它更像一个样板，但使用它的代码将看起来更干净:

prices = Whatever.AllProducts.Select (product => product.price);

vs

prices = Whatever.GetAllProducts().Select (product => product.price);

注意:我不会对任何可能需要一段时间才能完成工作的方法这样做。