Most of the Object Oriented Languages nowadays supports this pattern through their core language infrastructure.
Challenge
You are working on a Name printing application. You have to deal with a Bank
class with the following properties.
public
class
Bank
{
public string
ManagerName
{
get;
set;
}
public string
AccountantName
{
get;
set;
}
public string
CashierName
{
get;
set;
}
}
For printing the name the Print() method is called as following:
Print(_bank.Manager);
Print(_bank.Accountant);
Print(_bank.Cashier);
Now there is an addition of Branch type Bank to the above Bank object. Now the
situation has become more complex. How to do a better approach?
Definition
"Provide a way to access the elements of an aggregate object sequentially
without exposing its underlying representation"
Implementation
We can improve the above Challenge Situation using the Iterator pattern. Instead
of calling Print() method each time, we can use an Iterator to get the names
inside Bank Object.
We are introducing a new class named BankIterator which implements IEnumerable:
public
class BankIterator
: IEnumerable
{
private IList
_list = new
ArrayList();
public BankIterator(Bank
bank)
{
_list.Add(bank.Manager);
_list.Add(bank.Accountant);
_list.Add(bank.Cashier);
}
public
IEnumerator GetEnumerator()
{
return _list.GetEnumerator();
}
}
The class uses and ArrayList ito hold the Manager, Accountant, Cashier names. As
it is inheriting IEnumerable it has to implement the GetEnumerator() method.
Luckily we can send the list.GetEnumerator() for the same.
The new Print() method invocation looks like below:
BankIterator
iterator = new
BankIterator(_bank);
foreach
(string name in
iterator)
Print(name);
This improves the situation in the following ways:
- Easier Names access through Iteration
- More flexibility in introducing new Name
properties in the Bank class
Following is the snapshot of Class Diagrams:
Note
From C# 2.0 onwards the Iterator pattern is implemented using foreach. The
foreach allows sequential accessing of the elements inside a collection. The
IEnumerator interface is used to implement the Iterator pattern.
public
interface
IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
While executing the foreach, first the Reset() method is called to position to
the first element of the collection. Then through each iteration the MoveNext()
method is called. The Current property returns the current object from the
collection. The IEnumerator interface implementation of array, List, HashSet
etc. enables us to iterate over them using the same foreach loop.
References
http://msdn.microsoft.com/en-us/library/dscyy5s0(v=vs.80).aspx
Summary
In this article we have explored the Iterator pattern with an example in C#. The
pattern is already well implemented inside the language architecture of C#. We
can extend the pattern usage in our custom classes too. The examples we
discussed above are included in the source code attachment.