如果您选择使用泛型集合，例如List<MyObject>而不是ArrayList，您会发现List<MyObject>将提供您可以使用的泛型和非泛型枚举器。

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

您可能不需要IEnumerable<T>的 * 显式 * 实现（这就是您所展示的）。
通常的模式是在IEnumerable的显式实现中使用IEnumerable<T>的GetEnumerator：

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

为什么要手动操作？yield return自动化处理迭代器的整个过程。（我还写了关于它的on my blog，包括查看编译器生成的代码）。
如果你真的想自己做，你也必须返回一个泛型枚举数。您将不能再使用ArrayList，因为它是非泛型的。将其改为List<MyObject>。当然，这是假设集合中只有MyObject类型（或派生类型）的对象。

如果使用泛型，请使用List而不是ArrayList。List具有您需要的GetEnumerator方法。

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

将mylist转换为List<MyObject>是一种选择

请注意，IEnumerable<T>已经由System.Collections实现，所以另一种方法是从System.Collections派生MyObjects类作为基类（documentation）：
System.Collections:为泛型集合提供基类。
我们可以稍后进行自己的实现来覆盖虚拟System.Collections方法以提供自定义行为（仅适用于ClearItems、InsertItem、RemoveItem和SetItem沿着Equals、GetHashCode和ToString）。不像List<T>，它的设计不容易扩展。
示例：

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

请注意，仅在需要自定义收集行为的情况下，才建议从collection驱动，这种情况很少发生。参见usage。

.....不要忘记使用，如果你被阻止

IEnumerator IEnumerable.GetEnumerator()
    {
        // uses the strongly typed IEnumerable<T> implementation
        return GetEnumerator();
    }

添加此内容：

using System.Collections;

此外：

: IEnumerable<string>

这是一个很好的例子，因为它包含了IEnumerable：

public interface IEnumerable<out T> : IEnumerable

...还要注意enumrAble中的A和enumratOr中的o之间的语法笑话，这两个都在这个模式中使用！漂亮的危险线：

IEnumerator IEnumerable.GetEnumerator()