一、引言

?? 今天我們開始講“行為型”設計模式的第三個模式，該模式是【迭代器模式】，英文名稱是：Iterator Pattern。還是老套路，先從名字上來看看?！暗髂Ｊ健蔽业谝淮慰吹竭@個名稱，我的理解是，迭代是遍歷的意思，迭代器可以理解為是遍歷某某的工具，遍歷什么呢？在軟件設計中，當然遍歷的是集合對象，所以說迭代器模式是遍歷集合的一種通用的算法。如果集合只有一種類型，那這個模式就沒用了，就是因為集合對象包含數組、列表，字典和哈希表等各種對象，如果為每一種集合對象都實現一套遍歷算法，也不太現實，因此為了解決遍歷集合有一個統一的接口這個事情，所以就提出了“迭代器”這個模式。

二、迭代器模式的詳細介紹

2.1、動機（Motivate）

?? 在軟件構建過程中，集合對象內部結構常常變化各異。但對于這些集合對象，我們希望在不暴露其內部結構的同時，可以讓外部客戶代碼透明地訪問其中包含的元素；同時這種“透明遍歷”也為“同一種算法在多種集合對象上進行操作”提供了可能。

　使用面向對象技術將這種遍歷機制抽象為“迭代器對象”為“應對變化中的集合對象”提供了一種優雅的方式。

2.2、意圖（Intent）

?? 提供一種方法順序訪問一個聚合對象中的各個元素，而又不暴露該對象的內部表示。　　　　　　??????????????????????????????? ——《設計模式》GoF

2.3、結構圖

??????

2.4、模式的組成
?? ?
??? 從迭代器模式的結構圖可以看出，它涉及到四個角色，它們分別是：

??? （1）、抽象迭代器(Iterator)：抽象迭代器定義了訪問和遍歷元素的接口，一般聲明如下方法：用于獲取第一個元素的first()，用于訪問下一個元素的next()，用于判斷是否還有下一個元素的hasNext()，用于獲取當前元素的currentItem()，在其子類中將實現這些方法。

??? （2）、具體迭代器(ConcreteIterator)：具體迭代器實現了抽象迭代器接口，完成對集合對象的遍歷，同時在對聚合進行遍歷時跟蹤其當前位置。

??? （3）、抽象聚合類(Aggregate)：抽象聚合類用于存儲對象，并定義創建相應迭代器對象的接口，聲明一個createIterator()方法用于創建一個迭代器對象。

??? （4）、具體聚合類(ConcreteAggregate)：具體聚合類實現了創建相應迭代器的接口，實現了在抽象聚合類中聲明的createIterator()方法，并返回一個與該具體聚合相對應的具體迭代器ConcreteIterator實例。

2.5、迭代器模式的代碼實現

??? 迭代器模式在現實生活中也有類似的例子，比如：在部隊中，我們可以讓某一隊伍當中的某人出列，或者讓隊列里面的每個人依次報名，其實這個過程就是一個遍歷的過程。沒什么可說的，具體實現代碼如下：

1 namespace 迭代器模式的實現 2 { 3 // 部隊隊列的抽象聚合類--該類型相當于抽象聚合類Aggregate 4 public interface ITroopQueue 5 { 6 Iterator GetIterator(); 7 } 8 9 // 迭代器抽象類 10 public interface Iterator 11 { 12 bool MoveNext(); 13 Object GetCurrent(); 14 void Next(); 15 void Reset(); 16 } 17 18 //部隊隊列具體聚合類--相當于具體聚合類ConcreteAggregate 19 public sealed class ConcreteTroopQueue:ITroopQueue 20 { 21 private string[] collection; 22 23 public ConcreteTroopQueue() 24 { 25 collection = new string[] { "黃飛鴻","方世玉","洪熙官","嚴詠春" }; 26 } 27 28 public Iterator GetIterator() 29 { 30 return new ConcreteIterator(this); 31 } 32 33 public int Length 34 { 35 get { return collection.Length; } 36 } 37 38 public string GetElement(int index) 39 { 40 return collection[index]; 41 } 42 } 43 44 // 具體迭代器類 45 public sealed class ConcreteIterator : Iterator 46 { 47 // 迭代器要集合對象進行遍歷操作，自然就需要引用集合對象 48 private ConcreteTroopQueue _list; 49 private int _index; 50 51 public ConcreteIterator(ConcreteTroopQueue list) 52 { 53 _list = list; 54 _index = 0; 55 } 56 57 public bool MoveNext() 58 { 59 if (_index < _list.Length) 60 { 61 return true; 62 } 63 return false; 64 } 65 66 public Object GetCurrent() 67 { 68 return _list.GetElement(_index); 69 } 70 71 public void Reset() 72 { 73 _index = 0; 74 } 75 76 public void Next() 77 { 78 if (_index < _list.Length) 79 { 80 _index++; 81 } 82 83 } 84 } 85 86 // 客戶端（Client） 87 class Program 88 { 89 static void Main(string[] args) 90 { 91 Iterator iterator; 92 ITroopQueue list = new ConcreteTroopQueue(); 93 iterator = list.GetIterator(); 94 95 while (iterator.MoveNext()) 96 { 97 string ren = (string)iterator.GetCurrent(); 98 Console.WriteLine(ren); 99 iterator.Next(); 100 } 101 102 Console.Read(); 103 } 104 } 105 }

??
三、迭代器模式的實現要點：
?? ?
???? 1、迭代抽象：訪問一個聚合對象的內容而無需暴露它的內部表示。

???? 2、迭代多態：為遍歷不同的集合結構提供一個統一的接口，從而支持同樣的算法在不同的集合結構上進行操作。

???? 3、迭代器的健壯性考慮：遍歷的同時更改迭代器所在的集合結構，會導致問題。
????
???? 3.1】、迭代器模式的優點：

????????? （1）、迭代器模式使得訪問一個聚合對象的內容而無需暴露它的內部表示，即迭代抽象。

????????? （2）、迭代器模式為遍歷不同的集合結構提供了一個統一的接口，從而支持同樣的算法在不同的集合結構上進行操作

??? 3.2】、迭代器模式的缺點：

????????? （1）、迭代器模式在遍歷的同時更改迭代器所在的集合結構會導致出現異常。所以使用foreach語句只能在對集合進行遍歷，不能在遍歷的同時更改集合中的元素。

???? 3.3】、迭代器模式的使用場景：

?????? （1）、訪問一個聚合對象的內容而無需暴露它的內部表示。

?????? （2）、支持對聚合對象的多種遍歷。

?????? （3）、為遍歷不同的聚合結構提供一個統一的接口(即, 支持多態迭代)。

四、.NET 中迭代器模式的實現

???? 在mscorlib程序集里有這樣一個命名空間，該命名空間就是：System.Collections，在該命名空間里面早已有了迭代器模式的實現。對于聚集接口和迭代器接口已經存在了，其中IEnumerator扮演的就是迭代器的角色，它的實現如下：

public interface IEnumerator{object Current{get;}bool MoveNext();void Reset();}

???? 屬性Current返回當前集合中的元素，Reset()方法恢復初始化指向的位置，MoveNext()方法返回值true表示迭代器成功前進到集合中的下一個元素，返回值false表示已經位于集合的末尾。能夠提供元素遍歷的集合對象，在.Net中都實現了IEnumerator接口。

???? IEnumerable則扮演的就是抽象聚集的角色，只有一個GetEnumerator()方法，如果集合對象需要具備跌代遍歷的功能，就必須實現該接口。

public interface IEnumerable {IEumerator GetEnumerator(); }

??? 抽象聚合角色（Aggregate）和抽象迭代器角色（Iterator）分別是IEnumerable接口和IEnumerator接口，具體聚合角色（ConcreteAggregate）有Queue類型，?BitArray等類型，代碼如下：

1 public sealed class BitArray : ICollection, IEnumerable, ICloneable 2 { 3 [Serializable] 4 private class BitArrayEnumeratorSimple : IEnumerator, ICloneable 5 { 6 private BitArray bitarray; 7 8 private int index; 9 10 private int version; 11 12 private bool currentElement; 13 14 public virtual object Current 15 { 16 get 17 { 18 if (this.index == -1) 19 { 20 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumNotStarted")); 21 } 22 if (this.index >= this.bitarray.Count) 23 { 24 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumEnded")); 25 } 26 return this.currentElement; 27 } 28 } 29 30 internal BitArrayEnumeratorSimple(BitArray bitarray) 31 { 32 this.bitarray = bitarray; 33 this.index = -1; 34 this.version = bitarray._version; 35 } 36 37 public object Clone() 38 { 39 return base.MemberwiseClone(); 40 } 41 42 public virtual bool MoveNext() 43 { 44 if (this.version != this.bitarray._version) 45 { 46 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion")); 47 } 48 if (this.index < this.bitarray.Count - 1) 49 { 50 this.index++; 51 this.currentElement = this.bitarray.Get(this.index); 52 return true; 53 } 54 this.index = this.bitarray.Count; 55 return false; 56 } 57 58 public void Reset() 59 { 60 if (this.version != this.bitarray._version) 61 { 62 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EnumFailedVersion")); 63 } 64 this.index = -1; 65 } 66 } 67 68 private const int BitsPerInt32 = 32; 69 70 private const int BytesPerInt32 = 4; 71 72 private const int BitsPerByte = 8; 73 74 private int[] m_array; 75 76 private int m_length; 77 78 private int _version; 79 80 [NonSerialized] 81 private object _syncRoot; 82 83 private const int _ShrinkThreshold = 256; 84 85 [__DynamicallyInvokable] 86 public bool this[int index] 87 { 88 [__DynamicallyInvokable] 89 get 90 { 91 return this.Get(index); 92 } 93 [__DynamicallyInvokable] 94 set 95 { 96 this.Set(index, value); 97 } 98 } 99 100 [__DynamicallyInvokable] 101 public int Length 102 { 103 [__DynamicallyInvokable] 104 get 105 { 106 return this.m_length; 107 } 108 [__DynamicallyInvokable] 109 set 110 { 111 if (value < 0) 112 { 113 throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 114 } 115 int arrayLength = BitArray.GetArrayLength(value, 32); 116 if (arrayLength > this.m_array.Length || arrayLength + 256 < this.m_array.Length) 117 { 118 int[] array = new int[arrayLength]; 119 Array.Copy(this.m_array, array, (arrayLength > this.m_array.Length) ? this.m_array.Length : arrayLength); 120 this.m_array = array; 121 } 122 if (value > this.m_length) 123 { 124 int num = BitArray.GetArrayLength(this.m_length, 32) - 1; 125 int num2 = this.m_length % 32; 126 if (num2 > 0) 127 { 128 this.m_array[num] &= (1 << num2) - 1; 129 } 130 Array.Clear(this.m_array, num + 1, arrayLength - num - 1); 131 } 132 this.m_length = value; 133 this._version++; 134 } 135 } 136 137 public int Count 138 { 139 get 140 { 141 return this.m_length; 142 } 143 } 144 145 public object SyncRoot 146 { 147 get 148 { 149 if (this._syncRoot == null) 150 { 151 Interlocked.CompareExchange<object>(ref this._syncRoot, new object(), null); 152 } 153 return this._syncRoot; 154 } 155 } 156 157 public bool IsReadOnly 158 { 159 get 160 { 161 return false; 162 } 163 } 164 165 public bool IsSynchronized 166 { 167 get 168 { 169 return false; 170 } 171 } 172 173 private BitArray() 174 { 175 } 176 177 [__DynamicallyInvokable] 178 public BitArray(int length) : this(length, false) 179 { 180 } 181 182 [__DynamicallyInvokable] 183 public BitArray(int length, bool defaultValue) 184 { 185 if (length < 0) 186 { 187 throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 188 } 189 this.m_array = new int[BitArray.GetArrayLength(length, 32)]; 190 this.m_length = length; 191 int num = defaultValue ? -1 : 0; 192 for (int i = 0; i < this.m_array.Length; i++) 193 { 194 this.m_array[i] = num; 195 } 196 this._version = 0; 197 } 198 199 [__DynamicallyInvokable] 200 public BitArray(byte[] bytes) 201 { 202 if (bytes == null) 203 { 204 throw new ArgumentNullException("bytes"); 205 } 206 if (bytes.Length > 268435455) 207 { 208 throw new ArgumentException(Environment.GetResourceString("Argument_ArrayTooLarge", new object[] 209 { 210 8 211 }), "bytes"); 212 } 213 this.m_array = new int[BitArray.GetArrayLength(bytes.Length, 4)]; 214 this.m_length = bytes.Length * 8; 215 int num = 0; 216 int num2 = 0; 217 while (bytes.Length - num2 >= 4) 218 { 219 this.m_array[num++] = ((int)(bytes[num2] & 255) | (int)(bytes[num2 + 1] & 255) << 8 | (int)(bytes[num2 + 2] & 255) << 16 | (int)(bytes[num2 + 3] & 255) << 24); 220 num2 += 4; 221 } 222 switch (bytes.Length - num2) 223 { 224 case 1: 225 goto IL_103; 226 case 2: 227 break; 228 case 3: 229 this.m_array[num] = (int)(bytes[num2 + 2] & 255) << 16; 230 break; 231 default: 232 goto IL_11C; 233 } 234 this.m_array[num] |= (int)(bytes[num2 + 1] & 255) << 8; 235 IL_103: 236 this.m_array[num] |= (int)(bytes[num2] & 255); 237 IL_11C: 238 this._version = 0; 239 } 240 241 [__DynamicallyInvokable] 242 public BitArray(bool[] values) 243 { 244 if (values == null) 245 { 246 throw new ArgumentNullException("values"); 247 } 248 this.m_array = new int[BitArray.GetArrayLength(values.Length, 32)]; 249 this.m_length = values.Length; 250 for (int i = 0; i < values.Length; i++) 251 { 252 if (values[i]) 253 { 254 this.m_array[i / 32] |= 1 << i % 32; 255 } 256 } 257 this._version = 0; 258 } 259 260 [__DynamicallyInvokable] 261 public BitArray(int[] values) 262 { 263 if (values == null) 264 { 265 throw new ArgumentNullException("values"); 266 } 267 if (values.Length > 67108863) 268 { 269 throw new ArgumentException(Environment.GetResourceString("Argument_ArrayTooLarge", new object[] 270 { 271 32 272 }), "values"); 273 } 274 this.m_array = new int[values.Length]; 275 this.m_length = values.Length * 32; 276 Array.Copy(values, this.m_array, values.Length); 277 this._version = 0; 278 } 279 280 [__DynamicallyInvokable] 281 public BitArray(BitArray bits) 282 { 283 if (bits == null) 284 { 285 throw new ArgumentNullException("bits"); 286 } 287 int arrayLength = BitArray.GetArrayLength(bits.m_length, 32); 288 this.m_array = new int[arrayLength]; 289 this.m_length = bits.m_length; 290 Array.Copy(bits.m_array, this.m_array, arrayLength); 291 this._version = bits._version; 292 } 293 294 [__DynamicallyInvokable] 295 public bool Get(int index) 296 { 297 if (index < 0 || index >= this.Length) 298 { 299 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index")); 300 } 301 return (this.m_array[index / 32] & 1 << index % 32) != 0; 302 } 303 304 [__DynamicallyInvokable] 305 public void Set(int index, bool value) 306 { 307 if (index < 0 || index >= this.Length) 308 { 309 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index")); 310 } 311 if (value) 312 { 313 this.m_array[index / 32] |= 1 << index % 32; 314 } 315 else 316 { 317 this.m_array[index / 32] &= ~(1 << index % 32); 318 } 319 this._version++; 320 } 321 322 [__DynamicallyInvokable] 323 public void SetAll(bool value) 324 { 325 int num = value ? -1 : 0; 326 int arrayLength = BitArray.GetArrayLength(this.m_length, 32); 327 for (int i = 0; i < arrayLength; i++) 328 { 329 this.m_array[i] = num; 330 } 331 this._version++; 332 } 333 334 [__DynamicallyInvokable] 335 public BitArray And(BitArray value) 336 { 337 if (value == null) 338 { 339 throw new ArgumentNullException("value"); 340 } 341 if (this.Length != value.Length) 342 { 343 throw new ArgumentException(Environment.GetResourceString("Arg_ArrayLengthsDiffer")); 344 } 345 int arrayLength = BitArray.GetArrayLength(this.m_length, 32); 346 for (int i = 0; i < arrayLength; i++) 347 { 348 this.m_array[i] &= value.m_array[i]; 349 } 350 this._version++; 351 return this; 352 } 353 354 [__DynamicallyInvokable] 355 public BitArray Or(BitArray value) 356 { 357 if (value == null) 358 { 359 throw new ArgumentNullException("value"); 360 } 361 if (this.Length != value.Length) 362 { 363 throw new ArgumentException(Environment.GetResourceString("Arg_ArrayLengthsDiffer")); 364 } 365 int arrayLength = BitArray.GetArrayLength(this.m_length, 32); 366 for (int i = 0; i < arrayLength; i++) 367 { 368 this.m_array[i] |= value.m_array[i]; 369 } 370 this._version++; 371 return this; 372 } 373 374 [__DynamicallyInvokable] 375 public BitArray Xor(BitArray value) 376 { 377 if (value == null) 378 { 379 throw new ArgumentNullException("value"); 380 } 381 if (this.Length != value.Length) 382 { 383 throw new ArgumentException(Environment.GetResourceString("Arg_ArrayLengthsDiffer")); 384 } 385 int arrayLength = BitArray.GetArrayLength(this.m_length, 32); 386 for (int i = 0; i < arrayLength; i++) 387 { 388 this.m_array[i] ^= value.m_array[i]; 389 } 390 this._version++; 391 return this; 392 } 393 394 [__DynamicallyInvokable] 395 public BitArray Not() 396 { 397 int arrayLength = BitArray.GetArrayLength(this.m_length, 32); 398 for (int i = 0; i < arrayLength; i++) 399 { 400 this.m_array[i] = ~this.m_array[i]; 401 } 402 this._version++; 403 return this; 404 } 405 406 public void CopyTo(Array array, int index) 407 { 408 if (array == null) 409 { 410 throw new ArgumentNullException("array"); 411 } 412 if (index < 0) 413 { 414 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 415 } 416 if (array.Rank != 1) 417 { 418 throw new ArgumentException(Environment.GetResourceString("Arg_RankMultiDimNotSupported")); 419 } 420 if (array is int[]) 421 { 422 Array.Copy(this.m_array, 0, array, index, BitArray.GetArrayLength(this.m_length, 32)); 423 return; 424 } 425 if (array is byte[]) 426 { 427 int arrayLength = BitArray.GetArrayLength(this.m_length, 8); 428 if (array.Length - index < arrayLength) 429 { 430 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen")); 431 } 432 byte[] array2 = (byte[])array; 433 for (int i = 0; i < arrayLength; i++) 434 { 435 array2[index + i] = (byte)(this.m_array[i / 4] >> i % 4 * 8 & 255); 436 } 437 return; 438 } 439 else 440 { 441 if (!(array is bool[])) 442 { 443 throw new ArgumentException(Environment.GetResourceString("Arg_BitArrayTypeUnsupported")); 444 } 445 if (array.Length - index < this.m_length) 446 { 447 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen")); 448 } 449 bool[] array3 = (bool[])array; 450 for (int j = 0; j < this.m_length; j++) 451 { 452 array3[index + j] = ((this.m_array[j / 32] >> j % 32 & 1) != 0); 453 } 454 return; 455 } 456 } 457 458 public object Clone() 459 { 460 return new BitArray(this.m_array) 461 { 462 _version = this._version, 463 m_length = this.m_length 464 }; 465 } 466 467 [__DynamicallyInvokable] 468 public IEnumerator GetEnumerator() 469 { 470 return new BitArray.BitArrayEnumeratorSimple(this); 471 } 472 473 private static int GetArrayLength(int n, int div) 474 { 475 if (n <= 0) 476 { 477 return 0; 478 } 479 return (n - 1) / div + 1; 480 } 481 }

?? 還有很多類型，就不一一列舉了，大家可以查看源代碼，每個元素都可以在迭代器模式的構造圖上找到對應的元素。

?? 具體的類型和代碼截圖如下：

?????
??
五、總結

??? 今天到此就把迭代器模式寫完了，該模式不是很難，結構也不是很復雜，Net框架里面也有現成的實現。并且在 Net 2.0里面還有升級的實現，要想學習該模式，可以好好看看該模式在Net 框架中的實現，受益匪淺。

總結

以上是生活随笔為你收集整理的C#设计模式之十五迭代器模式（Iterator Pattern）【行为型】的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。