Iterator Pattern
Description:
» The Iterator pattern provides a way of accessing elements of a collection sequentially, without knowing how the collection is structured;» As an extension, the pattern allows for filtering elements in a variety of ways as they are generated.
Use When:
You are iterating over a collection and one of these conditions holds:» There are various ways of traversing it (several enumerators);
» There are different collections for the same kind of traversing;
» Different filters and orderings might apply.
//Define the Main Tree Object.
//Define the Tree class which contains the methods required to iterate through the family tree structure.
public class Tree
{
Node _mRoot;
public Tree(Node head)
{
_mRoot = head;
}
public IEnumerable<Person> Preorder
{
get
{
return ScanPreorder(_mRoot);
}
}
//The ScanPreorder() method is the main method for transvering the tree and uses recursion to iterate from the root node to the left node and then to the right node for each node in the tree.
//For the root node the method yields the data at that node, and for the left and right nodes, it yields a node to the enumerator. This node will act as the root node and the iteration will start again.
//In this way, the entire tree is transversed from left to right and top to bottom.
private IEnumerable<Person> ScanPreorder(Node root)
{
yield return (root.Data);
if (root.Child != null)
{
foreach (Person p in ScanPreorder(root.Child))
{
yield return p;
}
}
if (root.Next != null)
{
foreach (Person p in ScanPreorder(root.Next))
{
yield return p;
}
}
}
//The Where() method acts as another enumerator, which also calls ScanPreorder() method but filters out the required Person objects according to the delegate supplied.
//The type of the delegate is Func, meaning it takes a Person as a parameter on each iteration, and returns a boolean value.
//The Tree class does not implement the IEnumerable interface so in order to use LINQ functionality the Where() method was defined.
public IEnumerable<Person> Where(Func<Person, bool> filter)
{
foreach (Person p in ScanPreorder(_mRoot))
{
if (filter(p))
{
yield return p;
}
}
}
}
//Define the Tree class which contains the methods required to iterate through the family tree structure.
public class Tree
{
Node _mRoot;
public Tree(Node head)
{
_mRoot = head;
}
public IEnumerable<Person> Preorder
{
get
{
return ScanPreorder(_mRoot);
}
}
//The ScanPreorder() method is the main method for transvering the tree and uses recursion to iterate from the root node to the left node and then to the right node for each node in the tree.
//For the root node the method yields the data at that node, and for the left and right nodes, it yields a node to the enumerator. This node will act as the root node and the iteration will start again.
//In this way, the entire tree is transversed from left to right and top to bottom.
private IEnumerable<Person> ScanPreorder(Node root)
{
yield return (root.Data);
if (root.Child != null)
{
foreach (Person p in ScanPreorder(root.Child))
{
yield return p;
}
}
if (root.Next != null)
{
foreach (Person p in ScanPreorder(root.Next))
{
yield return p;
}
}
}
//The Where() method acts as another enumerator, which also calls ScanPreorder() method but filters out the required Person objects according to the delegate supplied.
//The type of the delegate is Func
//The Tree class does not implement the IEnumerable
public IEnumerable<Person> Where(Func<Person, bool> filter)
{
foreach (Person p in ScanPreorder(_mRoot))
{
if (filter(p))
{
yield return p;
}
}
}
}
