¿Por qué IEnumerator <T> hereda de IDisposable mientras que el IEnumerator no genérico no?

Question

Me di cuenta de que el genérico IEnumerator<T> hereda de IDisposable, pero la interfaz no genérica IEnumerator no lo hace. ¿Por qué está diseñado de esta manera?

Normalmente, utilizamos la instrucción foreach para pasar por una instancia IEnumerator<T>. El código generado de foreach en realidad tiene un bloque try-finally que invoca a Dispose() finalmente.

Answer 1

Básicamente fue un descuido. En C# 1.0, foreachnunca llamado Dispose . Con C# 1.2 (introducido en VS2003 - no hay 1.1, extrañamente) foreach comenzó a verificar en el bloque finally si el iterador implementó IDisposable - tenían que hacerlo de esa manera, porque retrospectivamente hacer IEnumerator ampliar IDisposable habría roto la implementación de todos IEnumerator. Si hubieran descubierto que es útil para el foreach deshacerse de los iteradores en primer lugar, estoy seguro de que IEnumerator habría extendido IDisposable.

Cuando aparecieron C# 2.0 y .NET 2.0, sin embargo, tuvieron una nueva oportunidad: nueva interfaz, nueva herencia. Tiene mucho más sentido que la interfaz extienda IDisposable para que no necesite una verificación en tiempo de ejecución en el bloque finally, y ahora el compilador sabe que si el iterador es IEnumerator<T> puede emitir una llamada incondicional al Dispose.

EDITAR: Es increíblemente útil llamar al Dispose al final de la iteración (como sea que termine).Significa que el iterador puede conservar los recursos, lo que hace que sea factible, por ejemplo, leer un archivo línea por línea. El iterador bloquea las implementaciones del generador Dispose que aseguran que cualquier bloque finally relevante para el "punto de ejecución actual" del iterador se ejecute cuando se elimine, de modo que pueda escribir código normal dentro del iterador y la limpieza se realice de forma adecuada.

---

Mirando hacia atrás en la especificación 1.0, que ya se ha especificado. Todavía no he podido verificar esta afirmación anterior de que la implementación 1.0 no llamó al Dispose.

Answer 2

IIRC Todo sobre tener IEnumerable<T> y IEnumerable es un resultado de IEnumerable anterior a la plantilla de .Net cosas. Sospecho que tu pregunta es de la misma manera.

Answer 3

¿IEnumerable` inherit IDisposing? De acuerdo con el reflector .NET o MSDN. ¿Estás seguro de que no lo estás confundiendo con IEnumerator? Eso usa IDisposing porque es solo para enumerar una colección y no para longevidad.

Answer 4

IEnumerable < T> no hereda IDisposable. IEnumerator < T> hereda IDisposable, mientras que el IEnumerator no genérico no lo hace. Incluso cuando usa foreach para un IEnumerable no genérico (que devuelve IEnumerator), el compilador generará una verificación para IDisposable y llamará a Dispose() si el enumerador implementa la interfaz.

supongo que el enumerador genérica < T> hereda de IDisposable por lo que no tiene que ser un tiempo de ejecución de tipo de salida que puede seguir adelante y llamar a Dispose() que debe tener un mejor rendimiento ya que puede ser probable que sea optimizado si el enumerador tiene un método Dispose() vacío.

Answer 5

Un poco difícil de ser definitivo en esto, a menos que logre obtener una respuesta del propio AndersH, o alguien cercano a él.

Sin embargo, mi conjetura es que se relaciona con la palabra clave "rendimiento" que se introdujo en C# al mismo tiempo. Si observa el código generado por el compilador cuando se usa "yield return x", verá el método envuelto en una clase auxiliar que implementa IEnumerator; al hacer que IEnumerator desciende de IDisposable, se asegura de que se pueda limpiar cuando se complete la enumeración.

Answer 6

Sé que esto es una vieja discusión pero reasontly escribí una biblioteca donde solía IEnumerable de T/T, donde IEnumerator de los usuarios de la biblioteca podrían implementar iteradores personalizados que sólo debe implementar IEnumerator de T.

encontré es muy extraño que IEnumerator of T herede de IDisposable. Implementamos IDisposable si queremos liberar recursos no manchados ¿no? Por lo tanto, solo sería relevante para los enumeradores que realmente tienen recursos no administrados, como una secuencia IO, etc. ¿Por qué no solo permite que los usuarios implementen tanto IEnumerator of T como IDisposable en su enumerador si tiene sentido? En mi libro, esto viola el principio de responsabilidad única: por qué mezclar la lógica del enumerador y eliminar los objetos.