这个链接有一个简单的例子

这里还有更简单的例子

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

注意yield return不会从方法返回。你甚至可以在收益率后面加上一个WriteLine

上面生成了一个4个整数的IEnumerable (4,4,4,4)

这里有一个WriteLine。将向列表中添加4，打印abc，然后向列表中添加4，然后完成方法，从而真正从方法中返回(一旦方法完成，就像没有返回的过程一样)。但它会有一个值，一个IEnumerable int列表，它会在补全时返回。

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

还要注意，当使用yield时，返回的结果与函数的类型不同。它是IEnumerable列表中的元素类型。

将yield与方法的返回类型一起使用IEnumerable。如果方法的返回类型是int或List<int>并且使用yield，那么它将不会被编译。你可以在没有yield的情况下使用IEnumerable方法返回类型，但似乎你不能在没有IEnumerable方法返回类型的情况下使用yield。

为了让它执行，你必须用特殊的方式调用它。

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

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

它产生了可枚举的序列。它所做的实际上是创建本地IEnumerable序列，并将其作为方法结果返回

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>，它包装了IteratorBlock返回的IEnumerable<T>，但是这个可枚举对象还没有被枚举。这发生在你执行foreach循环时:

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

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

Notice that LINQ methods like ToList(), ToArray(), First(), Count() etc. will use a foreach loop to enumerate the enumerable. For instance ToList() will enumerate all elements of the enumerable and store them in a list. You can now access the list to get all elements of the enumerable without the iterator block executing again. There is a trade-off between using CPU to produce the elements of the enumerable multiple times and memory to store the elements of the enumeration to access them multiple times when using methods like ToList().

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

让我们通过一个例子来理解这一点。在这个例子中，对应于每一行，我已经提到了执行流的顺序。

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()方法有另一个调用，那么它的状态将被重置。

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

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

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