Jak zaimplementować IEnumerable <T>

Wiem, jak zaimplementować nieogólne IEnumerable, na przykład:

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

Jednak zauważam również, że IEnumerable ma wersję ogólną, IEnumerable<T> , ale nie mogę dowiedzieć się, jak ją zaimplementować.

Jeśli dodam using System.Collections.Generic;do moich dyrektyw using, a następnie zmienię:

class MyObjects : IEnumerable

do:

class MyObjects : IEnumerable<MyObject>

Następnie kliknij prawym przyciskiem myszy IEnumerable<MyObject>i wybierz Implement Interface => Implement Interface, Visual Studio z pomocą dodaje następujący blok kodu:

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

Zwracanie nieogólnego obiektu IEnumerable z GetEnumerator();metody nie działa tym razem, więc co mam tutaj umieścić? Interfejs CLI ignoruje teraz nieogólną implementację i kieruje się bezpośrednio do wersji ogólnej, gdy próbuje wyliczyć moją tablicę podczas pętli foreach.

Jeśli zdecydujesz się użyć kolekcji ogólnej, takiej jak List<MyObject>zamiast ArrayList, przekonasz się, że List<MyObject>będą one zawierać zarówno ogólne, jak i nieogólne moduły wyliczające, których możesz użyć.

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

Prawdopodobnie nie chcesz jawnej implementacji IEnumerable<T>(co pokazałeś).

Zazwyczaj wzór jest do użytku IEnumerable<T>„s GetEnumeratorw wyraźnej realizacji 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();
    }
}

Dlaczego robisz to ręcznie? yield returnautomatyzuje cały proces obsługi iteratorów. (Pisałem też o tym na swoim blogu , włączając w to spojrzenie na kod wygenerowany przez kompilator).

Jeśli naprawdę chcesz to zrobić sam, musisz również zwrócić ogólny moduł wyliczający. Nie będziesz już mógł używać ArrayListżadnego, ponieważ nie jest to typowe. List<MyObject>Zamiast tego zmień go na . To oczywiście zakłada, że MyObjectw swojej kolekcji masz tylko obiekty typu (lub typy pochodne).

Jeśli pracujesz z rodzajami, użyj listy zamiast ArrayList. Lista zawiera dokładnie taką metodę GetEnumerator, jakiej potrzebujesz.

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

zmienić mylist w a List<MyObject>, jest jedną z opcji

Zauważ, że IEnumerable<T>już zaimplementowane przez System.Collectionsto inne podejście polega na wyprowadzeniu Twojej MyObjectsklasy z System.Collectionsklasy bazowej ( dokumentacja ):

System.Collections: dostarcza klasę bazową dla kolekcji ogólnej.

Możemy później uczynić nasz własny implementacja zastąpić wirtualne System.Collectionsmetody zapewniające zachowanie niestandardowe (tylko ClearItems, InsertItem, RemoveItem, a SetItemwraz z Equals, GetHashCodei ToStringod Object). W przeciwieństwie do tego, List<T>który nie jest zaprojektowany tak, aby był łatwo rozszerzalny.

Przykład:

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!
}

Należy pamiętać, że jazda z collectionzalecana jest tylko w przypadku, gdy potrzebne jest niestandardowe zachowanie kolekcji, co rzadko się zdarza. zobacz użycie .