悖论：为什么收益率回报比这里列出的更快

Question

人们已经无数次证明，那yield return比list.但是，当我尝试基准测试时，得到了相反的结果：Results:TestYield: Time =1.19 secTestList : 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它是一个状态机可憎，但它更快。为什么？编辑：所有答案都被复制，确实产量比列表快。New Results With Size set on constructor:TestYield: Time =1.001TestList: Time =1.403From a 400% slower difference, down to 40% slower difference.然而，这些见解令人心碎。这意味着所有那些从 1960 年起使用 list 作为默认集合的程序员都是错误的，应该被解雇（解雇），因为他们没有使用最好的工具来解决这种情况（yield）。答案认为，收益率应该更快，因为它没有实现。1）我不接受这个逻辑。Yield 背后有内部逻辑，它不是“理论模型”，而是编译器构造。因此，它会在消费时自动实现。我不接受它“没有实现”的论点，因为成本已经在使用时支付。2）如果船可以走海路，而老妇人不行，你不能要求船“走陆路”。正如你在这里对列表所做的那样。如果一个列表需要具体化，而 yield 不需要，那不是“产量问题”，而是一个“特性”。不应仅仅因为它有更多用途而在测试中惩罚产量。3）我在这里争论的是，如果您知道整个 SET将被消耗，那么测试的目的是找到“最快的集合”来消耗/返回方法返回的结果。yield 是否成为从方法返回列表参数的新“事实上的标准”。Edit2：如果我使用纯内联数组，它会获得与 Yield 相同的性能。Test 3:TestYield: Time =0.987TestArray: Time =0.962TestList: Time =1.516int[] CreateNumbers(){    var list = new int[Size];    for (int i = 0; i < Size; i++) list[i] = i;    return list;}因此，yield 会自动内联到数组中。列表不是。

Answer 1

如果您使用产量测量版本而不具体化列表，它将比其他版本具有优势，因为它不必分配和调整大列表的大小（以及触发 GC）。

根据您的编辑，我想添加以下内容：

但是，请记住，从语义上讲，您正在查看两种不同的方法。一个产生一个集合。它的大小是有限的，您可以存储对集合的引用、更改其元素并共享它。

另一个产生一个序列。它可能是无限的，每次迭代它都会得到一个新副本，并且它后面可能有也可能没有集合。

它们不是同一件事。编译器不会创建集合来实现序列。如果您通过在幕后实现集合来实现序列，您将看到与使用列表的版本相似的性能。

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;

    }

}

Answer 2

您必须考虑以下几点：

• List<T>消耗内存，但您可以一次又一次地迭代它而无需任何额外资源。为了达到同样的效果yield，您需要通过 实现序列ToList()。

• 生产时最好设置容量List<T>。这将避免内部数组调整大小。

这是我所拥有的：

class Program

{

    static void Main(string[] args)

    {

        // warming up

        CreateNumbersYield(1);

        CreateNumbersList(1, true);

        Measure(null, () => { });

        // testing

        var size = 1000000;

        Measure("Yield", () => CreateNumbersYield(size));

        Measure("Yield + ToList", () => CreateNumbersYield(size).ToList());

        Measure("List", () => CreateNumbersList(size, false));

        Measure("List + Set initial capacity", () => CreateNumbersList(size, true));

        Console.ReadLine();

    }

    static void Measure(string testName, Action action)

    {

        var sw = new Stopwatch();

        sw.Start();

        action();

        sw.Stop();

        Console.WriteLine($"{testName} completed in {sw.Elapsed}");

    }

    static IEnumerable<int> CreateNumbersYield(int size) //for yield

    {

        for (int i = 0; i < size; i++)

        {

            yield return i;

        }

    }

    static IEnumerable<int> CreateNumbersList(int size, bool setInitialCapacity) //for list

    {

        var list = setInitialCapacity ? new List<int>(size) : new List<int>();

        for (int i = 0; i < size; i++)

        {

            list.Add(i);

        }

        return list;

    }

}

结果（发布版本）：

Yield completed in 00:00:00.0001683

Yield + ToList completed in 00:00:00.0121015

List completed in 00:00:00.0060071

List + Set initial capacity completed in 00:00:00.0033668

如果我们比较可比较的情况（Yield + ToList& List + Set initial capacity），yield速度要慢得多。