枚举器和函数范围

Question

为什么Enumerator 不跟踪同一函数中的项目，但如果MoveNext 操作发生在其他函数中，则不跟踪？

例子：

    public static void Test()
    {
        var array = new List<Int32>(new Int32[] { 1, 2, 3, 4, 5 });
        var e = array.GetEnumerator();
        e.MoveNext();
        e.MoveNext();
        Console.WriteLine(e.Current); // 2
        Incremenet(e);
        Console.WriteLine(e.Current); //2
    }

    static void Incremenet(IEnumerator<Int32> e)
    {
        Console.WriteLine("Inside " + e.Current); //2
        e.MoveNext();
        Console.WriteLine("Inside " + e.Current); // 3
        e.MoveNext();
        Console.WriteLine("Inside " + e.Current); //4
    }

我原本希望在最后一个 CW 中获得 5，但我获得了 2，就像它从未增加过一样。为什么函数返回时忘记了Increment函数里面的MoveNext？

干杯。

Answer 1

List<T> 的枚举类型List<T>.Enumerator 不是class，而是struct。由于GetEnumerator暴露了返回类型是List<T>.Enumerator，所以当你使用var时，e的类型是List<T>.Enumerator，所以当你将它传递给Incremenet时，它会自动成为boxed IEnumerator<Int32> 对象。这就是您看到的奇怪行为的原因。

如果您将e 键入为IEnumerator<Int32>，则在您获得对象后立即发生装箱，因此不会发生这种奇怪的行为：无论您在Test 中运行其他代码还是在Increment（我修正了那个方法的拼写，顺便说一下，它不是“Incremenet”）。

public static void Test()
{
    var array = new List<Int32> { 1, 2, 3, 4, 5 };
    IEnumerator<Int32> e = array.GetEnumerator(); // boxed here
    e.MoveNext();
    e.MoveNext();
    Console.WriteLine(e.Current); // 2
    Increment(e);
    Console.WriteLine(e.Current); // now it's 4
}

static void Increment(IEnumerator<Int32> e)
{
    Console.WriteLine("Inside " + e.Current); // 2
    e.MoveNext();
    Console.WriteLine("Inside " + e.Current); // 3
    e.MoveNext();
    Console.WriteLine("Inside " + e.Current); // 4
}

出于性能原因，它被公开为它的类型而不是IEnumerator<T>。 foreach is smart enough 在这种情况下调用 MoveNext 和 Current 无需装箱或虚拟分派，并且可以毫无问题地处理值类型语义。正如你所看到的，当你没有特别注意如何处理它时，它确实会引起混乱，因为mutable structs are evil。

Answer 2

出于同样的原因，test 在以下测试用例中递增后为 1。这是值类型的正常行为。

    static void Main(string[] args)
    {
        int test = 1;
        Increment(test);
        Console.WriteLine("After increment: " + test);
    }

    static void Increment(int test)//add ref and the original variable will also update
    {
        test += 1;
        Console.WriteLine(test);
    }

正如 Servy 从技术上指出的那样，该示例的不同之处在于局部变量 test 是不可变的。实际上，我们看到的行为是因为变量被复制到了Increment 方法。但是，我的观点是，这种类型的行为在值类型（属性和局部变量）之间是一致的。有关这一事实的进一步证据：

struct MutableStruct
{
    public int EvilInt { get; set; }    
}

class Program
{        
    static void Main(string[] args)
    {
        var testStruct = new MutableStruct();
        testStruct.EvilInt = 1;

        int test = 1;
        Increment(test, testStruct);
        Console.WriteLine("After increment: " + test + " and..." + testStruct.EvilInt);//both 1
    }

    static void Increment(int test, MutableStruct test2)
    {
        test2.EvilInt += 1;
        test += 1;
        Console.WriteLine(test + " and..." + test2.EvilInt);//both 2
    }
}

正如我们在这里看到的，这种行为在值类型中是正常的。在局部不可变值类型和可变结构的情况下，行为保持一致。