为什么使用 ExecutionAndPublication 的 Lazy<T> 与产生的 IEnumerables 的行为不同？

Question

我的代码中存在一个问题，即调用延迟初始化程序的频率超出了我的预期。从文档中，我预计使用 LazyThreadSafetyMode.ExecutionAndPublication 将确保我的初始化函数只被调用一次，例如，如果在定义后访问 numbers.Value：

numbers = new Lazy<IEnumerable<int>>(
        () => GetNumbers(),
        LazyThreadSafetyMode.ExecutionAndPublication
    );

但是，我发现如果初始化函数产生结果，初始化函数会被多次调用。我认为这与延迟执行有关，但我只有模糊的感觉。

问题：

在下面的代码中，为什么各个初始化函数的执行次数不同？

void Main()
{
    var foo         = new foo();
    var tasks       = new List<Task>();

    for (int i = 0; i < 10; ++i) tasks.Add(Task.Run(() => {foreach (var number in foo.Numbers) Debug.WriteLine(number);})); 
    Task.WaitAll(tasks.ToArray());
    tasks.Clear();
    for (int i = 0; i < 10; ++i) tasks.Add(Task.Run(() => {foreach (var letter in foo.Letters) Debug.WriteLine(letter);})); 
    Task.WaitAll(tasks.ToArray());
}

public class foo
{
    public IEnumerable<int> Numbers => numbers.Value;
    public IEnumerable<char> Letters => letters.Value;
    readonly Lazy<IEnumerable<int>> numbers;
    readonly Lazy<IEnumerable<char>> letters;

    public foo()
    {
        numbers = new Lazy<IEnumerable<int>>(
            () => GetNumbers(),
            LazyThreadSafetyMode.ExecutionAndPublication
        );
        letters = new Lazy<IEnumerable<char>>(
            () => GetLetters().ToList(), //ToList enumerates all yielded letters, creating the expected call once behavior
            LazyThreadSafetyMode.ExecutionAndPublication
        );
    }

    protected IEnumerable<char> GetLetters()
    {
        Debug.WriteLine($"{nameof(GetLetters)} Called");
        yield return 'a';
        yield return 'b';
        yield return 'c';
        yield break;
    }
    protected IEnumerable<int> GetNumbers()
    {
        Debug.WriteLine($"{nameof(GetNumbers)} Called");
        yield return 1;
        yield return 2;
        yield return 3;
        yield break;
    }
}

Answer 1

我的代码中有一个问题，即延迟初始化程序的调用频率比我预期的要高。

不，lazy 的初始化器被调用一次。懒惰的初始化器是

() => GetNumbers()

而且只调用一次。

GetNumbers 返回一个IEnumerable<int>——一个整数序列。

当你foreach那个序列时，它调用GetEnumerator来获取一个枚举器，然后在枚举器对象上调用MoveNext直到MoveNext返回false。

您说过您希望将序列枚举为：

the first time MoveNext is called, do a writeline and produce 1
the second time MoveNext is called, produce 2
the third time MoveNext is called, produce 3
the fourth time MoveNext is called, produce 4
Every subsequent time MoveNext is called, return false

所以每次枚举序列时，都会发生这种情况。

你能解释一下你预期会发生什么吗？我有兴趣了解为什么人们对计算机程序抱有错误的信念。

我也不清楚你为什么使用Lazy。您通常会使用Lazy 来避免在需要之前进行昂贵的工作，但序列已经推迟工作直到它们被枚举。