Question

Buenas, leyendo la documentación de la interfaz IEnumerable me encuentro con que en el código de ejemplo se hace esto:

// Implementation for the GetEnumerator method.
IEnumerator IEnumerable.GetEnumerator()
{
   return (IEnumerator) GetEnumerator();
}

public PeopleEnum GetEnumerator()
{
    return new PeopleEnum(_people);
}

Entiendo básicamente los usos de la implementación explicita de una interfaz (múltiples interfaces con el mismo nombre de método, ocultamiento de métodos, etc), lo que no comprendo es con qué fin se hace una EII si dentro de ésta se llama al método implícito, como lo veo diría que es redundante. He encontrado unas líneas parecidas en el libro Pro ASP.NET MVC 5.

namespace LanguageFeatures.Models {
    public class ShoppingCart : IEnumerable<Product> {
        public List<Product> Products { get; set; }
        public IEnumerator<Product> GetEnumerator() {
            return Products.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator() {
            return GetEnumerator();
        }
    }
}

No sé si sea algo propio del uso en conjunto de estas interfaces, pero no he podido encontrar más ejemplos. Tal vez sea solo una práctica o me estoy saltando algo.
¡Gracias!

Answer 1

Hola votagus,

Primero, aclararte que jamás escribí una línea de código en C#. Me animo a responderte porque hay involucrado un principio de la POO de por medio, y de eso sí entiendo bastante.

El uso de interfaces es un mecanismo más ligero que la herencia para definir protocolo y más flexible porque una clase pude implementar varias interfaces.

Dado que la interfaz solo define un protocolo, será tarea de la clase implementar el iterador como mejor le parezca a cada uno, siempre yu cuando por supuesto se implemente toda la interfaz declarada.

Es por esto que el iterador puede ser implementado luego con cualquier estructura que se pueda recorrer: vectores, listas, colecciones o incluso cosas más esotéricas como archivos en el disco, mensajes en la bandeja de GMail y un largo etc. Es decir, hay que implementar en la clase alguna estructura que implemente el iterador concreto.

Se mantiene así la idea de la POO de ocultación de la información: la cosa funciona independientemente de cómo se haya implementado el enumerador.

En el primer ejemplo es un PeopleEnum(), en el segundo es una lista List<Product> Products . Los ejemplos devuelven en getEnumerator() el iterador correspondiente.

Posiblemente tu confusión venga porque existe un "iterador" ya implementado en el framework que ya implemente internamente a la clase, y estés confundiendo a esta clase con la interfaz que implementa.

Espero haberte orientado un poco!