The BitBull Blog

FooBar enumerator;
foreach( Foo foo in enumerator )
{
	// do some stuff
}

using System.Collections.Generic;
using System.Collections;

namespace com.bitbull
{
	public class FooEnumerator:IEnumerable,IEnumerator
	{
		#region properties
		private Foo[] foo=new Foo[24];
		private int count;
		#endregion

		public FooEnumerator()
		{
		}

		/*
		 * Called at the start of each foreach statement and it
		 * would appear this is the best place to initialize your 
		 * counter. Note that, unintuitively, I start on -1 rather
		 * than zero as MoveNext is called before the first object in
		 * the enumeration is retrieved
		 */
		public IEnumerator GetEnumerator()
		{
			count=-1;
			return this;
		}

		/*
		 * I'm not really sure why you need this here but 
		 * it won't compile without it
		 */
		IEnumerator IEnumerable.GetEnumerator()
		{
			return this.GetEnumerator();
		}

		/*
		 * Called each iteration of foreach BEFORE the current
		 * object is retrieved. Unintuitively this means that if
		 * you start your count on zero you will miss the first
		 * object in your enumeration.
		 * 
		 * Should return true or false depending on whether there
		 * are further objects available to iterate through
		 */
		public bool MoveNext()
		{
			if (count>=foo.Length)
			{
				return false;		
			}
			else
			{
				count++;
				return (count<foo.Length);
			}
		}

		/*
		 * I am not entirely sure when this gets called but you 
		 * need to implement it! It doesn't seem to get called at
		 * the start of each foreach statement which is what I 
		 * presumed would happen. I reset the counter here anyway
		 * as it seems the sensible thing to do but this method
		 * never seems to get called in my code.
		 */
		public void Reset()
		{
			count=-1;
		}

		/*
		 * Returns the current object in the enumeration
		 * called on each iteration of foreach
		 */
		public Foo Current
		{
			get { return foo[count]; }
		}

		/*
		 * I'm not really sure why you need this here but 
		 * it won't compile without it
		 */
		object IEnumerator.Current
		{
			get{ return this.Current; }
		}

		/*
		 * You need to implement this as well, again I'm not
		 * really sure why this is really necessary.
		 */
		public void Dispose()
		{
		}
	}

	public class Foo
	{
		public Foo()
		{
		}
	}
}