Iterator Design Pattern

// Iterator pattern -- Structural example

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Iterator.Structural
{

  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      ConcreteAggregate a = new ConcreteAggregate();
      a[0] = "Item A";
      a[1] = "Item B";
      a[2] = "Item C";
      a[3] = "Item D";

      // Create Iterator and provide aggregate
      ConcreteIterator i = new ConcreteIterator(a);

      Console.WriteLine("Iterating over collection:");
      
      object item = i.First();
      while (item != null)
      {
        Console.WriteLine(item);
        item = i.Next();
      }

      // Wait for user
      Console.Read();
    }
  }

  // "Aggregate"

  abstract class Aggregate
  {
    public abstract Iterator CreateIterator();
  }

  // "ConcreteAggregate"

  class ConcreteAggregate : Aggregate
  {
    private ArrayList items = new ArrayList();

    public override Iterator CreateIterator()
    {
      return new ConcreteIterator(this);
    }

    // Property
    public int Count
    {
      get{ return items.Count; }
    }

    // Indexer
    public object this[int index]
    {
      get{ return items[index]; }
      set{ items.Insert(index, value); }
    }
  }

  // "Iterator"

  abstract class Iterator
  {
    public abstract object First();
    public abstract object Next();
    public abstract bool IsDone();
    public abstract object CurrentItem();
  }

  // "ConcreteIterator"

  class ConcreteIterator : Iterator
  {
    private ConcreteAggregate aggregate;
    private int current = 0;

    // Constructor
    public ConcreteIterator(ConcreteAggregate aggregate)
    {
      this.aggregate = aggregate;
    }

    public override object First()
    {
      return aggregate[0];
    }

    public override object Next()
    {
      object ret = null;
      if (current < aggregate.Count - 1)
      {
        ret = aggregate[++current];
      }
      
      return ret;
    }

    public override object CurrentItem()
    {
      return aggregate[current];
    }

    public override bool IsDone()
    {
      return current >= aggregate.Count ? true : false ;
    }
  }
}

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Iterator.RealWorld
{

  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      // Build a collection
      Collection collection = new Collection();
      collection[0] = new Item("Item 0");
      collection[1] = new Item("Item 1");
      collection[2] = new Item("Item 2");
      collection[3] = new Item("Item 3");
      collection[4] = new Item("Item 4");
      collection[5] = new Item("Item 5");
      collection[6] = new Item("Item 6");
      collection[7] = new Item("Item 7");
      collection[8] = new Item("Item 8");

      // Create iterator
      Iterator iterator = new Iterator(collection);

      // Skip every other item
      iterator.Step = 2;

      Console.WriteLine("Iterating over collection:");

      for(Item item = iterator.First();
        !iterator.IsDone; item = iterator.Next())
      {
        Console.WriteLine(item.Name);
      }

      // Wait for user
      Console.Read();
    }
  }

  class Item
  {
    string name;

    // Constructor
    public Item(string name)
    {
      this.name = name;
    }

    // Property
    public string Name
    {
      get{ return name; }
    }
  }

  // "Aggregate"

  interface IAbstractCollection
  {
    Iterator CreateIterator();
  }

  // "ConcreteAggregate"

  class Collection : IAbstractCollection
  {
    private ArrayList items = new ArrayList();

    public Iterator CreateIterator()
    {
      return new Iterator(this);
    }

    // Property
    public int Count
    {
      get{ return items.Count; }
    }
    
    // Indexer
    public object this[int index]
    {
      get{ return items[index]; }
      set{ items.Add(value); }
    }
  }

  // "Iterator"

  interface IAbstractIterator
  {
    Item First();
    Item Next();
    bool IsDone{ get; }
    Item CurrentItem{ get; }
  }

  // "ConcreteIterator"

  class Iterator : IAbstractIterator
  {
    private Collection collection;
    private int current = 0;
    private int step = 1;

    // Constructor
    public Iterator(Collection collection)
    {
      this.collection = collection;
    }

    public Item First()
    {
      current = 0;
      return collection[current] as Item;
    }

    public Item Next()
    {
      current += step;
      if (!IsDone)
        return collection[current] as Item;
      else
        return null;
    }

    // Properties
    public int Step
    {
      get{ return step; }
      set{ step = value; }
    }

    public Item CurrentItem
    {
      get
      {
        return collection[current] as Item;
      }
    }

    public bool IsDone
    {
      get
      {
        return current >= collection.Count ? true : false;
      }
    }
  }
}

// Iterator pattern -- .NET optimized

Two editions: C# and VB.NET

This .NET code is part of our unique Design Pattern Framework 2.0TM with: 69 gang-of-four pattern projects 46 head-first pattern projects Martin Fowler's enterprise patterns SOA design patterns e-commerce web application 100% pure source code Instant download. Order now!

         See our Singleton page for a .NET optimized code sample.