Enumerador como argumento

Question

De acuerdo, vamos a empezar con este botón muy simple, haga clic en Método

    private void button1_Click(object sender, EventArgs e)
    {
        int counter = 1;
        List<int> items = new int[] { 1, 2, 3 }.ToList();
        List<int>.Enumerator enm = items.GetEnumerator();

        // 1
        if (!enm.MoveNext())
            throw new Exception("Unexpected end of list");
        if (enm.Current != counter)
            throw new Exception(String.Format("Expect {0} but actual {1}", counter, enm.Current));
        counter++;

        // 2
        if (!enm.MoveNext()) 
            throw new Exception("Unexpected end of list");
        if (enm.Current != counter) 
            throw new Exception(String.Format("Expect {0} but actual {1}", counter, enm.Current));
        counter++;

        //3
        if (!enm.MoveNext())
            throw new Exception("Unexpected end of list");
        if (enm.Current != counter)
            throw new Exception(String.Format("Expect {0} but actual {1}", counter, enm.Current));
        counter++;

        if (enm.MoveNext()) 
            throw new Exception("Unexpected continuation of list");
    }

Este método no hace nada porque cada afirmación pasa con gracia.Las cosas están bien hasta que creo que debo introducir un método para eliminar la redundancia

    static void AssertNext(ref int counter, List<int>.Enumerator e)
    {
        if (!e.MoveNext()) 
            throw new Exception("Unexpected end of list");
        if (e.Current != counter) 
            throw new Exception(String.Format("Expect {0} but actual {1}", counter, e.Current));
        counter++;
    }

    private void button2_Click(object sender, EventArgs e)
    {
        var counter = 1;
        var items = new int[] { 1, 2, 3 }.ToList();
        var enm = items.GetEnumerator();
        AssertNext(ref counter, enm);
        AssertNext(ref counter, enm);
        AssertNext(ref counter, enm);
        if (enm.MoveNext()) throw new Exception("Unexpected continuation of list");
    }

Aunque esta refactorización es sencilla (para mí, al menos).¡Borra el programa! En la segunda llamada a AssertNext, parece que el enumerador ya se restableció al punto de inicio y hace que la afirmación falle.

No puedo entender qué sucede.Realmente me siento como un principiante con este rompecabezas.

¿Qué extraño aquí?

Answer 1

Estoy imaginando que tiene algo que ver con la lista. Siendo una estructura.Lo estás pasando a un método, manipulándolo y luego regresa.La manipulación probablemente no sucederá para su instancia original.

Answer 2

List<T>.Enumerator es un tipo de valor que significa que se copia en el alcance local de su método, alterado y luego destruido al abandonar el método.Intenta pasarlo por referencia también.