Comment implémenter IEnumerable <T>

Je sais comment implémenter le IEnumerable non générique, comme ceci:

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

Cependant, je remarque également que IEnumerable a une version générique IEnumerable<T>, mais je ne peux pas comprendre comment l'implémenter.

Si j'ajoute using System.Collections.Generic;à mes directives d'utilisation, puis que je change:

class MyObjects : IEnumerable

à:

class MyObjects : IEnumerable<MyObject>

Et puis faites un clic droit sur IEnumerable<MyObject>et sélectionnez Implement Interface => Implement Interface, Visual Studio ajoute utilement le bloc de code suivant:

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

Le retour de l'objet IEnumerable non générique à partir de la GetEnumerator();méthode ne fonctionne pas cette fois, alors que dois-je mettre ici? La CLI ignore maintenant l'implémentation non générique et se dirige directement vers la version générique lorsqu'elle essaie d'énumérer via mon tableau pendant la boucle foreach.

Si vous choisissez d'utiliser une collection générique, comme au List<MyObject>lieu de ArrayList, vous constaterez que le List<MyObject>fournira à la fois des énumérateurs génériques et non génériques que vous pouvez utiliser.

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

Vous ne voulez probablement pas une implémentation explicite de IEnumerable<T>(ce que vous avez montré).

Le modèle habituel est d'utiliser IEnumerable<T>des GetEnumeratordans l'implémentation explicite 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();
    }
}

Pourquoi le faites-vous manuellement? yield returnautomatise l'ensemble du processus de gestion des itérateurs. (J'ai également écrit à ce sujet sur mon blog , y compris un aperçu du code généré par le compilateur).

Si vous voulez vraiment le faire vous-même, vous devez également renvoyer un énumérateur générique. Vous ne pourrez plus en utiliser ArrayListcar ce n'est pas générique. Changez-le à la List<MyObject>place. Cela suppose bien sûr que vous n'avez que des objets de type MyObject(ou des types dérivés) dans votre collection.

Si vous travaillez avec des génériques, utilisez List au lieu de ArrayList. La liste a exactement la méthode GetEnumerator dont vous avez besoin.

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

faire mylist en a List<MyObject>, est une option

Notez que le IEnumerable<T>déjà implémenté par le System.Collectionsdonc une autre approche est de dériver votre MyObjectsclasse System.Collectionscomme classe de base ( documentation ):

System.Collections: fournit la classe de base pour une collection générique.

Nous pouvons faire plus tard notre propre implemenation de passer outre les virtuels System.Collectionsméthodes pour fournir un comportement personnalisé (uniquement pour ClearItems, InsertItem, RemoveItemet SetItemainsi Equals, GetHashCodeet ToStringde Object). Contrairement au List<T>qui n'est pas conçu pour être facilement extensible.

Exemple:

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

Veuillez noter que la conduite à partir de collectionrecommandé uniquement dans le cas où un comportement de collecte personnalisé est nécessaire, ce qui se produit rarement. voir l' utilisation .