¿Cómo se implementa IEnumerable <T>

Question

Sé cómo implementar el IEnumerable no genérico, como esto:

using System; 
using System.Collections; 

namespace ConsoleApplication33 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      MyObjects myObjects = new MyObjects(); 
      myObjects[0] = new MyObject() { Foo = "Hello", Bar = 1 }; 
      myObjects[1] = new MyObject() { Foo = "World", Bar = 2 }; 

      foreach (MyObject x in myObjects) 
      { 
       Console.WriteLine(x.Foo); 
       Console.WriteLine(x.Bar); 
      } 

      Console.ReadLine(); 
     } 
    } 

    class MyObject 
    { 
     public string Foo { get; set; } 
     public int Bar { get; set; } 
    } 

    class MyObjects : IEnumerable 
    { 
     ArrayList mylist = new ArrayList(); 

     public MyObject this[int index] 
     { 
      get { return (MyObject)mylist[index]; } 
      set { mylist.Insert(index, value); } 
     } 

     IEnumerator IEnumerable.GetEnumerator() 
     { 
      return mylist.GetEnumerator(); 
     } 
    } 
} 

Sin embargo también noto que IEnumerable tiene una versión genérica, IEnumerable<T>, pero no puedo encontrar la manera para implementarlo.

Si añado using System.Collections.Generic; a mis utilizando directivas y, a continuación, cambiar:

class MyObjects : IEnumerable 

a:

class MyObjects : IEnumerable<MyObject> 

Y a continuación, haga clic derecho en IEnumerable<MyObject> y seleccione Implement Interface => Implement Interface, Visual Studio amablemente añade el siguiente bloque del código:

IEnumerator<MyObject> IEnumerable<MyObject>.GetEnumerator() 
{ 
    throw new NotImplementedException(); 
} 

Returni ng el objeto IEnumerable no genérico del método GetEnumerator(); no funciona esta vez, entonces ¿qué debo poner aquí? La CLI ahora ignora la implementación no genérica y se dirige directamente a la versión genérica cuando intenta enumerar a través de mi matriz durante el ciclo foreach.

Gracias

Answer 1

Si decide utilizar una colección genérica, como List<MyObject> en lugar de ArrayList, encontrará que la List<MyObject> proporcionará enumeradores genéricos y no genéricos que se pueden utilizar.

using System.Collections; 

class MyObjects : IEnumerable<MyObject> 
{ 
    List<MyObject> mylist = new List<MyObject>(); 

    public MyObject this[int index] 
    { 
     get { return mylist[index]; } 
     set { mylist.Insert(index, value); } 
    } 

    public IEnumerator<MyObject> GetEnumerator() 
    { 
     return mylist.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return this.GetEnumerator(); 
    } 
} 

Answer 2

¿Por qué lo haces manualmente? yield return automatiza todo el proceso de manejo de iteradores. (También escribí al respecto on my blog, incluido un vistazo al código generado por el compilador).

Si realmente desea hacerlo usted mismo, también debe devolver un enumerador genérico. Ya no podrá usar un ArrayList ya que no es genérico. Cámbielo a un List<MyObject> en su lugar. Por supuesto, eso supone que solo tiene objetos de tipo MyObject (o tipos derivados) en su colección.

Answer 3

maquillaje milista en un List<MyObject>, es una opción

Answer 4

Es probable que no quiere un explícita implementación de IEnumerable<T> (que es lo que has mostrado).

El patrón habitual es utilizar GetEnumerator IEnumerable<T> 's en la implementación explícita de IEnumerable:

class FooCollection : IEnumerable<Foo>, IEnumerable 
{ 
    SomeCollection<Foo> foos; 

    // Explicit for IEnumerable because weakly typed collections are Bad 
    System.Collections.IEnumerator IEnumerable.GetEnumerator() 
    { 
     // uses the strongly typed IEnumerable<T> implementation 
     return this.GetEnumerator(); 
    } 

    // Normal implementation for IEnumerable<T> 
    IEnumerator<Foo> GetEnumerator() 
    { 
     foreach (Foo foo in this.foos) 
     { 
      yield return foo; 
      //nb: if SomeCollection is not strongly-typed use a cast: 
      // yield return (Foo)foo; 
      // Or better yet, switch to an internal collection which is 
      // strongly-typed. Such as List<T> or T[], your choice. 
     } 

     // or, as pointed out: return this.foos.GetEnumerator(); 
    } 
} 

Answer 5

Si se trabaja con los genéricos, el uso de lista en lugar de ArrayList. La Lista tiene exactamente el método GetEnumerator que necesita.

List<MyObject> myList = new List<MyObject>();