在C中，yield关键字用于什么？

What is the yield keyword used for in C#?

在"How can I expose only a fragment of ilist<>question"中，其中一个答案包含以下代码片段：

1
2
3
4
5
6
7
8

IEnumerable<object> FilteredList()
{
foreach( object item in FullList )
{
if( IsItemInPartialList( item )
yield return item;
}
}

yield关键字在那里做什么？我在一些地方看到过它的引用，还有一个问题，但我还没有完全弄清楚它实际上是做什么的。我习惯于从一根线屈服于另一根线的角度来考虑屈服，但这在这里似乎并不相关。

相关讨论

yield关键字实际上在这里做了很多工作。函数返回实现IEnumerable接口的对象。如果调用函数开始对该对象进行调用，则再次调用该函数，直到它"生成"。这是C 2.0中引入的句法糖。在早期版本中，您必须创建自己的IEnumerable和IEnumerator对象来执行类似的操作。

理解这种代码的最简单方法是在一个示例中键入，设置一些断点，然后看看会发生什么。

尝试单步执行此操作，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public void Consumer()
{
foreach(int i in Integers())
{
Console.WriteLine(i.ToString());
}
}

public IEnumerable<int> Integers()
{
yield return 1;
yield return 2;
yield return 4;
yield return 8;
yield return 16;
yield return 16777216;
}

当您单步执行该示例时，您将发现对integers()的第一个调用返回1。第二个调用返回2，"yield return 1"行不再执行。

这是一个真实的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public IEnumerable<T> Read<T>(string sql, Func<IDataReader, T> make, params object[] parms)
{
using (var connection = CreateConnection())
{
using (var command = CreateCommand(CommandType.Text, sql, connection, parms))
{
command.CommandTimeout = dataBaseSettings.ReadCommandTimeout;
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
yield return make(reader);
}
}
}
}
}

相关讨论

在这种情况下，这将更容易，我只是使用这里的整数来显示收益率如何工作。使用yield-return的好处在于，它是实现迭代器模式的一种非常快速的方法，因此可以轻松地进行评估。
同样值得注意的是，当您不想再退货时，您可以使用yield break;。
@从技术上讲，brianleeming调用Integers()返回IEnumerable；
您使用的任何LINQ操作实际上都是通过使用yield完成的延迟加载，实际上所有ORM都使用这个…
yield不是关键字。如果是这样的话，我就不能像在int yield = 500;中那样使用yield作为标识符。
1…2…4…8…16…983475398745394875？
@这是因为所有编程语言都支持两种类型的关键字，即保留关键字和上下文关键字。yield属于后面的类别，这就是为什么C编译器不禁止您的代码。这里有更多的细节：ericlippert.com/2009/05/11/reserved-and-contextual-keywords你会很高兴地知道，还有一些保留字，它们不能被一种语言识别为关键字。例如Java中的GTO。更多详情请访问：stackoverflow.com/questions/2545103/&hellip；
@RBT也许你是对的。但在其他语言中，通常不需要区分关键字和保留字。例如，在Java中，可以将GOTO视为一个什么也不做的关键字。上下文关键字似乎是C的一个好主意。C++的方法，例如，试图回收现有的关键字，如删除和自动给他们新的语言特征。
'If a calling function starts foreach-ing over this object the function is called again until it"yields"'。我听上去不太对劲。我一直在想C yield关键字的上下文是"收获丰收"，而不是"汽车向行人让步"。
在这种情况下，返回是提供者，而yield是控制流挂起和控制本身被放弃的标志。IEnumerable对调用上下文/循环(如汽车和行人)进行控制，而RETURN则承载当前状态的有效负载，即示例中的农作物。是的，仅返回就以一种主要的方式放弃了控制，但是yield就像一个goto，在返回点被创建，在下一次调用之后被创建；在最后一次生成控制的地方恢复，而在传统返回的情况下放弃它。
@brianleeeming您的句子是错误的：对integers()的调用只执行一次，然后返回整个列表。dotnetfiddle.net/8lcfqg
"yield"关键字是反直觉的，应该弃用。
@或者你需要多训练你的直觉。编程语言的许多高级特性起初是违反直觉的。

迭代。它创建了一个"在封面下"的状态机，它可以记住您在函数的每个附加循环中所处的位置，并从中获取信息。

产量有两大用途，

它有助于在不创建临时集合的情况下提供自定义迭代。

它有助于进行有状态的迭代。 enter image description here

为了更明确地解释以上两点，我制作了一个简单的视频，你可以在这里观看。

相关讨论

最近，RaymondChen也发表了一系列关于yield关键字的有趣文章。

C语言中迭代器的实现及其后果(第1部分)
C语言中迭代器的实现及其后果(第2部分)
C语言中迭代器的实现及其后果(第3部分)
C语言中迭代器的实现及其后果(第4部分)

虽然它名义上用于轻松实现迭代器模式，但可以概括为状态机。引用Raymond没有意义，最后一部分还链接到其他用途(但是Entin的博客中的例子特别好，展示了如何编写异步安全代码)。

相关讨论

第一眼，产量回报是一种纯糖，可以回报。

3.Without yield，all the items of the collection are created at once:

ZZU1

SAME code using yield，it returns item by item：

1
2
3
4
5
6
7
8
9
10
11

class SomeData
{
public SomeData() { }

static public IEnumerable<SomeData> CreateSomeDatas()
{
yield return new SomeData();
yield return new SomeData();
yield return new SomeData();
}
}

使用产量的优点是，如果功能消耗了你的数据，简单地需要收集的第一个项目，项目的其余部分就不会产生。

应要求，产量算子允许项目的创建。这是一个很好的理由。

与调查者一起使用。在每一次呼唤产量声明时，控制权都回到呼叫者手中，但这意味着Callee's State is maintained.由于这个原因，当Caller Enumerates the next element时，它继续在Callee方法中执行，从EDOCX1&1之后立即声明。

让我们以一个例子来理解这一点。在这个例子中，对应于每一条线路，我在执行流量中提到了顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static void Main(string[] args)
{
foreach (int fib in Fibs(6))//1, 5
{
Console.WriteLine(fib +"");//4, 10
}
}

static IEnumerable<int> Fibs(int fibCount)
{
for (int i = 0, prevFib = 0, currFib = 1; i < fibCount; i++)//2
{
yield return prevFib;//3, 9
int newFib = prevFib + currFib;//6
prevFib = currFib;//7
currFib = newFib;//8
}
}

此外，国家对每一项调查都有控制权。假设，我有另一个电话给Fibs()方法，然后国家会重新接通。

相关讨论

直观地说，关键字从函数返回一个值而不离开它，即在代码示例中，它返回当前的item值，然后继续循环。更正式地说，编译器使用它为迭代器生成代码。迭代器是返回IEnumerable对象的函数。MSDN上有几篇关于它们的文章。

相关讨论

一个列表或阵列实现负荷的所有项目立即在产量实现时提供一个缺陷执行方案。

在实践中，这往往是一种令人沮丧的情况，因为需要在工作中达到最小的数量，以减少资源消耗的一种应用。

例如，我们可以在一个数据库中应用数以百万计的记录。The following benefits can be achieved when we use ienumerable in a deferred execution pull-based model：

Scalability，reliability and predictibility are likely to improve，since the number of records does not impressicantly impact the application's resource requirements.
性能和响应性是自从处理能够立即开始等待整个收藏成为第一个装载。
由于应用可以停止、开始、中断或失败，因此恢复能力和使用是可以改进的。只有进步中的项目才能与实际使用结果的一部分的所有数据进行比较。
在添加恒定工作负荷流的环境中，可进行连续处理。

这是一个比较，比如说一张清单，用产量来比较。

List Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class ContactListStore : IStore<ContactModel>
{
public IEnumerable<ContactModel> GetEnumerator()
{
var contacts = new List<ContactModel>();
Console.WriteLine("ContactListStore: Creating contact 1");
contacts.Add(new ContactModel() { FirstName ="Bob", LastName ="Blue" });
Console.WriteLine("ContactListStore: Creating contact 2");
contacts.Add(new ContactModel() { FirstName ="Jim", LastName ="Green" });
Console.WriteLine("ContactListStore: Creating contact 3");
contacts.Add(new ContactModel() { FirstName ="Susan", LastName ="Orange" });
return contacts;
}
}

static void Main(string[] args)
{
var store = new ContactListStore();
var contacts = store.GetEnumerator();

Console.WriteLine("Ready to iterate through the collection.");
Console.ReadLine();
}

控制台输出
联系人：创建联系人1
联系人2
联系人3
准备通过收藏重新开始。

注：整个收藏都装入了记忆中，甚至没有要求在列表中列入一个单一项目。

Yield Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class ContactYieldStore : IStore<ContactModel>
{
public IEnumerable<ContactModel> GetEnumerator()
{
Console.WriteLine("ContactYieldStore: Creating contact 1");
yield return new ContactModel() { FirstName ="Bob", LastName ="Blue" };
Console.WriteLine("ContactYieldStore: Creating contact 2");
yield return new ContactModel() { FirstName ="Jim", LastName ="Green" };
Console.WriteLine("ContactYieldStore: Creating contact 3");
yield return new ContactModel() { FirstName ="Susan", LastName ="Orange" };
}
}

static void Main(string[] args)
{
var store = new ContactYieldStore();
var contacts = store.GetEnumerator();

Console.WriteLine("Ready to iterate through the collection.");
Console.ReadLine();
}

控制台输出
准备通过收藏重新开始。

注：收藏并非一律执行。这是由于"有缺陷的执行"的性质。建设一个项目只会在需要时出现。

让我们重新召唤收藏，在我们第一次接触收藏的时候，抛弃行为。

1
2
3
4
5
6
7
8

static void Main(string[] args)
{
var store = new ContactYieldStore();
var contacts = store.GetEnumerator();
Console.WriteLine("Ready to iterate through the collection");
Console.WriteLine("Hello {0}", contacts.First().FirstName);
Console.ReadLine();
}

控制台输出
准备通过收藏重新开始
联系人1
你好鲍勃

尼斯只有当客户"推出"项目时，才构建第一个接触点。

以下是理解概念的简单方法：基本思想是，如果您想要一个集合，您可以在上面使用"foreach"，但是由于某些原因(例如从数据库中查询这些项)将这些项收集到集合中是很昂贵的，并且您通常不需要整个集合，那么您可以创建一个函数，一次生成一个集合，并将其返回给缺点。numer(然后可以提前终止收集工作)。

这样想：你到肉柜台去买一磅火腿片。屠夫把一个10磅重的火腿放在后面，放在切片机上，把整条火腿切片，然后把一堆切片拿回来，量出一磅。(旧路)。有了yield，屠夫把切片机带到柜台上，开始把每一片切片"生产"到秤上，直到它达到1磅，然后为你包装好，你就完成了。旧的方法可能对屠夫更好(让他按照自己喜欢的方式组织他的机器)，但新的方法显然在大多数情况下对消费者更有效。

yield关键字允许您在迭代器块上以窗体创建IEnumerable。这个迭代器块支持延迟执行，如果您不熟悉这个概念，它可能看起来很神奇。然而，在一天结束的时候，只是代码执行时没有任何奇怪的技巧。

迭代器块可以被描述为语法糖，在这里编译器生成一个状态机，跟踪枚举的进展情况。要枚举可枚举的，通常使用foreach循环。然而，foreach循环也是句法上的糖分。因此，您是从实际代码中删除的两个抽象，这就是为什么最初很难理解它是如何一起工作的。

假设您有一个非常简单的迭代器块：

1
2
3
4
5
6
7
8
9
10

IEnumerable<int> IteratorBlock()
{
Console.WriteLine("Begin");
yield return 1;
Console.WriteLine("After 1");
yield return 2;
Console.WriteLine("After 2");
yield return 42;
Console.WriteLine("End");
}

真正的迭代器块通常有条件和循环，但是当检查条件并展开循环时，它们最终仍然是与其他代码交错的yield语句。

要枚举迭代器块，使用foreach循环：

1 2	foreach (var i in IteratorBlock()) Console.WriteLine(i);

这里是输出(这里没有惊喜)：

1
2
3
4
5
6
7

Begin
1
After 1
2
After 2
42
End

如上所述，foreach是句法上的糖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

IEnumerator<int> enumerator = null;
try
{
enumerator = IteratorBlock().GetEnumerator();
while (enumerator.MoveNext())
{
var i = enumerator.Current;
Console.WriteLine(i);
}
}
finally
{
enumerator?.Dispose();
}

为了解开这个谜团，我用板条箱装了一个序列图，去掉了抽象部分：

C# iterator block sequence diagram

编译器生成的状态机也实现了枚举器，但为了使图表更清晰，我将它们作为单独的实例显示出来。(当从另一个线程枚举状态机时，您实际上会得到单独的实例，但这里的细节并不重要。)

每次调用迭代器块时，都会创建状态机的新实例。但是，在enumerator.MoveNext()第一次执行之前，迭代器块中的任何代码都不会执行。这就是延迟执行的工作方式。下面是一个(相当愚蠢的)例子：

1	var evenNumbers = IteratorBlock().Where(i => i%2 == 0);

此时迭代器尚未执行。Where条款创建了一个新的IEnumerable，它包装了IteratorBlock返回的IEnumerable，但这个可枚举的尚未枚举。当执行foreach循环时会发生这种情况：

1 2	foreach (var evenNumber in evenNumbers) Console.WriteLine(eventNumber);

如果枚举可枚举的两次，则每次都会创建状态机的新实例，并且迭代器块将执行相同的代码两次。

注意，像ToList()、ToArray()、First()、Count()等linq方法将使用foreach循环来枚举可枚举的。例如，ToList()将枚举可枚举的所有元素并将它们存储在一个列表中。现在可以访问该列表以获取可枚举的所有元素，而无需再次执行迭代器块。在使用ToList()等方法时，在使用CPU生成可枚举多次的元素和存储枚举多次访问的元素的内存之间存在权衡。

简单地说，c yield关键字允许对代码体(称为迭代器)进行多次调用，这些代码体知道如何在完成之前返回，当再次调用时，将在停止的位置继续执行，即，它有助于迭代器在迭代器在连续调用中返回的序列中对每个项透明地具有状态。

在JavaScript中，相同的概念称为生成器。

相关讨论

如果我正确理解这一点，下面将从实现IEnumerable和yield的函数的角度来描述这一点。

这里有一个。
如果您需要其他电话，请再次致电。
我会记得我给你的。
我只知道你再打电话时我能不能再给你一个。

这是为对象创建可枚举的非常简单和容易的方法。编译器创建一个类，该类包装您的方法，并在本例中实现IEnumerable