c# - 悖论 : Why is yield return faster than list here

Question

人们已经无数次证明，yield return 比 list 慢。

示例:Is 'yield return' slower than "old school" return?

然而，当我尝试使用基准测试时，我得到了相反的结果:

Results:
TestYield: Time =1.19 sec
TestList : Time =4.22 sec

在这里，List 慢了 400%。无论大小，都会发生这种情况。这没有意义。

IEnumerable<int> CreateNumbers() //for yield
{
    for (int i = 0; i < Size; i++) yield return i;
}

IEnumerable<int> CreateNumbers() //for list
{
    var list = new List<int>();
    for (int i = 0; i < Size; i++) list.Add(i);
    return list;
}

我是这样吃的:

foreach (var value in CreateNumbers()) sum += value;

我使用所有正确的基准测试规则来避免结果冲突，所以这不是问题所在。

如果您查看底层代码，yield return 是一种令人厌恶的状态机，但速度更快。为什么？

编辑:复制的所有答案确实 Yield 比列表快。

New Results With Size set on constructor:
TestYield: Time =1.001
TestList: Time =1.403
From a 400% slower difference, down to 40% slower difference.

然而，这些见解令人心碎。这意味着所有 1960 年及以后使用 list 作为默认集合的程序员都是错误的，应该被枪毙(解雇)，因为他们没有使用适合这种情况的最佳工具(yield)。

答案认为 yield 应该更快，因为它没有实现。

1) 我不接受这种逻辑。 Yield 在幕后有内部逻辑，它不是一个“理论模型”，而是一个编译器构造。因此，它会在消耗时自动实现。我不接受它“没有实现”的论点，因为成本已经在 USE 上支付了。

2)如果船可以出海，而一个老太婆不能，你不能要求船“走陆路”。正如您在此处对列表所做的那样。如果一个列表需要物化，而 yield 不需要，那不是“yield 问题”，而是一个“特性”。产量不应该因为它有更多的用途而在测试中受到惩罚。

3) 我在这里争论的是，如果您知道 ENTIRE SET 将是消费。

yield 是否成为从方法返回列表参数的新“事实标准”。

Edit2:如果我使用纯内联数组，它获得与 Yield 相同的性能。

Test 3:
TestYield: Time =0.987
TestArray: Time =0.962
TestList: Time =1.516

int[] CreateNumbers()
{
    var list = new int[Size];
    for (int i = 0; i < Size; i++) list[i] = i;
    return list;
}

因此，yield 会自动内联到一个数组中。列表不是。

Answer 1

如果您在不具体化列表的情况下使用 yield 测量版本，它将比其他版本更具优势，因为它不必分配和调整大型列表的大小(以及触发 GC)。

根据您的修改，我想添加以下内容:

However, keep in mind that semantically you're looking at two different methods. One produces a collection. It is finite in size, you can store references to the collection, change its elements, and share it.

The other produces a sequence. It is potentially unbounded, you get a new copy each time you iterate over it, and there may or may not be a collection behind it.

They are not the same thing. The compiler doesn't create a collection to implement a sequence. If you implement a sequence by materializing a collection behind the scenes you will see similar performance as the version that uses a list.

默认情况下，BenchmarkDotNet 不允许您对延迟执行进行计时，因此您必须构建一个使用方法的测试，这就是我在下面所做的。我通过 BenchmarkDotNet 运行它并得到以下结果。

       Method |     Mean |    Error |   StdDev | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
------------- |---------:|---------:|---------:|------------:|------------:|------------:|--------------------:|
 ConsumeYield | 475.5 us | 7.010 us | 6.214 us |           - |           - |           - |                40 B |
  ConsumeList | 958.9 us | 7.271 us | 6.801 us |    285.1563 |    285.1563 |    285.1563 |           1049024 B |

注意分配。对于某些情况，这可能会有所作为。

我们可以通过分配正确的大小列表来抵消一些分配，但最终这不是同类比较。下面的数字。

       Method |     Mean |     Error |    StdDev | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
------------- |---------:|----------:|----------:|------------:|------------:|------------:|--------------------:|
 ConsumeYield | 470.8 us |  2.508 us |  2.346 us |           - |           - |           - |                40 B |
  ConsumeList | 836.2 us | 13.456 us | 12.587 us |    124.0234 |    124.0234 |    124.0234 |            400104 B |

代码如下。

[MemoryDiagnoser]
public class Test
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<Test>();
    }

    public int Size = 100000;

    [Benchmark]
    public int ConsumeYield()
    {
        var sum = 0;
        foreach (var x in CreateNumbersYield()) sum += x;
        return sum;
    }

    [Benchmark]
    public int ConsumeList()
    {
        var sum = 0;
        foreach (var x in CreateNumbersList()) sum += x;
        return sum;
    }

    public IEnumerable<int> CreateNumbersYield() //for yield
    {
        for (int i = 0; i < Size; i++) yield return i;
    }

    public IEnumerable<int> CreateNumbersList() //for list
    {
        var list = new List<int>();
        for (int i = 0; i < Size; i++) list.Add(i);
        return list;
    }
}