Come implementare IEnumerable <T>

So come implementare l'IEnumerable non generico, in questo modo:

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();
        }
    }
}

Tuttavia noto anche che IEnumerable ha una versione generica IEnumerable<T>, ma non riesco a capire come implementarla.

Se aggiungo using System.Collections.Generic;alle mie direttive using e poi cambio:

class MyObjects : IEnumerable

per:

class MyObjects : IEnumerable<MyObject>

Quindi fare clic con il pulsante destro del mouse IEnumerable<MyObject>e selezionare Implement Interface => Implement Interface, Visual Studio aggiunge utilmente il seguente blocco di codice:

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

Restituire l'oggetto IEnumerable non generico dal GetEnumerator();metodo non funziona questa volta, quindi cosa metto qui? La CLI ora ignora l'implementazione non generica e si dirige direttamente alla versione generica quando tenta di enumerare il mio array durante il ciclo foreach.

Se scegli di utilizzare una raccolta generica, ad esempio List<MyObject>invece di ArrayList, scoprirai che List<MyObject>fornirà enumeratori generici e non generici che puoi utilizzare.

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();
    }
}

Probabilmente non vuoi un'implementazione esplicita di IEnumerable<T>(che è ciò che hai mostrato).

Lo schema usuale è usare IEnumerable<T>'s GetEnumeratornell'esplicita implementazione di 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();
    }
}

Perché lo fai manualmente? yield returnautomatizza l'intero processo di gestione degli iteratori. (Ne ho anche scritto sul mio blog , incluso uno sguardo al codice generato dal compilatore).

Se vuoi davvero farlo da solo, devi restituire anche un enumeratore generico. Non potrai più utilizzarne uno ArrayListpoiché non è generico. Cambialo in un List<MyObject>invece. Ciò ovviamente presuppone che MyObjectnella tua raccolta siano presenti solo oggetti di tipo (o tipi derivati).

Se lavori con i generici, usa List invece di ArrayList. La lista ha esattamente il metodo GetEnumerator di cui hai bisogno.

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

trasforma la mia lista in una List<MyObject>, è un'opzione

Nota che il IEnumerable<T>già implementato da System.Collectionsquindi un altro approccio è derivare la tua MyObjectsclasse da System.Collectionsuna classe base ( documentazione ):

System.Collections: fornisce la classe base per una raccolta generica.

Dopo possiamo fare la nostra implemenation per sovrascrivere il virtuali System.Collectionsmetodi per fornire un comportamento personalizzato (solo per ClearItems, InsertItem, RemoveItem, e SetIteminsieme Equals, GetHashCodee ToStringda Object). A differenza del List<T>quale non è progettato per essere facilmente estensibile.

Esempio:

public class FooCollection : System.Collections<Foo>
{
    //...
    protected override void InsertItem(int index, Foo newItem)
    {
        base.InsertItem(index, newItem);     
        Console.Write("An item was successfully inserted to MyCollection!");
    }
}

public static void Main()
{
    FooCollection fooCollection = new FooCollection();
    fooCollection.Add(new Foo()); //OUTPUT: An item was successfully inserted to FooCollection!
}

Si noti che la guida da è collectionconsigliata solo nel caso in cui sia necessario un comportamento di raccolta personalizzato, cosa che accade raramente. vedi utilizzo .