Fork me on GitHub

设计模式之美:Iterator(迭代器)

索引

意图

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

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 模式结构样式代码。

  1 namespace IteratorPattern.Implementation1
  2 {
  3   public abstract class Iterator
  4   {
  5     public abstract object First();
  6     public abstract object MoveNext();
  7     public abstract object Current();
  8     public abstract bool IsDone();
  9     public abstract void Reset();
 10   }
 11 
 12   public abstract class Aggregate
 13   {
 14     public abstract Iterator CreateIterator();
 15   }
 16 
 17   public class ConcreteAggregate : Aggregate
 18   {
 19     private readonly ArrayList _items = new ArrayList();
 20 
 21     public int Count
 22     {
 23       get { return _items.Count; }
 24     }
 25 
 26     public object this[int index]
 27     {
 28       get { return _items[index]; }
 29       set { _items.Insert(index, value); }
 30     }
 31 
 32     public override Iterator CreateIterator()
 33     {
 34       return new ConcreteIterator(this);
 35     }
 36   }
 37 
 38   public class ConcreteIterator : Iterator
 39   {
 40     private readonly ConcreteAggregate _aggregate;
 41     private int _currentIndex = 0;
 42 
 43     public ConcreteIterator(ConcreteAggregate aggregate)
 44     {
 45       _aggregate = aggregate;
 46     }
 47 
 48     public override object First()
 49     {
 50       if (_aggregate.Count > 0)
 51         return _aggregate[0];
 52       else
 53         return null;
 54     }
 55 
 56     public override object MoveNext()
 57     {
 58       object item = null;
 59       if (_currentIndex < _aggregate.Count - 1)
 60       {
 61         item = _aggregate[++_currentIndex];
 62       }
 63 
 64       return item;
 65     }
 66 
 67     public override object Current()
 68     {
 69       return _aggregate[_currentIndex];
 70     }
 71 
 72     public override bool IsDone()
 73     {
 74       return _currentIndex >= _aggregate.Count;
 75     }
 76 
 77     public override void Reset()
 78     {
 79       _currentIndex = 0;
 80     }
 81   }
 82 
 83   public class Client
 84   {
 85     public void TestCase1()
 86     {
 87       var aggregate = new ConcreteAggregate();
 88       aggregate[0] = "Apple";
 89       aggregate[1] = "Orange";
 90       aggregate[2] = "Strawberry";
 91 
 92       var iterator = new ConcreteIterator(aggregate);
 93 
 94       object item = iterator.First();
 95       while (!iterator.IsDone())
 96       {
 97         Console.WriteLine(item);
 98         item = iterator.MoveNext();
 99       }
100     }
101   }
102 }

实现方式(二):实现 IEnumerable 中序遍历二叉树。

  1   /// <summary>
  2   /// 二叉树节点
  3   /// </summary>
  4   /// <typeparam name="T">The item type</typeparam>
  5   public class BinaryTreeNode<T>
  6   {
  7     #region Constructors
  8 
  9     /// <summary>
 10     /// 二叉树节点
 11     /// </summary>
 12     public BinaryTreeNode()
 13     {
 14     }
 15 
 16     /// <summary>
 17     /// 二叉树节点
 18     /// </summary>
 19     /// <param name="value">节点中的值</param>
 20     public BinaryTreeNode(T value)
 21     {
 22       this.Value = value;
 23     }
 24 
 25     /// <summary>
 26     /// 二叉树节点
 27     /// </summary>
 28     /// <param name="value">节点中的值</param>
 29     /// <param name="parent">节点的父节点</param>
 30     public BinaryTreeNode(T value, BinaryTreeNode<T> parent)
 31     {
 32       this.Value = value;
 33       this.Parent = parent;
 34     }
 35 
 36     /// <summary>
 37     /// 二叉树节点
 38     /// </summary>
 39     /// <param name="value">节点中的值</param>
 40     /// <param name="parent">节点的父节点</param>
 41     /// <param name="left">节点的左节点</param>
 42     /// <param name="right">节点的右节点</param>
 43     public BinaryTreeNode(T value, 
 44       BinaryTreeNode<T> parent, 
 45       BinaryTreeNode<T> left, 
 46       BinaryTreeNode<T> right)
 47     {
 48       this.Value = value;
 49       this.Right = right;
 50       this.Left = left;
 51       this.Parent = parent;
 52     }
 53 
 54     #endregion
 55 
 56     #region Properties
 57 
 58     /// <summary>
 59     /// 节点值
 60     /// </summary>
 61     public T Value { get; set; }
 62 
 63     /// <summary>
 64     /// 父节点
 65     /// </summary>
 66     public BinaryTreeNode<T> Parent { get; set; }
 67 
 68     /// <summary>
 69     /// 左节点
 70     /// </summary>
 71     public BinaryTreeNode<T> Left { get; set; }
 72 
 73     /// <summary>
 74     /// 右节点
 75     /// </summary>
 76     public BinaryTreeNode<T> Right { get; set; }
 77 
 78     /// <summary>
 79     /// 是否为根节点
 80     /// </summary>
 81     public bool IsRoot { get { return Parent == null; } }
 82 
 83     /// <summary>
 84     /// 是否为叶子节点
 85     /// </summary>
 86     public bool IsLeaf { get { return Left == null && Right == null; } }
 87 
 88     /// <summary>
 89     /// 是否为可访问的
 90     /// </summary>
 91     internal bool Visited { get; set; }
 92 
 93     #endregion
 94 
 95     #region Public Overridden Functions
 96 
 97     /// <summary>
 98     /// Returns a <see cref="System.String"/> that represents this instance.
 99     /// </summary>
100     /// <returns>
101     /// A <see cref="System.String"/> that represents this instance.
102     /// </returns>
103     public override string ToString()
104     {
105       return Value.ToString();
106     }
107 
108     #endregion
109   }
  1   /// <summary>
  2   /// 二叉树
  3   /// </summary>
  4   /// <typeparam name="T">二叉树中节点内容类型</typeparam>
  5   [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
  6   public class BinaryTree<T> : ICollection<T>, IEnumerable<T> where T : IComparable<T>
  7   {
  8     #region Constructor
  9 
 10     /// <summary>
 11     /// 二叉树
 12     /// </summary>
 13     public BinaryTree()
 14     {
 15       NumberOfNodes = 0;
 16     }
 17 
 18     /// <summary>
 19     /// 二叉树
 20     /// </summary>
 21     /// <param name="root">二叉树根节点</param>
 22     public BinaryTree(BinaryTreeNode<T> root)
 23       : this()
 24     {
 25       this.Root = root;
 26     }
 27 
 28     #endregion
 29 
 30     #region Properties
 31 
 32     /// <summary>
 33     /// 树的根节点
 34     /// </summary>
 35     public BinaryTreeNode<T> Root { get; set; }
 36 
 37     /// <summary>
 38     /// 树中节点的数量
 39     /// </summary>
 40     protected int NumberOfNodes { get; set; }
 41 
 42     /// <summary>
 43     /// 树是否为空
 44     /// </summary>
 45     public bool IsEmpty { get { return Root == null; } }
 46 
 47     /// <summary>
 48     /// 获取树中节点的最小值
 49     /// </summary>
 50     public T MinValue
 51     {
 52       get
 53       {
 54         if (IsEmpty)
 55           return default(T);
 56 
 57         BinaryTreeNode<T> minNode = Root;
 58         while (minNode.Left != null)
 59           minNode = minNode.Left;
 60 
 61         return minNode.Value;
 62       }
 63     }
 64 
 65     /// <summary>
 66     /// 获取树中节点的最大值
 67     /// </summary>
 68     public T MaxValue
 69     {
 70       get
 71       {
 72         if (IsEmpty)
 73           return default(T);
 74 
 75         BinaryTreeNode<T> maxNode = Root;
 76         while (maxNode.Right != null)
 77           maxNode = maxNode.Right;
 78 
 79         return maxNode.Value;
 80       }
 81     }
 82 
 83     #endregion
 84 
 85     #region IEnumerable<T> Members
 86 
 87     /// <summary>
 88     /// Returns an enumerator that iterates through the collection.
 89     /// </summary>
 90     /// <returns>
 91     /// A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> 
 92     /// that can be used to iterate through the collection.
 93     /// </returns>
 94     public IEnumerator<T> GetEnumerator()
 95     {
 96       foreach (BinaryTreeNode<T> node in Traverse(Root))
 97       {
 98         yield return node.Value;
 99       }
100     }
101 
102     #endregion
103 
104     #region IEnumerable Members
105 
106     /// <summary>
107     /// Returns an enumerator that iterates through a collection.
108     /// </summary>
109     /// <returns>
110     /// An <see cref="T:System.Collections.IEnumerator"/> 
111     /// object that can be used to iterate through the collection.
112     /// </returns>
113     IEnumerator IEnumerable.GetEnumerator()
114     {
115       foreach (BinaryTreeNode<T> node in Traverse(Root))
116       {
117         yield return node.Value;
118       }
119     }
120 
121     #endregion
122 
123     #region ICollection<T> Members
124 
125     /// <summary>
126     /// 新增节点
127     /// </summary>
128     /// <param name="item">The object to add to the 
129     /// <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
130     /// <exception cref="T:System.NotSupportedException">The 
131     /// <see cref="T:System.Collections.Generic.ICollection`1"></see> 
132     /// is read-only.</exception>
133     public void Add(T item)
134     {
135       if (Root == null)
136       {
137         Root = new BinaryTreeNode<T>(item);
138         ++NumberOfNodes;
139       }
140       else
141       {
142         Insert(item);
143       }
144     }
145 
146     /// <summary>
147     /// 清除树
148     /// </summary>
149     public void Clear()
150     {
151       Root = null;
152     }
153 
154     /// <summary>
155     /// 树中是否包含此节点
156     /// </summary>
157     /// <param name="item">The object to locate in the 
158     /// <see cref="T:System.Collections.Generic.ICollection`1"></see>.</param>
159     /// <returns>
160     /// true if item is found in the 
161     /// <see cref="T:System.Collections.Generic.ICollection`1"></see>; otherwise, false.
162     /// </returns>
163     public bool Contains(T item)
164     {
165       if (IsEmpty)
166         return false;
167 
168       BinaryTreeNode<T> currentNode = Root;
169       while (currentNode != null)
170       {
171         int comparedValue = currentNode.Value.CompareTo(item);
172         if (comparedValue == 0)
173           return true;
174         else if (comparedValue < 0)
175           currentNode = currentNode.Left;
176         else
177           currentNode = currentNode.Right;
178       }
179 
180       return false;
181     }
182 
183     /// <summary>
184     /// 将树中节点拷贝至目标数组
185     /// </summary>
186     /// <param name="array">The array.</param>
187     /// <param name="arrayIndex">Index of the array.</param>
188     public void CopyTo(T[] array, int arrayIndex)
189     {
190       T[] tempArray = new T[NumberOfNodes];
191       int counter = 0;
192       foreach (T value in this)
193       {
194         tempArray[counter] = value;
195         ++counter;
196       }
197       Array.Copy(tempArray, 0, array, arrayIndex, Count);
198     }
199 
200     /// <summary>
201     /// 树中节点的数量
202     /// </summary>
203     public int Count
204     {
205       get { return NumberOfNodes; }
206     }
207 
208     /// <summary>
209     /// 树是否为只读
210     /// </summary>
211     public bool IsReadOnly
212     {
213       get { return false; }
214     }
215 
216     /// <summary>
217     /// 移除节点
218     /// </summary>
219     /// <param name="item">节点值</param>
220     /// <returns>是否移除成功</returns>
221     public bool Remove(T item)
222     {
223       BinaryTreeNode<T> node = Find(item);
224       if (node == null)
225         return false;
226 
227       List<T> values = new List<T>();
228       foreach (BinaryTreeNode<T> l in Traverse(node.Left))
229       {
230         values.Add(l.Value);
231       }
232       foreach (BinaryTreeNode<T> r in Traverse(node.Right))
233       {
234         values.Add(r.Value);
235       }
236 
237       if (node.Parent.Left == node)
238       {
239         node.Parent.Left = null;
240       }
241       else
242       {
243         node.Parent.Right = null;
244       }
245 
246       node.Parent = null;
247 
248       foreach (T v in values)
249       {
250         this.Add(v);
251       }
252 
253       return true;
254     }
255 
256     #endregion
257 
258     #region Private Functions
259 
260     /// <summary>
261     /// 查找指定值的节点
262     /// </summary>
263     /// <param name="value">指定值</param>
264     /// <returns>
265     /// 指定值的节点
266     /// </returns>
267     protected BinaryTreeNode<T> Find(T value)
268     {
269       foreach (BinaryTreeNode<T> node in Traverse(Root))
270         if (node.Value.Equals(value))
271           return node;
272       return null;
273     }
274 
275     /// <summary>
276     /// 遍历树
277     /// </summary>
278     /// <param name="node">遍历搜索的起始节点</param>
279     /// <returns>
280     /// The individual items from the tree
281     /// </returns>
282     [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]
283     protected IEnumerable<BinaryTreeNode<T>> Traverse(BinaryTreeNode<T> node)
284     {
285       // 遍历左子树
286       if (node.Left != null)
287       {
288         foreach (BinaryTreeNode<T> left in Traverse(node.Left))
289           yield return left;
290       }
291 
292       // 中序遍历二叉树, 顺序是 左子树,根,右子树
293       yield return node;
294 
295       // 遍历右子树
296       if (node.Right != null)
297       {
298         foreach (BinaryTreeNode<T> right in Traverse(node.Right))
299           yield return right;
300       }
301     }
302 
303     /// <summary>
304     /// 插入节点
305     /// </summary>
306     /// <param name="value">插入的节点值</param>
307     protected void Insert(T value)
308     {
309       // 从根节点开始比较
310       BinaryTreeNode<T> currentNode = Root;
311       
312       while (true)
313       {
314         if (currentNode == null)
315           throw new InvalidProgramException("The current tree node cannot be null.");
316 
317         // 比较当前节点与新节点的值
318         int comparedValue = currentNode.Value.CompareTo(value);
319         if (comparedValue < 0)
320         {
321           // 当前节点值小于新节点值
322           if (currentNode.Left == null)
323           {
324             currentNode.Left = new BinaryTreeNode<T>(value, currentNode);
325             ++NumberOfNodes;
326             return;
327           }
328           else
329           {
330             currentNode = currentNode.Left;
331           }
332         }
333         else if (comparedValue > 0)
334         {
335           // 当前节点值大于新节点值
336           if (currentNode.Right == null)
337           {
338             currentNode.Right = new BinaryTreeNode<T>(value, currentNode);
339             ++NumberOfNodes;
340             return;
341           }
342           else
343           {
344             currentNode = currentNode.Right;
345           }
346         }
347         else
348         {
349           // 当前节点值等于新节点值
350           currentNode = currentNode.Right;
351         }
352       }
353     }
354 
355     #endregion
356   }

实现方式(三):实现 BidirectionalConcurrentDictionary 双向并发字典。

  1 namespace IteratorPattern.Implementation3
  2 {
  3   /// <summary>
  4   /// 双值对
  5   /// </summary>
  6   /// <typeparam name="TFirst">第一个值的类型</typeparam>
  7   /// <typeparam name="TSecond">第二个值的类型</typeparam>
  8   [Serializable]
  9   public struct FirstSecondPair<TFirst, TSecond>
 10   {
 11     private TFirst first;
 12     private TSecond second;
 13 
 14     /// <summary>
 15     /// 第一个值
 16     /// </summary>
 17     public TFirst First
 18     {
 19       get
 20       {
 21         return this.first;
 22       }
 23     }
 24 
 25     /// <summary>
 26     /// 第二个值
 27     /// </summary>
 28     public TSecond Second
 29     {
 30       get
 31       {
 32         return this.second;
 33       }
 34     }
 35 
 36     /// <summary>
 37     /// 双值对
 38     /// </summary>
 39     /// <param name="first">第一个值</param>
 40     /// <param name="second">第二个值</param>
 41     public FirstSecondPair(TFirst first, TSecond second)
 42     {
 43       if (first == null)
 44         throw new ArgumentNullException("first");
 45       if (second == null)
 46         throw new ArgumentNullException("second");
 47 
 48       this.first = first;
 49       this.second = second;
 50     }
 51 
 52     /// <summary>
 53     /// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
 54     /// </summary>
 55     /// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
 56     /// <returns>
 57     ///   <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
 58     /// </returns>
 59     public override bool Equals(object obj)
 60     {
 61       if (obj == null)
 62         return false;
 63 
 64       FirstSecondPair<TFirst, TSecond> target = (FirstSecondPair<TFirst, TSecond>)obj;
 65       return this.First.Equals(target.First) && this.Second.Equals(target.Second);
 66     }
 67 
 68     /// <summary>
 69     /// Returns a hash code for this instance.
 70     /// </summary>
 71     /// <returns>
 72     /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
 73     /// </returns>
 74     public override int GetHashCode()
 75     {
 76       return base.GetHashCode();
 77     }
 78 
 79     /// <summary>
 80     /// Returns a <see cref="System.String"/> that represents this instance.
 81     /// </summary>
 82     /// <returns>
 83     /// A <see cref="System.String"/> that represents this instance.
 84     /// </returns>
 85     public override string ToString()
 86     {
 87       StringBuilder sb = new StringBuilder();
 88       sb.Append('[');
 89 
 90       if (this.First != null)
 91       {
 92         sb.Append(this.First.ToString());
 93       }
 94 
 95       sb.Append(", ");
 96 
 97       if (this.Second != null)
 98       {
 99         sb.Append(this.Second.ToString());
100       }
101 
102       sb.Append(']');
103 
104       return sb.ToString();
105     }
106 
107     /// <summary>
108     /// Implements the operator ==.
109     /// </summary>
110     /// <param name="left">The left.</param>
111     /// <param name="right">The right.</param>
112     /// <returns>
113     /// The result of the operator.
114     /// </returns>
115     public static bool operator ==(FirstSecondPair<TFirst, TSecond> left, FirstSecondPair<TFirst, TSecond> right)
116     {
117       if (((object)left == null) || ((object)right == null))
118       {
119         return false;
120       }
121 
122       return left.Equals(right);
123     }
124 
125     /// <summary>
126     /// Implements the operator !=.
127     /// </summary>
128     /// <param name="left">The left.</param>
129     /// <param name="right">The right.</param>
130     /// <returns>
131     /// The result of the operator.
132     /// </returns>
133     public static bool operator !=(FirstSecondPair<TFirst, TSecond> left, FirstSecondPair<TFirst, TSecond> right)
134     {
135       return !(left == right);
136     }
137   }
138 
139   public class BidirectionalConcurrentDictionary<TFirst, TSecond> : IEnumerable<FirstSecondPair<TFirst, TSecond>>
140   {
141     #region Fields
142 
143     private ConcurrentDictionary<TFirst, TSecond> firstToSecond = new ConcurrentDictionary<TFirst, TSecond>();
144     private ConcurrentDictionary<TSecond, TFirst> secondToFirst = new ConcurrentDictionary<TSecond, TFirst>();
145 
146     #endregion
147 
148     #region Public Methods
149 
150     public void Add(TFirst first, TSecond second)
151     {
152       if (firstToSecond.ContainsKey(first) || secondToFirst.ContainsKey(second))
153         throw new ArgumentException("Duplicate first or second");
154 
155       firstToSecond.Add(first, second);
156       secondToFirst.Add(second, first);
157     }
158 
159     public bool ContainsFirst(TFirst first)
160     {
161       return firstToSecond.ContainsKey(first);
162     }
163 
164     public bool ContainsSecond(TSecond second)
165     {
166       return secondToFirst.ContainsKey(second);
167     }
168 
169     public TSecond GetByFirst(TFirst first)
170     {
171       TSecond second;
172       if (!firstToSecond.TryGetValue(first, out second))
173         throw new KeyNotFoundException("Cannot find second by first.");
174 
175       return second;
176     }
177 
178     public TFirst GetBySecond(TSecond second)
179     {
180       TFirst first;
181       if (!secondToFirst.TryGetValue(second, out first))
182         throw new KeyNotFoundException("Cannot find first by second.");
183 
184       return first;
185     }
186 
187     public void RemoveByFirst(TFirst first)
188     {
189       TSecond second;
190       if (!firstToSecond.TryGetValue(first, out second))
191         throw new KeyNotFoundException("Cannot find second by first.");
192 
193       firstToSecond.Remove(first);
194       secondToFirst.Remove(second);
195     }
196 
197     public void RemoveBySecond(TSecond second)
198     {
199       TFirst first;
200       if (!secondToFirst.TryGetValue(second, out first))
201         throw new KeyNotFoundException("Cannot find first by second.");
202 
203       secondToFirst.Remove(second);
204       firstToSecond.Remove(first);
205     }
206 
207     public bool TryAdd(TFirst first, TSecond second)
208     {
209       if (firstToSecond.ContainsKey(first) || secondToFirst.ContainsKey(second))
210         return false;
211 
212       firstToSecond.Add(first, second);
213       secondToFirst.Add(second, first);
214       return true;
215     }
216 
217     public bool TryGetByFirst(TFirst first, out TSecond second)
218     {
219       return firstToSecond.TryGetValue(first, out second);
220     }
221 
222     public bool TryGetBySecond(TSecond second, out TFirst first)
223     {
224       return secondToFirst.TryGetValue(second, out first);
225     }
226 
227     public bool TryRemoveByFirst(TFirst first)
228     {
229       TSecond second;
230       if (!firstToSecond.TryGetValue(first, out second))
231         return false;
232 
233       firstToSecond.Remove(first);
234       secondToFirst.Remove(second);
235       return true;
236     }
237 
238     public bool TryRemoveBySecond(TSecond second)
239     {
240       TFirst first;
241       if (!secondToFirst.TryGetValue(second, out first))
242         return false;
243 
244       secondToFirst.Remove(second);
245       firstToSecond.Remove(first);
246       return true;
247     }
248 
249     public int Count
250     {
251       get { return firstToSecond.Count; }
252     }
253 
254     public void Clear()
255     {
256       firstToSecond.Clear();
257       secondToFirst.Clear();
258     }
259 
260     #endregion
261 
262     #region IEnumerable<FirstSecondPair<TFirst,TSecond>> Members
263 
264     IEnumerator<FirstSecondPair<TFirst, TSecond>> IEnumerable<FirstSecondPair<TFirst, TSecond>>.GetEnumerator()
265     {
266       foreach (var item in firstToSecond)
267       {
268         yield return new FirstSecondPair<TFirst, TSecond>(item.Key, item.Value);
269       }
270     }
271 
272     #endregion
273 
274     #region IEnumerable Members
275 
276     IEnumerator IEnumerable.GetEnumerator()
277     {
278       foreach (var item in firstToSecond)
279       {
280         yield return new FirstSecondPair<TFirst, TSecond>(item.Key, item.Value);
281       }
282     }
283 
284     #endregion
285   }
286 
287   public static class ConcurrentDictionaryExtensions
288   {
289     public static TValue Add<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key, TValue @value)
290     {
291       TValue result = collection.AddOrUpdate(key, @value, (k, v) => { return @value; });
292       return result;
293     }
294 
295     public static TValue Update<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key, TValue @value)
296     {
297       TValue result = collection.AddOrUpdate(key, @value, (k, v) => { return @value; });
298       return result;
299     }
300 
301     public static TValue Get<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key)
302     {
303       TValue @value = default(TValue);
304       collection.TryGetValue(key, out @value);
305       return @value;
306     }
307 
308     public static TValue Remove<TKey, TValue>(this ConcurrentDictionary<TKey, TValue> collection, TKey key)
309     {
310       TValue @value = default(TValue);
311       collection.TryRemove(key, out @value);
312       return @value;
313     }
314   }
315 }

实现方式(四):实现 RoundRobin 循环列表。

 1 namespace IteratorPattern.Implementation4
 2 {
 3   /// <summary>
 4   /// 循环列表
 5   /// </summary>
 6   /// <typeparam name="T"></typeparam>
 7   public class RoundRobinCollection<T> : IEnumerable<T>
 8   {
 9     private T[] _items;
10     private int _head;
11 
12     /// <summary>
13     /// 循环列表
14     /// </summary>
15     /// <param name="items">供循环的列表项</param>
16     public RoundRobinCollection(IEnumerable<T> items)
17     {
18       if (items == null || items.Count<T>() == 0)
19       {
20         throw new ArgumentException(
21           "One or more items must be provided", "items");
22       }
23 
24       // copy the list to ensure it doesn't change on us 
25       // (and so we can lock() on our private copy) 
26       _items = items.ToArray();
27     }
28 
29     /// <summary>
30     /// 获取循环器
31     /// </summary>
32     /// <returns></returns>
33     public IEnumerator<T> GetEnumerator()
34     {
35       int currentHead;
36 
37       lock (_items)
38       {
39         currentHead = _head++;
40 
41         if (_head == _items.Length)
42         {
43           // wrap back to the start 
44           _head = 0;
45         }
46       }
47 
48       // return results [current] ... [last] 
49       for (int i = currentHead; i < _items.Length; i++)
50       {
51         yield return _items[i];
52       }
53 
54       // return wrap-around (if any) [0] ... [current-1] 
55       for (int i = 0; i < currentHead; i++)
56       {
57         yield return _items[i];
58       }
59     }
60 
61     /// <summary>
62     /// 获取循环器
63     /// </summary>
64     /// <returns></returns>
65     IEnumerator IEnumerable.GetEnumerator()
66     {
67       return this.GetEnumerator();
68     }
69   }
70 }

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

posted @ 2014-03-29 08:03 匠心十年 阅读(...) 评论(...) 编辑 收藏