问题标签 [yield]

“test1”似乎是一个 IEnumerable，其中 v1 和 v2（参数）作为字段，并且没有调用“Test1”。

“Test2”工作“设计”:)

这是怎么回事？

两种方法的优点/缺点是什么？

相对

编辑因为它们与 MSIL 大致相当，你觉得哪一个更具可读性？

最初，上面的代码很棒，因为如果不需要，就不需要评估整个集合。

但是，一旦所有模块都被枚举一次，在没有变化的情况下重复查询 XDocument 变得更加昂贵。

因此，作为性能改进：

如果我重复使用整个列表，这很好，但否则就不是很好。

是否有一个中间立场，我可以在整个列表被迭代之前产生返回，然后缓存它并将缓存提供给后续请求？

Whilst I'd love to solve this problem in python, I'm stuck in Delphi for this one. I have nested lists (actually objects with nested lists as properties, but nevermind), and I want to iterate over them in a generator fashion. That is, I want to write a Next function, which gives me the next item from the leaves of the tree described by the nested lists.

For example, lets say I have

I want 8 consecutive calls to Next() to return 1..8.

How can I do this in a language without yield and generators?

Note that the depth of the nesting is fixed (2 in this example, 4 in real life), but answers which solve the more general case where depth is variable are welcome.

EDIT: Sorry, I should have mentioned, this is Delphi 2007.

我有这个代码工作：

但是，我想知道是否有更好的（LINQish）方法，而不必诉诸yield return。（而且LINQ to SQL不是一个选项 :)）

我是 Scala 的新手，据我了解，Scala 中的 yield 不像 C# 中的 yield，它更像是 select。

Scala 是否有类似于 C# 的 yield 的东西？C# 的产量很棒，因为它使编写迭代器变得非常容易。

更新：这是一个来自 C# 的伪代码示例，我希望能够在 Scala 中实现：

此代码实现了图的迭代广度优先遍历，使用yield，它返回一个迭代器，以便调用者可以使用常规for循环遍历图，例如：

在 C# 中，yield 只是语法糖，可以轻松编写迭代器（IEnumerable<T>在 .Net 中，类似于IterableJava）。作为一个迭代器，它的评估是惰性的。

更新二：我在这里可能是错的，但我认为 C# 中 yield 的全部意义在于你不必编写更高阶的函数。例如，您可以编写一个常规的 for 循环或使用类似 /// 的方法，select而map不是传入一个将遍历序列的函数。filterwhere

例如graph.iterator().foreach(n => println(n))，而不是graph.iterator( n => println(n)).

这样您就可以轻松地将它们链接起来，例如graph.iterator().map(x => x.foo).filter(y => y.bar >= 2).foreach(z => println(z)).

我传统上在 C# 中使用 yield 没有返回，例如：

但在其他示例中，我看到它写为“yield return foo;”，请参阅：http: //msdn.microsoft.com/en-us/library/9k7k7cf0%28VS.80%29.aspx。

有什么区别吗？

我正在尝试创建一个实用程序类来遍历目录中的所有文件，包括子目录和子子目录中的文件。我尝试使用发电机，因为发电机很酷；但是，我遇到了障碍。

当生成器到达一个目录时，它只是简单地生成新生成器的内存位置；它没有给我目录的内容。

如何使生成器产生目录的内容而不是新的生成器？

如果已经有一个简单的库函数可以递归地列出目录结构中的所有文件，请告诉我。我不打算复制库函数。

我正在尝试优化一个并发集合，以尽量减少读取的锁争用。第一遍是使用链表，它允许我只锁定写入，而许多同时读取可以继续畅通无阻。这使用了一个自定义IEnumerator来产生下一个链接值。一旦我开始将集合上的迭代与普通进行比较，List<T>我注意到我的实现速度大约是原来的一半（对于from x in c select x1*m* 项目的集合，我的集合分别为24 毫秒List<T>和49 毫秒）。

所以我想我会使用 aReaderWriteLockSlim并在读取上牺牲一点争用，这样我就可以使用 aList<T>作为我的内部存储。由于我必须在迭代开始时捕获读锁并在完成时释放它，所以我首先为 my IEnumerable, foreach做了一个yield模式List<T>。现在我只有66ms。

我查看了 List 实际做了什么，它使用了一个内部存储T[]和一个自定义IEnumerator来向前移动索引并返回当前索引值。现在，手动T[]用作存储意味着更多的维护工作，但是，我正在追逐微秒。

然而，即使模仿IEnumerator移动数组上的索引，我能做的最好的事情也是大约~38ms。那么是什么提供了List<T>它的秘诀，或者说什么是迭代器的更快实现呢？

更新：原来我的主要速度罪魁祸首是运行调试编译，而List<T>显然是发布编译。在发布时，我的实现仍然比 . 慢一点List<T>，尽管在单声道上它现在更快。

我从朋友那里得到的另一个建议是 BCL 更快，因为它在 GAC 中，因此可以由系统预编译。将不得不在 GAC 中进行测试以测试该理论。

我正在使用 C# 2.0 应用程序，因此 linq/lambda 答案在这里将无济于事。

基本上我面临的情况是我需要yield return一个对象，但前提是它的属性是唯一的（分组依据）。例如，..say 我有一个用户集合，我想要一个基于名称的分组集合（我可能有 20 个 Dave，但我只想在我的集合中看到一个）。

现在我可以想到很多这可能有用的情况，但我认为在 C# 2.0 中如果没有我明确地跟踪我用另一个内部列表产生的内容是不可能的。要做到这一点，我需要访问先前产生的集合以检查它们是否存在。

这是我想太多还是有意义？也许通过IEnumerable<T>界面访问产量是有意义的，所以你可以做这样的事情 -