Skip to main content

The evolution of C# - Part III - C# 2.0 - Iterators

It's been a while since i wrote the last post, but i did not forget my purpose of creating a series that shows the evolution of C#. Today i came here to talk about one of the most useful features of C#, even if you dont know you're using it. Let's talk about iterators!

What is an iterator?
For those of you who didn't read about the iterator pattern somewhere in the internet or in the "Gang of Four" book, you can read a description here. The iterator is a class/object/whatever which knows how to traverse a structure. So, if you have a list or collection of objects, an iterator would have the knowledge of how to traverse that collection and access each element that it contains. The iterator is a well known design pattern and is behind many of the wonderful that we have nowadays in .NET (Linq comes to mind).

Why is it a feature?
Truth be told, an iterator is a concept well known way before .NET even existed. Being an OO Design Pattern, the iterator has been used everywhere. The iterator object typically has some methods by convention. To implement the iterator pattern in .NET 1.0 you needed to implement the IEnumerator interface. Then, in the class that needs to be traversed, you implement the IEnumerable interface which has a method that returns an instance of the enumerator. It's easier if we look at this example:

public class Box : IEnumerable
{
string[] itemNames;
public Box()
{
itemNames = new string[5];
itemNames[0] = "Clothes";
itemNames[1] = "Spoons";
itemNames[2] = "Toys";
itemNames[3] = "Tools";
itemNames[4] = "Plates";
}
public IEnumerator GetEnumerator()
{
return new BoxItemIterator(itemNames);
}
}
public class BoxItemIterator : IEnumerator
{
int CurrentPosition = -1;
string[] itemNames = null;
public BoxItemIterator(string[] ItemNames)
{
itemNames = ItemNames;
}
public bool MoveNext()
{
CurrentPosition++;
return (CurrentPosition < itemNames.Length);
}
public void Reset()
{
CurrentPosition = -1; //Sets the current position at the start of the collection
}
public object Current
{
get
{
return itemNames[CurrentPosition];
}
}
}
view raw gistfile1.txt hosted with ❤ by GitHub
In the example above we can see that the Box class implements IEnumerable and it's GetEnumerator method returns a new instance of the BoxItemEnumerator. BoxItemEnumerator implements the IEnumerator interface and receives the items in the constructor. This is the class that knows how to traverse the items in the box, and this way we can return as many iterators as we want through the GetEnumerator method. Also, this will allow us to do this:

Box b = new Box();
foreach (string item in b)
{
Console.WriteLine(item);
}
view raw gistfile1.cs hosted with ❤ by GitHub
Notice how we can use the Box instance in the foreach. Behind the scenes, the framework will call the MoveNext method and Current property of the BoxItemEnumerator instance in each iteration, convert it to string and put it in the item variable. This will of course print the names of the items.

So, where is the real improvement? We had this already!

The answer lies in the yield keyword. Now we can build an iterator without having to implement the IEnumerator class! Check the code below:

void Main()
{
Box b = new Box();
foreach (string item in b)
{
Console.WriteLine(item);
}
}
public class Box : IEnumerable
{
string[] itemNames;
public Box()
{
itemNames = new string[5];
itemNames[0] = "Clothes";
itemNames[1] = "Spoons";
itemNames[2] = "Toys";
itemNames[3] = "Tools";
itemNames[4] = "Plates";
}
public IEnumerator GetEnumerator()
{
foreach (string item in itemNames)
yield return item;
}
}
view raw gistfile1.cs hosted with ❤ by GitHub
The above snippet does exactly the same thing as the first, but notice how i didn't have to implement the IEnumerator interface to get the same result! This is a massive time saver if you had to implement all that plumbing code! But what does that yield do? Notice that each time the GetEnumerator method is executed, yield will save the state of the execution and will resume the method from there. You can try it out with the debugger and see that the method never really exits until the end of the foreach loop on the items, it just pauses. You can implement as many iterators as you want and then refer to them in client code by calling the method in the foreach loop.

To get out of the loop, you can use yield break in the GetEnumerator method and the loop will obviously end. You can also use an iterator in a get acessor of a property and have the same results. Note that the return type of an iterator method must be IEnumerable, IEnumerator, IEnumerable(of T) or IEnumerator(of T).

Whenever you think it will help you, use an iterator. I never really needed to implement an iterator, because most of the structures that i use already implement IEnumerable, but never say never!

Next time in Run or Debug we will take a look at yet another feature of .NET 2.0: Partial classes.

Comments

Popular posts from this blog

The repository's repository

Ever since I started delving into architecture,  and specifically service oriented architecture, there has been one matter where opinions get divided. Let me state the problem first, and then take a look at both sides of the barricade. Given that your service layer needs to access persistent storage, how do you model that layer? It is almost common knowledge what to do here: use the Repository design pattern. So we look at the pattern and decide that it seems simple enough! Let's implement the shit out of it! Now, let's say that you will use an ORM - here comes trouble. Specifically we're using EF, but we could be talking about NHibernate or really any other. The real divisive theme is this question: should you be using the repository pattern at all when you use an ORM? I'll flat out say it: I don't think you should... except with good reason. So, sharpen your swords, pray to your gods and come with me to fight this war... or maybe stay in the couch? ...

Follow up: improving the Result type from feedback

This post is a follow up on the previous post. It presents an approach on how to return values from a method. I got some great feedback both good and bad from other people, and with that I will present now the updated code taking that feedback into account. Here is the original: And the modified version: Following is some of the most important feedback which led to this. Make it an immutable struct This was a useful one. I can't say that I have ever found a problem with having the Result type as a class, but that is just a matter of scale. The point of this is that now we avoid allocating memory in high usage scenarios. This was a problem of scale, easily solvable. Return a tuple instead of using a dedicated Result type The initial implementation comes from a long time ago, when C# did not have (good) support for tuples and deconstruction wasn't heard of. You would have to deal with the Tuple type, which was a bit of a hassle. I feel it would complicate the ...

C# 2.0 - Partial Types

For those of you interested, i found a very interesting list of features that were introduced in C# in  here . This is a very complete list that contains all the features, and i'm explaining them one by one in this post series. We've talked about  Generics  and  Iterators . Now it's time for some partial types . A partial type  is a type which definition is spread across one or more files. It doesn't have to be in multiple separated files, but can be. This is a very simple concept that can give us many benefits, let's see: If a type is partial, multiple developers can work on every part of it. This allows a more organized way of working and can lead to production improvement.  Winforms , for example, generates a partial class for the form so that the client can separately edit other parts it. This way, a part contains information about the design and the other contains the logic of the form. In fact, this is a very spread pattern across .Net. Ent...