原文 第15章 迭代器模式（Iterator Pattern）
概述：
在面向对象的软件设计中，我们经常会遇到一类集合对象，这类集合对象的内部结构可能有着各种各样的实现，但是归结起来，无非有两点是需要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则，所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。
提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。[GOF 《设计模式》]
结构图：
简单示例：可能中间对象引用的地方有点绕，但是写得很精髓
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
/// <summary>
/// 抽象迭代器
/// </summary>
public
interface
Iterator
{
object
GetCurrentItem();
//当前项
bool
MoveNext();
//是否遍历完
void
Next();
//下一个
}
/// <summary>
/// 具体迭代器
/// </summary>
public
class
ConcreteTerator : Iterator
{
public
ConcreteList list;
int
index = 0;
public
ConcreteTerator(ConcreteList list)
{
this
.list = list;
}
public
bool
MoveNext()
{
if
(index < list.Length)
{
return
true
;
}
else
{
return
false
;
}
}
public
object
GetCurrentItem()
{
return
list.GetItem(index);
}
public
void
Next()
{
index++;
}
}
/// <summary>
/// 抽象聚集类
/// </summary>
public
interface
IList
{
//获取迭代器
Iterator GetTerator();
}
/// <summary>
/// 具体聚集类
/// </summary>
public
class
ConcreteList : IList
{
//这里就假设个Int数组对象
public
int
[] list
{
get
;
set
;
}
public
int
Length
{
get
{
return
list.Length;
}
}
public
object
GetItem(
int
i)
{
return
list[i];
}
public
Iterator GetTerator()
{
//把本身传入到迭代器
return
new
ConcreteTerator(
this
);
}
}
//client
class
Program
{
static
void
Main(
string
[] args)
{
ConcreteList list =
new
ConcreteList();
list.list =
new
int
[5] { 1, 2, 3, 4, 5 };
Iterator terator = list.GetTerator();
while
(terator.MoveNext())
{
Console.WriteLine(terator.GetCurrentItem());
terator.Next();
}
Console.ReadLine();
}
}
|
效果：
1．迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。
2．迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。
3．迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。
适用场景：
1．访问一个聚合对象的内容而无需暴露它的内部表示。
2．支持对聚合对象的多种遍历。
3．为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
