在如何只能暴露IList<>的一个片段问题中，其中一个答案有以下代码片段:
IEnumerable<object> FilteredList()
{
foreach(object item in FullList)
{
if(IsItemInPartialList(item))
yield return item;
}
}
yield关键字在这里做什么?我在一些地方看到过它，还有一个问题，但我还没搞清楚它到底是干什么的。我习惯于从一个线程屈服于另一个线程的意义上考虑屈服，但这在这里似乎无关紧要。
当前回答
关于Yield关键字的一个主要观点是惰性执行。现在我所说的惰性执行是指在需要时执行。更好的表达方式是举个例子
示例:不使用Yield，即没有Lazy Execution。
public static IEnumerable<int> CreateCollectionWithList()
{
var list = new List<int>();
list.Add(10);
list.Add(0);
list.Add(1);
list.Add(2);
list.Add(20);
return list;
}
示例:使用Yield，即惰性执行。
public static IEnumerable<int> CreateCollectionWithYield()
{
yield return 10;
for (int i = 0; i < 3; i++)
{
yield return i;
}
yield return 20;
}
当我调用两个方法时。
var listItems = CreateCollectionWithList();
var yieldedItems = CreateCollectionWithYield();
你会注意到listItems里面有5个项目(调试时将鼠标悬停在listItems上)。 而yieldItems将只有一个对方法的引用，而不是对项目的引用。 这意味着它没有在方法中执行获取项的过程。一种只在需要时获取数据的非常有效的方法。 yield的实际实现可以在ORM中看到，如Entity Framework和NHibernate等。
其他回答
屈服有两大用处，
它有助于在不创建临时集合的情况下提供自定义迭代。 它有助于进行有状态迭代。
为了更清楚地解释以上两点，我制作了一个简单的视频，你可以在这里观看
简单的演示，了解产量
using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApp_demo_yield {
class Program
{
static void Main(string[] args)
{
var letters = new List<string>() { "a1", "b1", "c2", "d2" };
// Not yield
var test1 = GetNotYield(letters);
foreach (var t in test1)
{
Console.WriteLine(t);
}
// yield
var test2 = GetWithYield(letters).ToList();
foreach (var t in test2)
{
Console.WriteLine(t);
}
Console.ReadKey();
}
private static IList<string> GetNotYield(IList<string> list)
{
var temp = new List<string>();
foreach(var x in list)
{
if (x.Contains("2")) {
temp.Add(x);
}
}
return temp;
}
private static IEnumerable<string> GetWithYield(IList<string> list)
{
foreach (var x in list)
{
if (x.Contains("2"))
{
yield return x;
}
}
}
}
}
它试图带来一些Ruby的善良:) 概念:这是一些示例Ruby代码，打印出数组的每个元素
rubyArray = [1,2,3,4,5,6,7,8,9,10]
rubyArray.each{|x|
puts x # do whatever with x
}
数组的每个方法实现将控制权移交给调用者('puts x')，数组的每个元素都整齐地表示为x。然后调用者可以对x做任何需要做的事情。
然而。net并没有完全做到这一点。c#似乎已经与IEnumerable耦合了yield，在某种程度上迫使你在调用者中写一个foreach循环，就像Mendelt的响应中看到的那样。没有那么优雅。
//calling code
foreach(int i in obCustomClass.Each())
{
Console.WriteLine(i.ToString());
}
// CustomClass implementation
private int[] data = {1,2,3,4,5,6,7,8,9,10};
public IEnumerable<int> Each()
{
for(int iLooper=0; iLooper<data.Length; ++iLooper)
yield return data[iLooper];
}
它产生了可枚举的序列。它所做的实际上是创建本地IEnumerable序列，并将其作为方法结果返回
直观地，关键字从函数中返回一个值而不离开它，即在您的代码示例中，它返回当前项的值，然后继续循环。更正式地说，它被编译器用来为迭代器生成代码。迭代器是返回IEnumerable对象的函数。MSDN上有几篇关于它们的文章。
