Implementing enumerators manually is painful.

gistfile1.txt

public class DemonstrationList<T> : IEnumerable<T>
{
    private const int defaultCapacity = 10;
    private T[] items = new T[defaultCapacity];
    private int count = 0;

    public void Add(T item)
    {
        if (count == items.Length)
        {
            Array.Resize(ref items, defaultCapacity * 2);
        }

        items[count++] = item;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new Enumerator<T>(this);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    private class Enumerator<T> : IEnumerator<T>
    {
        private readonly DemonstrationList<T> _parent;
        private int _index = 0;

        object IEnumerator.Current
        {
            get { return Current; }
        }

        public T Current
        {
            get { return _parent.items[_index++]; }
        }

        public Enumerator(DemonstrationList<T> parent)
        {
            _parent = parent;
        }

        public bool MoveNext()
        {
            return _index < _parent.count;
        }

        public void Reset()
        {
            throw new NotImplementedException();
        }

        public void Dispose()
        {
        }
    }
}