Como faço para implementar IEnumerable <T>

Eu sei como implementar o IEnumerable não genérico, assim:

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

No entanto, também notei que o IEnumerable tem uma versão genérica IEnumerable<T>, mas não consigo descobrir como implementá-lo.

Se eu adicionar using System.Collections.Generic;ao meu uso diretivas, e depois alterar:

class MyObjects : IEnumerable

para:

class MyObjects : IEnumerable<MyObject>

E, em seguida, clique com o botão direito do mouse IEnumerable<MyObject>e selecione Implement Interface => Implement Interface, o Visual Studio adiciona o seguinte bloco de código:

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

Retornar o objeto IEnumerable não genérico do GetEnumerator();método não funciona desta vez, então o que devo colocar aqui? A CLI agora ignora a implementação não genérica e segue diretamente para a versão genérica quando tenta enumerar minha matriz durante o loop foreach.

Se você optar por usar uma coleção genérica, como em List<MyObject>vez de ArrayList, verá que List<MyObject>ele fornecerá enumeradores genéricos e não genéricos que você pode usar.

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

Você provavelmente não deseja uma implementação explícita de IEnumerable<T>(que é o que você mostrou).

O padrão usual é usar IEnumerable<T>'s' GetEnumeratorna implementação 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();
    }
}

Por que você faz isso manualmente? yield returnautomatiza todo o processo de manipulação de iteradores. (Eu também escrevi sobre isso no meu blog , incluindo uma olhada no código gerado pelo compilador).

Se você realmente deseja fazer isso sozinho, também precisará retornar um enumerador genérico. Você não poderá mais usar um, ArrayListuma vez que não é genérico. Altere para um em List<MyObject>vez disso. Obviamente, isso pressupõe que você tenha apenas objetos do tipo MyObject(ou tipos derivados) em sua coleção.

Se você trabalha com genéricos, use Lista em vez de ArrayList. A lista possui exatamente o método GetEnumerator que você precisa.

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

transformar minha lista em uma List<MyObject>é uma opção

Observe que o IEnumerable<T>método já implementado pela System.Collectionsoutra abordagem é derivar sua MyObjectsclasse System.Collectionscomo uma classe base ( documentação ):

System.Collections: fornece a classe base para uma coleção genérica.

Mais tarde, pode fazer nossa própria implemenation para substituir as virtuais System.Collectionsmétodos para fornecer o comportamento personalizado (apenas para ClearItems, InsertItem, RemoveIteme, SetItemjuntamente com Equals, GetHashCodee, ToStringa partir Object). Ao contrário do List<T>que não foi projetado para ser facilmente extensível.

Exemplo:

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

Observe que a orientação é collectionapenas recomendada caso seja necessário um comportamento de coleção personalizado, o que raramente acontece. veja o uso .