¿Cómo puedo abandonar un IEnumerator sin iterar hasta el final?

Question

Considere el siguiente código, el primero demuestra que la "limpieza" se ejecuta cuando terminamos de iterar sobre el IEnumerable de cadenas. El segundo pase es lo que me está causando dolor. Necesito poder abandonar IEnumerable antes de llegar al final y luego ejecutar el código de limpieza. Pero si ejecuta esto, verá que en el segundo paso la limpieza nunca se dispara.

¿Cuál es la forma preferida de abandonar un IEnumerable como este?

static void Main(string[] args) 
{ 
    // first pass 
    foreach (String color in readColors()) 
     Console.WriteLine(color); 

    // second pass 
    IEnumerator<string> reader = readColors().GetEnumerator(); 
    if (reader.MoveNext()) 
    { 
     Console.WriteLine(reader.Current); 
     reader.Dispose(); 
    } 
} 
static IEnumerable<string> readColors() 
{ 
    string[] colors = { "red", "green", "blue" }; 
    for (int i = 0; i < colors.Length; i++) 
     yield return colors[i]; 

    Console.WriteLine("Cleanup goes here"); 
} 

Answer 1

Es necesario poner la parte principal de su método de iterador en un try..finally, con el código de limpieza en el último:

public IEnumerable<string> readColors() 
    { 
     try 
     { 
      string[] colors = { "red", "green", "blue" }; 
      for (int i = 0; i < colors.Length; i++) 
       yield return colors[i]; 
     } 
     finally 
     { 
      Console.WriteLine("Cleanup goes here"); 
     } 
    } 

Recuerde que bajo el capó un método iterador provoca una clase separada que ser creado, que implementa IEnumerable y IEnumerator. Al poner su limpieza en el bloque finally, termina en el método de clase generado 'Dispose.

[Editar : (como se ha señalado en otras respuestas) prefieren un comunicado using sobre su enfoque de llamar Dispose manualmente. Asumía que lo había hecho así solo para resaltar el tema en discusión, pero vale la pena señalar de todos modos]

Answer 2

Esa es una forma de abandonarlo. La razón por la que usted no está viendo

Cleanup goes here 

impresa en la consola se debe a que el bucle for (int i = 0; i < colors.Length; i++) nunca se ejecuta hasta el final. Vea a continuación cómo forzar la ejecución del código de limpieza.

Aquí hay otra manera. Este es el patrón preferido para usar objetos IDisposable en C#. Esto se prefiere porque esto hará que se llame a IEnumerator.Dispose incluso si se produce una excepción.

using (IEnumerator<string> reader = readColors().GetEnumerator()) { 
    reader.MoveNext(); 
    Console.WriteLine(reader.Current); 
} 

Como para forzar el código de limpieza tiene que ejecutar se puede hacer lo siguiente:

static IEnumerable<string> readColors() { 
    string[] colors = { "red", "green", "blue" }; 
    try { 
     for (int i = 0; i < colors.Length; i++) { 
      yield return colors[i]; 
     } 
    } 
    finally { 
     Console.WriteLine("Cleanup goes here"); 
    } 
} 

Answer 3

Creo que la forma preferida de hacer la limpieza es usando IDisposable. En este caso, será mejor que implemente su propio IEnumerable<string> con un IEnumerator<string> específico y utilizando el método Dispose normal. Usted obtiene disponer de gratis cuando usa foreach.

class MyEnumerator : IEnumerator<string> 
    { 
     // ... 
     #region IDisposable Members 

     public void Dispose() 
     { 
      // do your cleanup here 
      throw new NotImplementedException(); 
     } 

     #endregion 
     // ... 
    } 

Answer 4

try { 

    string[] colors = { "red", "green", "blue" }; 
    for (int i = 0; i < colors.Length; i++) { 
    if(condition == true) 
     break; 
    yield return colors[i]; 
    } 
} 
finally { 
    Console.WriteLine("Cleanup goes here"); 
}