转载自：http://www.cnblogs.com/kenshincui/archive/2011/04/04/2005297.html
摘要：迭代器是C#2.0中添加的功能，它能够使我们在类或结构中支持foreach迭代，而不必实现整个IEnumerable/IEnumerable接口。今天我们就一块看一下什么是c#中的迭代器吧。
主要内容：
1.foreach的运行机制
2.传统集合的遍历
3.使用迭代器
一、foreach的运行机制
我们在程序中经常会用到foreach，如果你把它理解成是for的一种简写形式的话那就太大材小用了，事实上foreach中包含了丰富的内容。我们知道要使用foreach遍历集合就必须实现IEnumerable接口，而要实现IEnumerable接口就要实现IEnumerator接口。关于如何实现这两个接口我们在第二部分会看到，在谈foreach的运行机制之前请允许我使用msdn中的Person类（我们下面的几部分中我们还会用到相关的People和PeopleEnum类）：
1
using
System;
2
using
System.Collections.Generic;
3
using
System.Linq;
4
using
System.Text;
5
6
namespace
IteratorDemo
7
{
8
class
Person
9
{
10
public
Person(
string
fName,
string
lName)
11
{
12
this
.firstName
=
fName;
13
this
.lastName
=
lName;
14
}
15
16
public
string
firstName;
17
public
string
lastName;
18
}
19
}
当然具体细节我就不再说了，有了上面的Person类我们就可以运行下面的代码了：
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
Program
10
{
11
static
void
Main(
string
[] args)
12
{
13
Person[] persons
=
new
Person[] {
14
new
Person(
"
Kenshin
"
,
"
Cui
"
),
15
new
Person(
"
Miaoer
"
,
"
Sun
"
),
16
new
Person(
"
Jinjuan
"
,
"
Shen
"
),
17
new
Person(
"
Yanxin
"
,
"
Nie
"
)
18
};
19
foreach
(Person p
in
persons)
20
{
21
Console.WriteLine(p.firstName
+
"
"
+
p.lastName);
22
}
23
Console.Read();
24
}
25
26
}
27
}
具体的运行结果也没有什么可说的，可是为什么会有这样的结果呢？原因可以分两层来解释：第一就是我们的Persons是使用[]符号声明，这是一个Array类的记号。而Array类实现了IEnumerable接口中GetEnumerator()方法，因此它可以使用foreach进行迭代；第二，之所以实现IEnumerable接口的GetEnumerator()方法就能够迭代是因为foreach将上面的代码解析成如下的形式：
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
Program
10
{
11
static
void
Main(
string
[] args)
12
{
13
Person[] persons
=
new
Person[] {
14
new
Person(
"
Kenshin
"
,
"
Cui
"
),
15
new
Person(
"
Miaoer
"
,
"
Sun
"
),
16
new
Person(
"
Jinjuan
"
,
"
Shen
"
),
17
new
Person(
"
Yanxin
"
,
"
Nie
"
)
18
};
19
20
//
等价的方法
21
IEnumerator enuerator
=
persons.GetEnumerator();
22
while
(enuerator.MoveNext())
23
{
24
Person p
=
enuerator.Current
as
Person;
25
Console.WriteLine(p.firstName
+
"
"
+
p.lastName);
26
}
27
Console.Read();
28
}
29
30
}
31
}
我们知道GetEnumerator()方法返回一个IEnumerator类型的接口，在IEnumerator接口中有一个Current属性来返回当前元素，而其MoveNext()方法又可以移动到集合的下一个元素（有则返回true，无则返回false），如此反复就形成了对整个集合的迭代（具体原理可以参见上面链接的内容）。
二、传统集合的遍历
上面我们谈到Array类实现了IEnumerable接口中的GetEnumerator()方法，因此可以使用foreach来循环遍历，那么我们自己当然也同样可以实现相关接口。
People类
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
People:IEnumerable
10
{
11
private
Person[] _people;
12
public
People(Person[] pArray)
13
{
14
_people
=
new
Person[pArray.Length];
15
16
for
(
int
i
=
0
; i
<
pArray.Length; i
++
)
17
{
18
_people[i]
=
pArray[i];
19
}
20
}
21
22
public
IEnumerator GetEnumerator()
23
{
24
return
new
PeopleEnum(_people);
25
}
26
}
27
}
PeopleEnum类
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
PeopleEnum:IEnumerator
10
{
11
public
Person[] _people;
12
int
position
=
-
1
;
13
14
public
PeopleEnum(Person[] list)
15
{
16
_people
=
list;
17
}
18
19
public
bool
MoveNext()
20
{
21
position
++
;
22
return
(position
<
_people.Length);
23
}
24
25
public
void
Reset()
26
{
27
position
=
-
1
;
28
}
29
30
public
object
Current
31
{
32
get
33
{
34
try
35
{
36
return
_people[position];
37
}
38
catch
(IndexOutOfRangeException)
39
{
40
throw
new
InvalidOperationException();
41
}
42
}
43
}
44
}
45
}
在上面People类就实现了IEnumerable接口（当然截至到目前其相关内容也必须实现IEnumerator类），因此我们就可以遍历People类：
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
Program
10
{
11
/*
12
* 实现IEnumerable（显然目前我们必须先实现IEnumerator）
13
*/
14
static
void
Main(
string
[] args)
15
{
16
Person[] persons
=
new
Person[] {
17
new
Person(
"
Kenshin
"
,
"
Cui
"
),
18
new
Person(
"
Miaoer
"
,
"
Sun
"
),
19
new
Person(
"
Jinjuan
"
,
"
Shen
"
),
20
new
Person(
"
Yanxin
"
,
"
Nie
"
)
21
};
22
People pe
=
new
People(persons);
23
foreach
(Person p
in
pe)
24
{
25
Console.WriteLine(p.firstName
+
"
"
+
p.lastName);
26
}
27
Console.Read();
28
}
29
30
}
31
}
三、使用迭代器
截止到现在我们可以看到如果让一个类或结构支持foreach就必须实现整个IEnumerable接口，这显然过于麻烦，毕竟我们不想在这方面花费太多的时间，那么此时我们就来使用迭代器吧。创建迭代器的最常用的方法就是对IEnumerable接口实现GetEnumerator()方法，例如将上面的People类可以写成这样：
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
People:IEnumerable
10
{
11
private
Person[] _people;
12
public
People(Person[] pArray)
13
{
14
_people
=
new
Person[pArray.Length];
15
16
for
(
int
i
=
0
; i
<
pArray.Length; i
++
)
17
{
18
_people[i]
=
pArray[i];
19
}
20
}
21
22
public
IEnumerator GetEnumerator()
23
{
24
for
(
int
i
=
0
; i
<
_people.Length;
++
i)
25
{
26
yield
return
_people[i];
27
}
28
}
29
}
30
}
从上面我们可以看到我们完全省略了创建PeopleEnum的过程（事实上我们还可以更简单，下面我们就可以看到，这里主要为了和上面的例子做个对比），当然这一切都归功于迭代器的功劳。迭代器使用yield return语句返回每个元素，yield break终止迭代（其返回类型必须为IEnumerable/IEnumerable、IEnumerator/Ienumerator类型）。yield关键字用于指定返回值，到达yield break时会保存当前位置，直到下次调用迭代器时将从此位置从新开始执行。当编译器见到迭代器时，会自动生成IEnumerable/IEnumerable接口的Current、MoveNext和Dispose方法。
当然可能有朋友到现在还有些模糊，那么您不妨简单的理解为：迭代器就是使用yield帮助我们省去了实现IEnumerator的麻烦（虽然，事实上远不止那么简单）。
之所以今天会想起这个话题，其实是因为偶然看到一段类似下面代码：
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
Program
10
{
11
private
static
IList
<
Person
>
FilterPeople(IEnumerable
<
Person
>
people)
12
{
13
IList
<
Person
>
persons
=
new
List
<
Person
>
();
14
foreach
(Person p
in
people)
15
{
16
if
(p.lastName
==
"
Cui
"
)
17
{
18
persons.Add(p);
19
}
20
}
21
return
persons;
22
}
23
static
void
Main(
string
[] args)
24
{
25
Person[] persons
=
new
Person[] {
26
new
Person(
"
Kenshin
"
,
"
Cui
"
),
27
new
Person(
"
Miaoer
"
,
"
Sun
"
),
28
new
Person(
"
Jinjuan
"
,
"
Shen
"
),
29
new
Person(
"
Yanxin
"
,
"
Nie
"
)
30
};
31
foreach
(Person p
in
FilterPeople(persons))
32
{
33
Console.WriteLine(p.firstName
+
"
"
+
p.lastName);
34
}
35
Console.Read();
36
}
37
}
38
}
想象一下如果使用迭代块（包含yield语句的方法或属性）会不会更优雅呢：
1
using
System;
2
using
System.Collections;
3
using
System.Collections.Generic;
4
using
System.Linq;
5
using
System.Text;
6
7
namespace
IteratorDemo
8
{
9
class
Program
10
{
11
/*
12
* 使用迭代快简化类似的方法
13
*/
14
private
static
IEnumerable
<
Person
>
FilterPeople(IEnumerable
<
Person
>
people)
15
{
16
foreach
(Person p
in
people)
17
{
18
if
(p.lastName
==
"
Cui
"
)
19
{
20
yield
return
p;
21
}
22
}
23
}
24
static
void
Main(
string
[] args)
25
{
26
Person[] persons
=
new
Person[] {
27
new
Person(
"
Kenshin
"
,
"
Cui
"
),
28
new
Person(
"
Miaoer
"
,
"
Sun
"
),
29
new
Person(
"
Jinjuan
"
,
"
Shen
"
),
30
new
Person(
"
Yanxin
"
,
"
Nie
"
)
31
};
32
foreach
(Person p
in
FilterPeople(persons))
33
{
34
Console.WriteLine(p.firstName
+
"
"
+
p.lastName);
35
}
36
Console.Read();
37
}
38
}
39
}
1394
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
