C＃中使用的yield关键字是什么？

#1 楼

yield关键字实际上在这里做了很多。

函数返回一个实现IEnumerable<object>接口的对象。如果调用函数开始对此对象进行调用，则会再次调用该函数，直到“屈服”为止。这是C＃2.0中引入的语法糖。在早期版本中，您必须创建自己的foreach和IEnumerable对象才能执行此类操作。

理解此类代码的最简单方法是键入示例，设置一些断点并查看会发生什么。尝试逐步执行以下示例：

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;
}

逐步执行示例时，将发现对IEnumerator的第一个调用返回Integers()。第二个调用返回1，并且行2不再执行。

这是一个真实的示例：

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);
                }
            }
        }
    }
}

@Brandin是因为所有编程语言都支持两种类型的关键字，即保留关键字和上下文关键字。 yield属于后面的类别，这就是为什么C＃编译器不禁止您的代码的原因。此处有更多详细信息：ericlippert.com/2009/05/11/reserved-and-contextual-keywords您会很高兴地知道，还有一些保留词未被语言识别为关键字。例如Java中的goto。此处有更多详细信息：stackoverflow.com/questions/2545103/…

– RBT
16年5月19日在0:27

“如果调用函数开始对此对象进行遍历，则该函数将再次被调用，直到它“屈服”为止。对我来说听起来不对。我总是在“农作物丰收”而不是“汽车向行人出产”的背景下想到c＃yield关键字。

–扎克
16年5月31日在15:28

#2 楼

迭代。它会在状态表下创建一个状态机，该状态机会记住您在该函数的每个其他循环中的位置，并从那里开始。

#3 楼

Yield有两个很好的用途，

它有助于提供自定义迭代而无需创建临时集合。
它有助于进行有状态迭代。

为了更生动地解释上述两点，我创建了一个简单的视频，您可以在这里观看

很棒的视频，但是很奇怪...使用yield的实现显然更干净，但是必须实质上是在内部创建自己的临时内存或/和List以便跟踪状态（或更确切地说是创建状态机）。那么，“ Yield”是否在做其他事情，而不是使实现更简单，使外观看起来更好，还是还有其他东西？效率如何，使用Yield运行代码比没有使用效率更高/更快？

– toughQuestions
3月19日15:10

#4 楼

最近，Raymond Chen也对yield关键字进行了一系列有趣的文章。

C＃中迭代器的实现及其结果（第1部分）
C＃中迭代器的实现及其后果（第2部分）
C＃中迭代器的实现及其结果（第3部分）
C＃中迭代器的实现及其后果（第4部分）

它通常用于轻松实现迭代器模式，但可以推广到状态机中。引用Raymond毫无意义，最后一部分也链接到其他用途（但是Entin博客中的示例特别好，显示了如何编写异步安全代码）。

#5 楼

乍一看，收益回报是返回IEnumerable的.NET糖。

没有收益，则立即创建集合的所有项目：

class SomeData
{
    public SomeData() { }

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

使用yield的代码相同，它逐项返回：

class SomeData
{
    public SomeData() { }

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

使用yield的优点是，如果使用数据的函数只需要第一个集合中的项目，其余项目将不会创建。

yield运算符允许根据需要创建项目。那是使用它的一个很好的理由。

#6 楼

yield return与枚举器一起使用。在yield语句的每次调用中，控制权都返回给调用者，但它可以确保保持被调用者的状态。因此，当调用方枚举下一个元素时，它将在yield语句之后立即在该语句的被调用方方法中继续执行。

让我们尝试通过一个示例来理解这一点。在此示例中，与每行相对应，我提到了执行流程的顺序。

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()方法，那么状态将被重置。

#7 楼

列表或数组实现立即加载所有项目，而yield实施提供了延迟执行解决方案。

实践中，通常需要根据需要执行最少的工作量，以减少操作量。应用程序的资源消耗。

例如，我们可能有一个应用程序可以处理数据库中的数百万条记录。在延迟执行基于拉的模型中使用IEnumerable时，可以实现以下好处：由于记录数量的增加，可伸缩性，可靠性和可预测性可能会提高不会显着影响应用程序的资源需求。

性能和响应性可能会提高，因为可以立即开始处理，而不是等待整个集合先加载。

由于可以停止，启动，中断或失败应用程序，因此利用率可能会提高。与仅实际使用一部分结果的预取所有数据相比，只有进行中的项目会丢失。

在添加恒定工作负载流的环境中，可以进行连续处理。

这里是先构建列表（如列表）与使用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：创建联系人1

ContactListStore：创建联系人2

ContactListStore：创建联系人3

准备遍历集合。

注意：整个集合已加载到内存中，甚至不需要列表中的单个项目。

良率示例

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：创建联系人1

Hello Bob

好！当客户从集合中“拉出”该项目时，仅构造了第一个联系人。

#8 楼

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

#9 楼

这是理解该概念的简单方法：
基本思想是，如果您想要可以使用“ foreach”的集合，但是由于某些原因将项目收集到集合中会很昂贵（例如查询它们）数据库），并且通常不需要整个集合，然后创建一个函数，一次生成一个集合，然后将其交还给使用者（后者可以尽早终止收集工作）。 >
这样想：您去肉店买一磅火腿片。屠夫将10磅重的火腿放回去，放在切片机上，切成薄片，然后将一堆薄片拿回来给你，并从中取出一磅。（旧方法）。
使用yield，屠夫将切片机带到柜台，开始切片，然后将每个切片“屈服”到秤上，直到测量到1磅重，然后将其包裹起来，您就可以完成。对于屠夫来说，旧方法可能更好（让他按照自己喜欢的方式组织机器），但对于大多数消费者而言，新方法显然更有效。

#10 楼

使用yield关键字，您可以在迭代器块上的形式创建IEnumerable<T>。该迭代器块支持延迟执行，如果您不熟悉该概念，可能看起来很神奇。但是，最终，只是代码执行而没有任何怪异的技巧。

迭代器块可以描述为语法糖，其中编译器生成状态机，该状态机可以跟踪枚举的枚举已进行。要枚举可枚举，通常使用foreach循环。但是，foreach循环也是语法糖。因此，您从真实代码中删除了两个抽象，这就是为什么最初可能很难理解它们如何协同工作的原因。
假设您有一个非常简单的迭代器块：

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循环：

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

这里是输出（在这里没有惊喜）：

Begin
1
After 1
2
After 2
42
End

如上所述，foreach是语法糖：

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

为了弄清这一点，我创建了一个删除了抽象的序列图：

编译器生成的状态机也实现了枚举器，但是为了使图更清楚，我将它们显示为单独的实例。（从另一个线程枚举状态机时，实际上确实得到了单独的实例，但是这里的细节并不重要。）

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

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

此时，迭代器尚未执行。 Where子句创建了一个新的IEnumerable<T>，它包装了IEnumerable<T>返回的IteratorBlock，但是此枚举尚未被枚举。执行foreach循环时会发生这种情况：

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

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

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

#11 楼

如果我正确理解这一点，那么从实现带有yield的IEnumerable的函数的角度来看，这就是我的措辞。

这里是一个。
如果需要另一个，请再次调用。
我会记住我已经给你的。
我只知道当你再次打电话时我能否再给你一个。

#12 楼

简而言之，C＃yield关键字允许多次调用代码体（称为迭代器），该代码体知道在完成之前如何返回，并在再次调用时从中断处继续执行-即，它有助于迭代器在迭代器连续调用返回的序列中，每个项目都变成透明状态。

在JavaScript中，相同的概念称为Generators。

#13 楼

这是为对象创建枚举的非常简单的方法。编译器将创建一个包装您的方法的类，并实现IEnumerable

编程黑洞网