设计模式之美：Iterator（迭代器）

索引

• 意图
• 结构
• 参与者
• 适用性
• 效果
• 相关模式
• 实现
  • 实现方式（一）：Iterator 模式结构样式代码。
  • 实现方式（二）：实现 IEnumerable 中序遍历二叉树。
  • 实现方式（三）：实现 BidirectionalConcurrentDictionary 双向并发字典。
  • 实现方式（四）：实现 RoundRobin 循环列表。

意图

提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

结构

参与者

Iterator

• 迭代器定义访问和遍历元素的接口。

ConcreteIterator

• 具体迭代器实现迭代器接口。
• 对该聚合遍历时跟踪当前位置。

Aggregate

• 聚合定义创建相应迭代器对象的接口。

ConcreteAggregate

• 具体聚合实现创建相应迭代器的接口，该操作返回 ConreteIterator 的实例。

适用性

在以下情况下可以使用 Iterator 模式：

• 访问一个聚合对象的内容而无需暴露它的内部表示。
• 支持对聚合对象的多种遍历。
• 为遍历不同的聚合结构提供一个统一的接口。

效果

• 它支持以不同的方式遍历一个聚合。
• 迭代器简化了聚合的接口。
• 在同一个聚合上可以有多个遍历。

相关模式

• Iterator 常被应用到 Composite 这样的递归结构上。
• 可以使用 Factory Method 模式来实例化多态迭代器。
• Iterator 可以使用 Memento 来捕获一个迭代的状态，在内部存储 Memento。

实现

实现方式（一）：Iterator 模式结构样式代码。

namespace IteratorPattern.Implementation1
{
  public abstract class Iterator
  {
    public abstract object First();
    public abstract object MoveNext();
    public abstract object Current();
    public abstract bool IsDone();
    public abstract void Reset();
  }

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

  public class ConcreteAggregate : Aggregate
  {
    private readonly ArrayList _items = new ArrayList();

    public int Count
    {
      get { return _items.Count; }
    }

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

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

  public class ConcreteIterator : Iterator
  {
    private readonly ConcreteAggregate _aggregate;
    private int _currentIndex = 0;

    public ConcreteIterator(ConcreteAggregate aggregate)
    {
      _aggregate = aggregate;
    }

    public override object First()
    {
      if (_aggregate.Count > 0)
        return _aggregate[0];
      else
        return null;
    }

    public override object MoveNext()
    {
      object item = null;
      if (_currentIndex < _aggregate.Count - 1)
      {
        item = _aggregate[++_currentIndex];
      }

      return item;
    }

    public override object Current()
    {
      return _aggregate[_currentIndex];
    }

    public override bool IsDone()
    {
      return _currentIndex >= _aggregate.Count;
    }

    public override void Reset()
    {
      _currentIndex = 0;
    }
  }

  public class Client
  {
    public void TestCase1()
    {
      var aggregate = new ConcreteAggregate();
      aggregate[0] = "Apple";
      aggregate[1] = "Orange";
      aggregate[2] = "Strawberry";

      var iterator = new ConcreteIterator(aggregate);

      object item = iterator.First();
      while (!iterator.IsDone())
      {
        Console.WriteLine(item);
        item = iterator.MoveNext();
      }
    }
  }
}

实现方式（二）：实现 IEnumerable 中序遍历二叉树。

  /// <summary>
  /// 二叉树节点
  /// </summary>
  /// <typeparam name="T">The item type</typeparam>
  public class BinaryTreeNode<T>
  {
    #region Constructors

    /// <summary>
    /// 二叉树节点
    /// </summary>
    public BinaryTreeNode()
    {
    }

    /// <summary>
    /// 二叉树节点
    /// </summary>
    /// <param name="value">节点中的值</param>
    public BinaryTreeNode(T value)
    {
      this.Value = value;
    }

    /// <summary>
    /// 二叉树节点
    /// </summary>
    /// <param name="value">节点中的值</param>
    /// <param name="parent">节点的父节点</param>
    public BinaryTreeNode(T value, BinaryTreeNode<T> parent)
    {
      this.Value = value;
      this.Parent = parent;
    }

    /// <summary>
    /// 二叉树节点
    /// </summary>
    /// <param name="value">节点中的值</param>
    /// <param name="parent">节点的父节点</param>
    /// <param name="left">节点的左节点</param>
    /// <param name="right">节点的右节点</param>
    public BinaryTreeNode(T value, 
      BinaryTreeNode<T> parent, 
      BinaryTreeNode<T> left, 
      BinaryTreeNode<T> right)
    {
      this.Value = value;
      this.Right = right;
      this.Left = left;
      this.Parent = parent;
    }

    #endregion

    #region Properties

    /// <summary>
    /// 节点值
    /// </summary>
    public T Value { get; set; }

    /// <summary>
    /// 父节点
    /// </summary>
    public BinaryTreeNode<T> Parent { get; set; }

    /// <summary>
    /// 左节点
    /// </summary>
    public BinaryTreeNode<T> Left { get; set; }

    /// <summary>
    /// 右节点
    /// </summary>
    public BinaryTreeNode<T> Right { get; set; }

    /// <summary>
    /// 是否为根节点
    /// </summary>
    public bool IsRoot { get { return Parent == null; } }

    /// <summary>
    /// 是否为叶子节点
    /// </summary>
    public bool IsLeaf { get { return Left == null && Right == null; } }

    /// <summary>
    /// 是否为可访问的
    /// </summary>
    internal bool Visited { get; set; }

    #endregion

    #region Public Overridden Functions

    /// <summary>
    /// Returns a <see cref="System.String"/> that represents this instance.
    /// </summary>
    /// <returns>
    /// A <see cref="System.String"/> that represents this instance.
    /// </returns>
    public override string ToString()
    {
      return Value.ToString();
    }

    #endregion
  }

  /// <summary>
  /// 二叉树
  /// </summary>
  /// <typeparam name="T">二叉树中节点内容类型</typeparam>
  [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
  public class BinaryTree<T> : ICollection<T>, IEnumerable<T> where T : IComparable<T>
  {
    #region Constructor

    /// <summary>
    /// 二叉树
    /// </summary>
    public BinaryTree()
    {
      NumberOfNodes = 0;
    }

    /// <summary>
    /// 二叉树
    /// </summary>
    /// <param name="root">二叉树根节点</param>
    public BinaryTree(BinaryTreeNode<T> root)
      : this()
    {
      this.Root = root;
    }

    #endregion

    #region Properties

    /// <summary>
    /// 树的根节点
    /// </summary>
    public BinaryTreeNode<T> Root { get; set; }

    /// <summary>
    /// 树中节点的数量
    /// </summary>
    protected int NumberOfNodes { get; set; }

    /// <summary>
    /// 树是否为空
    /// </summary>
    public bool IsEmpty { get { return Root == null; } }

    /// <summary>
    /// 获取树中节点的最小值
    /// </summary>
    public T MinValue
    {
      get
      {
        if (IsEmpty)
          return default(T);

        BinaryTreeNode<T> minNode = Root;
        while (minNode.Left != null)
          minNode = minNode.Left;

        return minNode.Value;
      }
    }

    /// <summary>
    /// 获取树中节点的最大值
    /// </summary>
    public T MaxValue
    {
      get
      {
        if (IsEmpty)
          return default(T);

        BinaryTreeNode<T> maxNode = Root;
        while (maxNode.Right != null)
          maxNode = maxNode.Right;

        return maxNode.Value;
      }
    }

    #endregion

    #region IEnumerable<T> Members

    /// <summary>
    /// Returns an enumerator that iterates through the collection.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> 
    /// that can be used to iterate through the collection.
    /// </returns>
    public IEnumerator<T> GetEnumerator()
    {
      foreach (BinaryTreeNode<T> node in Traverse(Root))
      {
        yield return node.Value;
      }
    }

    #endregion

    #region IEnumerable Members

    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Collections.IEnumerator"/> 
    /// object that can be used to iterate through the collection.
    /// </returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
      foreach (BinaryTreeNode<T> node in Traverse(Root))
      {
        yield return node.Value;
      }
    }

    #endregion

    #region ICollection<T> Members

    /// <summary>
    /// 新增节点
    /// </summary>
    /// <param name="item">The object to add to the 
    /// <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
    /// <exception cref="T:System.NotSupportedException">The 
    /// <see cref="T:System.Collections.Generic.ICollection`1"></see> 
    /// is read-only.</exception>
    public void Add(T item)
    {
      if (Root == null)
      {
        Root = new BinaryTreeNode<T>(item);
        ++NumberOfNodes;
      }
      else
      {
        Insert(item);
      }
    }

    /// <summary>
    /// 清除树
    /// </summary>
    public void Clear()
    {
      Root = null;
    }

    /// <summary>
    /// 树中是否包含此节点
    /// </summary>
    /// <param name="item">The object to locate in the 
    /// <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
    /// <returns>
    /// true if item is found in the 
    /// <see cref="T:System.Collections.Generic.ICollection`1"></see>; otherwise, false.
    /// </returns>
    public bool Contains(T item)
    {
      if (IsEmpty)
        return false;

      BinaryTreeNode<T> currentNode = Root;
      while (currentNode != null)
      {
        int comparedValue = currentNode.Value.CompareTo(item);
        if (comparedValue == 0)
          return true;
        else if (comparedValue < 0)
          currentNode = currentNode.Left;
        else
          currentNode = currentNode.Right;
      }

      return false;
    }

    /// <summary>
    /// 将树中节点拷贝至目标数组
    /// </summary>
    /// <param name="array">The array.</param>
    /// <param name="arrayIndex">Index of the array.</param>
    public void CopyTo(T[] array, int arrayIndex)
    {
      T[] tempArray = new T[NumberOfNodes];
      int counter = 0;
      foreach (T value in this)
      {
        tempArray[counter] = value;
        ++counter;
      }
      Array.Copy(tempArray, 0, array, arrayIndex, Count);
    }

    /// <summary>
    /// 树中节点的数量
    /// </summary>
    public int Count
    {
      get { return NumberOfNodes; }
    }

    /// <summary>
    /// 树是否为只读
    /// </summary>
    public bool IsReadOnly
    {
      get { return false; }
    }

    /// <summary>
    /// 移除节点
    /// </summary>
    /// <param name="item">节点值</param>
    /// <returns>是否移除成功</returns>
    public bool Remove(T item)
    {
      BinaryTreeNode<T> node = Find(item);
      if (node == null)
        return false;

      List<T> values = new List<T>();
      foreach (BinaryTreeNode<T> l in Traverse(node.Left))
      {
        values.Add(l.Value);
      }
      foreach (BinaryTreeNode<T> r in Traverse(node.Right))
      {
        values.Add(r.Value);
      }

      if (node.Parent.Left == node)
      {
        node.Parent.Left = null;
      }
      else
      {
        node.Parent.Right = null;
      }

      node.Parent = null;

      foreach (T v in values)
      {
        this.Add(v);
      }

      return true;
    }

    #endregion

    #region Private Functions

    /// <summary>
    /// 查找指定值的节点
    /// </summary>
    /// <param name="value">指定值</param>
    /// <returns>
    /// 指定值的节点
    /// </returns>
    protected BinaryTreeNode<T> Find(T value)
    {
      foreach (BinaryTreeNode<T> node in Traverse(Root))
        if (node.Value.Equals(value))
          return node;
      return null;
    }

    /// <summary>
    /// 遍历树
    /// </summary>
    /// <param name="node">遍历搜索的起始节点</param>
    /// <returns>
    /// The individual items from the tree
    /// </returns>
    [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]
    protected IEnumerable<BinaryTreeNode<T>> Traverse(BinaryTreeNode<T> node)
    {
      // 遍历左子树
      if (node.Left != null)
      {
        foreach (BinaryTreeNode<T> left in Traverse(node.Left))
          yield return left;
      }

      // 中序遍历二叉树, 顺序是 左子树，根，右子树
      yield return node;

      // 遍历右子树
      if (node.Right != null)
      {
        foreach (BinaryTreeNode<T> right in Traverse(node.Right))
          yield return right;
      }
    }

    /// <summary>
    /// 插入节点
    /// </summary>
    /// <param name="value">插入的节点值</param>
    protected void Insert(T value)
    {
      // 从根节点开始比较
      BinaryTreeNode<T> currentNode = Root;
      
      while (true)
      {
        if (currentNode == null)
          throw new InvalidProgramException("The current tree node cannot be null.");

        // 比较当前节点与新节点的值
        int comparedValue = currentNode.Value.CompareTo(value);
        if (comparedValue < 0)
        {
          // 当前节点值小于新节点值
          if (currentNode.Left == null)
          {
            currentNode.Left = new BinaryTreeNode<T>(value, currentNode);
            ++NumberOfNodes;
            return;
          }
          else
          {
            currentNode = currentNode.Left;
          }
        }
        else if (comparedValue > 0)
        {
          // 当前节点值大于新节点值
          if (currentNode.Right == null)
          {
            currentNode.Right = new BinaryTreeNode<T>(value, currentNode);
            ++NumberOfNodes;
            return;
          }
          else
          {
            currentNode = currentNode.Right;
          }
        }
        else
        {
          // 当前节点值等于新节点值
          currentNode = currentNode.Right;
        }
      }
    }

    #endregion
  }

实现方式（三）：实现 BidirectionalConcurrentDictionary 双向并发字典。

namespace IteratorPattern.Implementation3
{
  /// <summary>
  /// 双值对
  /// </summary>
  /// <typeparam name="TFirst">第一个值的类型</typeparam>
  /// <typeparam name="TSecond">第二个值的类型</typeparam>
  [Serializable]
  public struct FirstSecondPair<TFirst, TSecond>
  {
    private TFirst first;
    private TSecond second;

    /// <summary>
    /// 第一个值
    /// </summary>
    public TFirst First
    {
      get
      {
        return this.first;
      }
    }

    /// <summary>
    /// 第二个值
    /// </summary>
    public TSecond Second
    {
      get
      {
        return this.second;
      }
    }

    /// <summary>
    /// 双值对
    /// </summary>
    /// <param name="first">第一个值</param>
    /// <param name="second">第二个值</param>
    public FirstSecondPair(TFirst first, TSecond second)
    {
      if (first == null)
        throw new ArgumentNullException("first");
      if (second == null)
        throw new ArgumentNullException("second");

      this.first = first;
      this.second = second;
    }

    /// <summary>
    /// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
    /// </summary>
    /// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
    /// <returns>
    ///   <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
    /// </returns>
    public override bool Equals(object obj)
    {
      if (obj == null)
        return false;

      FirstSecondPair<TFirst, TSecond> target = (FirstSecondPair<TFirst, TSecond>)obj;
      return this.First.Equals(target.First) && this.Second.Equals(target.Second);
    }

    /// <summary>
    /// Returns a hash code for this instance.
    /// </summary>
    /// <returns>
    /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
    /// </returns>
    public override int GetHashCode()
    {
      return base.GetHashCode();
    }

    /// <summary>
    /// Returns a <see cref="System.String"/> that represents this instance.
    /// </summary>
    /// <returns>
    /// A <see cref="System.String"/> that represents this instance.
    /// </returns>
    public override string ToString()
    {
      StringBuilder sb = new StringBuilder();
      sb.Append('[');

      if (this.First != null)
      {
        sb.Append(this.First.ToString());
      }

      sb.Append(", ");

      if (this.Second != null)
      {
        sb.Append(this.Second.ToString());
      }

      sb.Append(']');

      return sb.ToString();
    }

    /// <summary>
    /// Implements the operator ==.
    /// </summary>
    /// <param name="left">The left.</param>
    /// <param name="right">The right.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator ==(FirstSecondPair<TFirst, TSecond> left, FirstSecondPair<TFirst, TSecond> right)
    {
      if (((object)left == null) || ((object)right == null))
      {
        return false;
      }

      return left.Equals(right);
    }

    /// <summary>
    /// Implements the operator !=.
    /// </summary>
    /// <param name="left">The left.</param>
    /// <param name="right">The right.</param>
    /// <returns>
    /// The result of the operator.
    /// </returns>
    public static bool operator !=(FirstSecondPair<TFirst, TSecond> left, FirstSecondPair<TFirst, TSecond> right)
    {
      return !(left == right);
    }
  }

  public class BidirectionalConcurrentDictionary<TFirst, TSecond> : IEnumerable<FirstSecondPair<TFirst, TSecond>>
  {
    #region Fields

    private ConcurrentDictionary<TFirst, TSecond> firstToSecond = new ConcurrentDictionary<TFirst, TSecond>();
    private ConcurrentDictionary<TSecond, TFirst> secondToFirst = new ConcurrentDictionary<TSecond, TFirst>();

    #endregion

    #region Public Methods

    public void Add(TFirst first, TSecond second)
    {
      if (firstToSecond.ContainsKey(first) || secondToFirst.ContainsKey(second))
        throw new ArgumentException("Duplicate first or second");

      firstToSecond.Add(first, second);
      secondToFirst.Add(second, first);
    }

    public bool ContainsFirst(TFirst first)
    {
      return firstToSecond.ContainsKey(first);
    }

    public bool ContainsSecond(TSecond second)
    {
      return secondToFirst.ContainsKey(second);
    }

    public TSecond GetByFirst(TFirst first)
    {
      TSecond second;
      if (!firstToSecond.TryGetValue(first, out second))
        throw new KeyNotFoundException("Cannot find second by first.");

      return second;
    }

    public TFirst GetBySecond(TSecond second)
    {
      TFirst first;
      if (!secondToFirst.TryGetValue(second, out first))
        throw new KeyNotFoundException("Cannot find first by second.");

      return first;
    }

    public void RemoveByFirst(TFirst first)
    {
      TSecond second;
      if (!firstToSecond.TryGetValue(first, out second))
        throw new KeyNotFoundException("Cannot find second by first.");

      firstToSecond.Remove(first);
      secondToFirst.Remove(second);
    }

    public void RemoveBySecond(TSecond second)
    {
      TFirst first;
      if (!secondToFirst.TryGetValue(second, out first))
        throw new KeyNotFoundException("Cannot find first by second.");

      secondToFirst.Remove(second);
      firstToSecond.Remove(first);
    }

    public bool TryAdd(TFirst first, TSecond second)
    {
      if (firstToSecond.ContainsKey(first) || secondToFirst.ContainsKey(second))
        return false;

      firstToSecond.Add(first, second);
      secondToFirst.Add(second, first);
      return true;
    }

    public bool TryGetByFirst(TFirst first, out TSecond second)
    {
      return firstToSecond.TryGetValue(first, out second);
    }

    public bool TryGetBySecond(TSecond second, out TFirst first)
    {
      return secondToFirst.TryGetValue(second, out first);
    }

    public bool TryRemoveByFirst(TFirst first)
    {
      TSecond second;
      if (!firstToSecond.TryGetValue(first, out second))
        return false;

      firstToSecond.Remove(first);
      secondToFirst.Remove(second);
      return true;
    }

    public bool TryRemoveBySecond(TSecond second)
    {
      TFirst first;
      if (!secondToFirst.TryGetValue(second, out first))
        return false;

      secondToFirst.Remove(second);
      firstToSecond.Remove(first);
      return true;
    }

    public int Count
    {
      get { return firstToSecond.Count; }
    }

    public void Clear()
    {
      firstToSecond.Clear();
      secondToFirst.Clear();
    }

    #endregion

    #region IEnumerable<FirstSecondPair<TFirst,TSecond>> Members

    IEnumerator<FirstSecondPair<TFirst, TSecond>> IEnumerable<FirstSecondPair<TFirst, TSecond>>.GetEnumerator()
    {
      foreach (var item in firstToSecond)
      {
        yield return new FirstSecondPair<TFirst, TSecond>(item.Key, item.Value);
      }
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
      foreach (var item in firstToSecond)
      {
        yield return new FirstSecondPair<TFirst, TSecond>(item.Key, item.Value);
      }
    }

    #endregion
  }

  public static class ConcurrentDictionaryExtensions
  {
    public static TValue Add<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key, TValue @value)
    {
      TValue result = collection.AddOrUpdate(key, @value, (k, v) => { return @value; });
      return result;
    }

    public static TValue Update<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key, TValue @value)
    {
      TValue result = collection.AddOrUpdate(key, @value, (k, v) => { return @value; });
      return result;
    }

    public static TValue Get<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key)
    {
      TValue @value = default(TValue);
      collection.TryGetValue(key, out @value);
      return @value;
    }

    public static TValue Remove<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key)
    {
      TValue @value = default(TValue);
      collection.TryRemove(key, out @value);
      return @value;
    }
  }
}

实现方式（四）：实现 RoundRobin 循环列表。

namespace IteratorPattern.Implementation4
{
  /// <summary>
  /// 循环列表
  /// </summary>
  /// <typeparam name="T"></typeparam>
  public class RoundRobinCollection<T> : IEnumerable<T>
  {
    private T[] _items;
    private int _head;

    /// <summary>
    /// 循环列表
    /// </summary>
    /// <param name="items">供循环的列表项</param>
    public RoundRobinCollection(IEnumerable<T> items)
    {
      if (items == null || items.Count<T>() == 0)
      {
        throw new ArgumentException(
          "One or more items must be provided", "items");
      }

      // copy the list to ensure it doesn't change on us 
      // (and so we can lock() on our private copy) 
      _items = items.ToArray();
    }

    /// <summary>
    /// 获取循环器
    /// </summary>
    /// <returns></returns>
    public IEnumerator<T> GetEnumerator()
    {
      int currentHead;

      lock (_items)
      {
        currentHead = _head++;

        if (_head == _items.Length)
        {
          // wrap back to the start 
          _head = 0;
        }
      }

      // return results [current] ... [last] 
      for (int i = currentHead; i < _items.Length; i++)
      {
        yield return _items[i];
      }

      // return wrap-around (if any) [0] ... [current-1] 
      for (int i = 0; i < currentHead; i++)
      {
        yield return _items[i];
      }
    }

    /// <summary>
    /// 获取循环器
    /// </summary>
    /// <returns></returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
      return this.GetEnumerator();
    }
  }
}

《设计模式之美》为 Dennis Gao 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。