Introduction
In this article, we will discuss about the IEnumerable
interface. We will discuss how IEnumerable
interface facilitates the use of foreach
statement to iterate through a set of data. We will then look at how to implement our own collections that implement IEnumerable
interface. The use of yield
keyword and Enumerating generic collections will also be discussed in this article.
Background
Whenever we work with collection of objects, we might find ourselves in need to iterate the collection. The best way to iterate through a collection is by implementing the Iterator pattern. (refer: Understanding and Implementing the Iterator Pattern in C# and C++[^]). C# provides a very clean construct of foreach
statement to iterate in a read only manner over a collection.
C# also provides us the possibility of using the same foreach
construct and all the enumeration techniques on our custom collection objects by implementing the IEnumerable
interface. So let us see how we can implement IEnumerable
interface with our custom collection classes.
Using the Code
Enumerating the Collection Classes
Before starting the discussion, let us see how we can use the Built-in classes and iterate over them. Let's start by looking into the ArrayList
class that implements IEnumerable
and see how we can have read only iteration over that using foreach
statement.
ArrayList list = new ArrayList();
list.Add("1");
list.Add(2);
list.Add("3");
list.Add('4');
foreach (object s in list)
{
Console.WriteLine(s);
}
Enumerating the Generic Collection Classes
The Arraylist
class is a generalized class that lets us keep a collection. We can also have a generic class in which we can provide the type along with the data. Iterating over generic collection classes is also possible because they implement IEnumerable<T>
interface. Let's see how we can enumerate over a generic collection.
List<string> listOfStrings = new List<string>();
listOfStrings.Add("one");
listOfStrings.Add("two");
listOfStrings.Add("three");
listOfStrings.Add("four");
foreach (string s in listOfStrings)
{
Console.WriteLine(s);
}
Now our objective is to have our own custom collection class and a generic collection class that should implement the IEnumerable
and IEnumerable<T>
interface respectively to provide the possibility of enumerating over them.
Understanding the Yield Keyword
Before jumping into the implementation of these classes, we need to understand a very important keyword yield
which actually facilitates the enumeration over collection. yield
statement is used while returning a value from a function.
A normal method call like the one shown below will return only the first value, no matter how many times it is called.
static int SimpleReturn()
{
return 1;
return 2;
return 3;
}
static void Main(string[] args)
{
Console.WriteLine(SimpleReturn());
Console.WriteLine(SimpleReturn());
Console.WriteLine(SimpleReturn());
Console.WriteLine(SimpleReturn());
}
The reason for this is that the normal return
statement does not preserve the state of the function while returning, i.e., every call to this function is a new call and it will return the first value only.
Whereas, if I replace the return keyword by yield
return
, then the function will become capable of saving its state while returning the value, i.e., when the function is called a second time, it will continue the processing from where it has returned in the previous call.
static IEnumerable<int> YieldReturn()
{
yield return 1;
yield return 2;
yield return 3;
}
static void Main(string[] args)
{
foreach (int i in YieldReturn())
{
Console.WriteLine(i);
}
}
When we run the above code, it will return 1, 2 and then 3. The only catch while using the yield
return statement is that the function should return an IEnumerable
and should be called from an iteration block, i.e., foreach
statement.
Implementing IEnumerable in Our Custom Collection Class
Now in our custom collection classes, if we define a function that will iterate over all the elements in the collection and return then using the yield
keyword, we will be able to get hold of all the elements in the collection.
So let us define our own MyArrayList
class and implement IEnumerable
interface, which will force us to implement the GetEnumerator
function. This function will iterate over the collection and do a yield
return on all the elements.
class MyArrayList : IEnumerable
{
object[] m_Items = null;
int freeIndex = 0;
public MyArrayList()
{
m_Items = new object[100];
}
public void Add(object item)
{
m_Items[freeIndex] = item;
freeIndex++;
}
public IEnumerator GetEnumerator()
{
foreach (object o in m_Items)
{
if(o == null)
{
break;
}
yield return o;
}
}
}
This class will now let us enumerate all the elements using a foreach
stemement.
static void Main(string[] args)
{
MyArrayList myList = new MyArrayList();
myList.Add("1");
myList.Add(2);
myList.Add("3");
myList.Add('4');
foreach (object s in myList)
{
Console.WriteLine(s);
}
}
Note: This class is neither complete nor a very good implementation. The only purpose of the sample implementation is to demonstrate the implementation of IEnumerable
interface.
Implementing IEnumerable<T> in Our Custom Generic Collection Class
Let us now take this approach a little further and define a generic collection class capable of being enumerated. To do this, we need to implement IEnumerable<T>
interface.
class MyList<T> : IEnumerable<T>
{
T[] m_Items = null;
int freeIndex = 0;
public MyList()
{
m_Items = new T[100];
}
public void Add(T item)
{
m_Items[freeIndex] = item;
freeIndex++;
}
#region IEnumerable<T> Members
public IEnumerator<T> GetEnumerator()
{
foreach (T t in m_Items)
{
if (t == null)
{
break;
}
yield return t;
}
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
#endregion
}
This class will now let us enumerate all the elements using a foreach
stemement.
static void Main(string[] args)
{
MyList<string> myListOfStrings = new MyList<string>();
myListOfStrings.Add("one");
myListOfStrings.Add("two");
myListOfStrings.Add("three");
myListOfStrings.Add("four");
foreach (string s in myListOfStrings)
{
Console.WriteLine(s);
}
}
So now we have a collection class and a generic collection class that implement IEnumerable
and IEnumerable<T>
respectively. Although these classes are neither complete nor a very good implementation, they do serve the purpose of the article, i.e., to demonstrate the implementation of IEnumerable
interface.
Point of Interest
What we have tried to do in this article is see how can we implement the IEnumerable
and IEnumberable<T>
interface. We have looked into the significance of yield
keyword. This stuff is known to most experienced C# programmers, but beginners might find it useful. I hope this has been informative.
History
- 11th October, 2012: First version