C#中yield关键字的作用是什么？

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

下面是输出结果（没有意外）：

开始
1
1后
2
2后
42
结束

如上所述，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>，该枚举包装了由 IteratorBlock 返回的 IEnumerable<T>，但是此可枚举对象尚未被枚举。当您执行 foreach 循环时，就会发生这种情况：

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

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

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

关于Yield关键字的一个重要点是延迟执行。现在我所说的延迟执行是指需要时才执行。更好的方式是通过举例来说明。

例如：不使用Yield，即没有延迟执行。

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等）中看到。

C# 的yield关键字，简单来说，允许多次调用一个名为迭代器的代码体，该迭代器知道如何在完成之前返回，并在再次调用时从上次离开的地方继续 - 也就是帮助迭代器透明地针对迭代器返回的每个序列项成为有状态的。

在JavaScript中，相同的概念被称为生成器（Generators）。

创建对象的可枚举性是一种非常简单易行的方法。编译器会创建一个类来包装您的方法，并实现IEnumerable<object>接口。如果没有使用yield关键字，您将需要创建一个实现IEnumerable<object>接口的对象。

它正在生成可枚举序列。它的实际作用是创建本地的可枚举序列并将其作为方法结果返回。

public static IEnumerable<int> testYieldb()
{
    for(int i=0;i<3;i++) yield return 4;
}

public static IEnumerable<int> testYieldb()
{
    yield return 4;
    console.WriteLine("abc");
    yield return 4;
}

static void Main(string[] args)
{
    testA();
    Console.Write("try again. the above won't execute any of the function!\n");

    foreach (var x in testA()) { }


    Console.ReadLine();
}



// static List<int> testA()
static IEnumerable<int> testA()
{
    Console.WriteLine("asdfa");
    yield return 1;
    Console.WriteLine("asdf");
}

using System;
using System.Collections.Generic;               
using System.Threading.Tasks;

public class Program
{
    public static async Task Main()
    {
        List<int> numbers = new List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        
        await foreach(int number in YieldReturnNumbers(numbers))
        {
            Console.WriteLine(number);
        }
    }
    
    public static async IAsyncEnumerable<int> YieldReturnNumbers(List<int> numbers) 
    {
        foreach (int number in numbers)
        {
            await Task.Delay(1000);
            yield return number;
        }
    }
}

理解yield的简单演示

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#似乎已经将yield与IEnumerable耦合在一起，以某种方式迫使您在调用者中编写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]; 
}