在如何只能暴露IList<>的一个片段问题中，其中一个答案有以下代码片段:
IEnumerable<object> FilteredList()
{
foreach(object item in FullList)
{
if(IsItemInPartialList(item))
yield return item;
}
}
yield关键字在这里做什么?我在一些地方看到过它，还有一个问题，但我还没搞清楚它到底是干什么的。我习惯于从一个线程屈服于另一个线程的意义上考虑屈服，但这在这里似乎无关紧要。
当前回答
如果我正确地理解了这一点，下面是我如何从函数实现IEnumerable的角度来表达这一点。
这是一个。 如果你需要另一个，请再打电话。 我会记得我给你的。 你下次打电话来的时候我才知道能不能再给你。
其他回答
迭代。它创建了一个“隐藏的”状态机，它会记住您在函数的每个额外循环中的位置，并从那里开始处理。
直观地，关键字从函数中返回一个值而不离开它，即在您的代码示例中，它返回当前项的值，然后继续循环。更正式地说，它被编译器用来为迭代器生成代码。迭代器是返回IEnumerable对象的函数。MSDN上有几篇关于它们的文章。
屈服有两大用处，
它有助于在不创建临时集合的情况下提供自定义迭代。 它有助于进行有状态迭代。
为了更清楚地解释以上两点，我制作了一个简单的视频，你可以在这里观看
列表或数组实现立即加载所有项，而yield实现提供了延迟执行的解决方案。
在实践中，为了减少应用程序的资源消耗，通常需要执行所需的最小工作量。
例如，我们可能有一个处理数据库中数百万条记录的应用程序。当我们在一个基于延迟执行的拉式模型中使用IEnumerable时，可以实现以下好处:
Scalability, reliability and predictability are likely to improve since the number of records does not significantly affect the application’s resource requirements. Performance and responsiveness are likely to improve since processing can start immediately instead of waiting for the entire collection to be loaded first. Recoverability and utilisation are likely to improve since the application can be stopped, started, interrupted or fail. Only the items in progress will be lost compared to pre-fetching all of the data where only using a portion of the results was actually used. Continuous processing is possible in environments where constant workload streams are added.
这里是先构建集合(如列表)与使用yield之间的比较。
列表的例子
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();
}
控制台输出 ContactListStore:创建联系人 ContactListStore:创建联系人 ContactListStore:正在创建联系人 准备遍历集合。
注意:整个集合被加载到内存中，甚至没有请求列表中的任何项
收益率的例子
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();
}
控制台输出 准备遍历集合。
注意:收集根本没有执行。这是由于IEnumerable的“延迟执行”特性。只有在真正需要时才会构造一个项。
让我们再次调用集合，并在取回集合中的第一个联系人时反转行为。
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();
}
控制台输出 准备遍历集合 ContactYieldStore:创建联系人 你好,鲍勃
好了!当客户端从集合中“拉出”项目时，只构造了第一个联系人。
关于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等。
