How to use the IEnumerable/IEnumerator interfaces






2.96/5 (8 votes)
This article describes how to work with the IEnumerable/IEnumerator interface for collection types.
Introduction
IEnumerable
is an interface implemented by the System.Collecetion
type in .NET that provides
the Iterator pattern. The definition according to MSDN is:
“Exposes the enumerator, which supports simple iteration over non-generic collections.”
It’s something that you can loop over. That might be a List
or Array
or anything else that supports a foreach
loop.
IEnumerator
allows you to iterate over List
or Array
and process each element one by one.
Objective
Explore the usage of IEnumerable
and IEnumerator
for a user defined class.
Using the code
Let’s first show how both IEnumerable
and IEnumerator
work: Let’s define a List
of string
s and iterate
each element using the iterator pattern.
// This is a collection that eventually we will use an Enumertor to loop through
// rather than a typical index number if we used a for loop.
string[] Continents = new string[] { "Asia", "Europe", "Africa", "North America", "South America", "Australia", "Antartica" };
Now we already knows how to iterate each element using a foreach
loop:
// Here is where loop iterate over each item of collection
foreach(string continent in Continents)
{
Console.WriteLine(continent);
}
The same can be done with the IEnumerator
object.
// HERE is where the Enumerator is gotten from the List object
IEnumerator enumerator = Continents.GetEnumerator()
while(enumerator.MoveNext())
{
string continent = Convert.ToString(enumerator.Current);
Console.WriteLine(continent);
}
Points of Interest
That's the first advantage: if your methods accept an IEnumerable
rather than an Array
or List
, they become more powerful
because you can pass different kinds of objects to them.
The second and most important advantage over List
and Array
is, unlike List
and Array
, an iterator block holds
a single item in memory, so if you are reading the result from a large SQL query, you can limit your memory use to a single record. Moreover this evaluation is lazy.
So if you're doing a complicated work to evaluate the enumerable as you read from it, the work doesn't happen until it's asked for.