C#迭代器——由foreach说开去

痴心易碎 提交于 2019-11-28 19:27:14

原文链接:https://blog.csdn.net/u013477973/article/details/65635737

 

C#迭代器——由foreach说开去
foreach在数组集合的遍历时会被经常用到,例如:

string[] strs = new string[] { "red", "green","blue" };
foreach (var item in strs)
{
Console.WriteLine(item);
}
1
2
3
4
5
使用foreach做遍历确实很方便,然而并不是每一种类型都能使用foreach进行遍历操作,只有实现了IEnumerable接口的类(也叫做可枚举类型)才能进行foreach的遍历操作,集合和数组已经实现了这个接口,所以能进行foreach的遍历操作

IEnumerable和IEnumerator
IEnumerable叫做可枚举接口,它的成员只有一个

GetEnumerator()
返回一个枚举器对象,即实现了IEnumerator接口的类的实例,实现IEnumerator接口的枚举器包含3个函数成员:

Current属性
MoveNext()方法
Reset()方法
Current属性为只读属性,返回枚举序列中的当前位置,MoveNext()把枚举器的位置前进到下一项,返回布尔值,新的位置若是有效的,返回true,否则返回false,ReSet()将位置重置为原始状态。
举个例子,实现自己的可枚举类型,先实现IEnumerator枚举器类型:

class Enumerator1<T> : IEnumerator<T> {
private int _position = -1;
private T[] t;
public Enumerator1(T[] a) {
t = new T[a.Length];
for (int i = 0; i < t.Length; i++) {
t[i] = a[i];
}
}
public T Current
{
get
{
if (_position == -1) {
throw new InvalidOperationException();
}
return t[_position];
}
}
object IEnumerator.Current
{
get
{
if (_position == -1)
{
throw new InvalidOperationException();
}
return t[_position];
}
}
public void Dispose()
{
}
public bool MoveNext()
{
Console.WriteLine("Call Move Next");
if (_position >= t.Length)
return false;
else
{
_position++;
return _position < t.Length;
}
}
public void Reset()
{
_position = -1;
}
}
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
这里实现的是IEnumerator泛型枚举器类,泛型枚举器类的实现中包含一个非泛型的Current属性,返回Object对象的引用,枚举器开始位置的状态为第一个元素之前,_position为-1,因此当我们取到Current之前,应先调用一次MoveNext(),才能得到可枚举项中的第一项,当位置到达可枚举项的最后一项,再次调用MoveNext(),会返回false,取值过程终止,除非位置被重置。
再来实现IEnumerable枚举类型:

class Enumeratable1<T> : IEnumerable<T>
{
private T[] t;
public Enumeratable1(T[] a) {
t = new T[a.Length];
for (int i = 0; i < t.Length; i++) {
t[i] = a[i];
}
}
public IEnumerator<T> GetEnumerator()
{
return new Enumerator1<T>(t);
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator1<T>(t);
}
}`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
这里实现的IEnumerable泛型枚举类,泛型枚举类的实现中包含一个非泛型的GetEnumerator方法,GetEnumerator返回的为之前创建的Enumerator1的泛型构造类的实例,使用泛型数组作为参数传入构造函数,创建Enumerator1的枚举器对象。
下面使用foreach对Enumerable1的实例进行遍历:

static void Main() {
string[] strs = new string[] { "red", "green", "blue" };
int[] nums = new int[] { 1, 2, 3, 4, 5 };
Enumeratable1<string> strEnum = new Enumeratable1<string>(strs);
Enumeratable1<int> numEnum = new Enumeratable1<int>(nums);
foreach (var temp in strEnum)
{
Console.WriteLine(temp);
}
Console.ReadKey();
}
1
2
3
4
5
6
7
8
9
10
11
输出结果:


在实现MoveNext()方法时,添加了一行输出,从输出结果可以看出,用foreach做遍历时,先调用了MoveNext()方法,再调用Current属性获得当前项,当取到最后一项时,并没有退出枚举过程,而是再次调用MoveNext()方法,返回值为false后,才退出枚举过程。

迭代器 和 yield return
当我们自己实现可枚举类型,在foreach中完成遍历时,需要手动实现IEnumerable枚举接口和IEnumerator枚举器接口。C#2.0以后提供了更为简单的方式去创建可枚举类型和枚举器,那就是迭代器,迭代器会生成枚举类型和枚举器类型。
举个栗子:

public IEnumerator<string> Color() //迭代器
{
yield return "red";
yield return "green";
yield return "blue";
}
1
2
3
4
5
6
以上代码就是一个迭代器创建枚举器的过程,如果手动创建枚举器,是需要实现IEnumerator的接口的,而在这里,并没有实现Current,MoveNext(),Reset这些成员,取而代之使用的是yield return语句,简单来说迭代器就是使用一个或多个yield return语句告诉编译器创建枚举器类,yield return语句指定了枚举器中下一个可枚举项,完整的代码:

class Program{
static void Main()
{
ColorEnumerable color = new ColorEnumerable();
foreach (var item in color)
{
Console.WriteLine(item);
}
Console.ReadKey();
}}
class ColorEnumerable {
public IEnumerator<string> GetEnumerator()
{
return Color();
}
public IEnumerator<string> Color()
{
yield return "red";
yield return "green";
yield return "blue";
}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ColorEnumeable类实现了GetEnumerator()方法,为可枚举类型。迭代器可以返回一个枚举器类型,也可以返回一个可枚举类型,例如:

public IEnumerable<string> Color() {
yield return "red2";
yield return "green2";
yield return "blue2";
}
1
2
3
4
5
以上代码是利用迭代器返回一个IEnumerable的可枚举类型,完整的代码如下:

class Program{
static void Main()
{
ColorEnumerable2 color2 = new ColorEnumerable2();
foreach (var item in color2.Color())
{
Console.WriteLine(item);
}
Console.ReadKey();
}}
class ColorEnumerable2 {
public IEnumerable<string> Color() {
yield return "red2";
yield return "green2";
yield return "blue2";
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
在foreach的语句中用的是color2.Color(),而不是像上一个例子中直接使用的color,这是因为ColorEnumerable类中已经公开实现了GetEnumerator()方法,但在ColorEnumerable2类中并没有公开实现,所以不能使用foreach直接遍历ColorEnumerable2类的实例,但ColorEnumerable2的方法Color()使用迭代器创建了可枚举类,已经实现了GetEnumerator()方法,所以使用color2.Color()可以得到可枚举类在foreach中进行遍历。我们对ColorEnumerable2作如下修改:

class ColorEnumerable2 {
public IEnumerator<string> GetEnumerator() {
return Color().GetEnumerator();
}
public IEnumerable<string> Color() {
yield return "red2";
yield return "green2";
yield return "blue2";
}
}
1
2
3
4
5
6
7
8
9
10
便可以在foreach的语句中直接使用ColorEnumerable2的实例进行遍历了。总结一下就是:

yield reutrn可以根据返回类型告诉编译器创建可枚举类或者是枚举器
yield return 语句指定了枚举器对象中的下一个可枚举项
迭代器的执行顺序
当创建完一个可枚举类型(不管是手动实现或是使用迭代器创建),枚举器实际上可以看做是包含4个状态的状态机(参考C#图解教程):

Before 首次调用MoveNext()时的状态,初始位置在第一个可枚举项之前
Running 调用MoveNext后进入该状态。在Running状态下,枚举器检测下一项的位置,当遇到yield return时会进入挂起状态,直到遇到下一个MoveNext(),当遇到yield break时或迭代器结束时,会退出状态
Suspended 暂时挂起状态,等待下一次MoveNext()调用时唤醒
After 已经到最后的位置,没有可枚举项
如下图所示:


通过代码来具体看这个过程:

class Program
{
static readonly String Padding = new String(' ', 35);
static IEnumerable<Int32> Enumerable() {
try {
Console.WriteLine("{0}进入Enumerable方法", Padding);
for (int i = 0; i < 4; i++)
{
Console.WriteLine("{0}yield return {1} 开始",Padding,i);
yield return i;
Console.WriteLine("{0}yield return {1} 结束",Padding,i);
}
Console.WriteLine("{0}最后一个yield return 开始", Padding);
yield return -1;
Console.WriteLine("{0}最后一个yield return 结束", Padding);
}
finally
{
Console.WriteLine("{0}Enumerable方法结束",Padding);
}
}
static void Main(string[] args)
{
IEnumerable<Int32> ie = Enumerable();
IEnumerator<Int32> ietor = ie.GetEnumerator();
Console.WriteLine("开始迭代");
while (true) {
Console.WriteLine("调用MoveNext()之前");
bool result=ietor.MoveNext();
Console.WriteLine("调用MoveNext()之后,值为:{0}", result);
if (!result) {
break;
}
Console.WriteLine("Current值为:{0}",ietor.Current);
}
Console.ReadKey();
}
}
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
为了调用枚举器中的MoveNext()方法,使用while循环进行遍历,输出的结果:

从输出结果可以看出:

直到调用MoveNext()后才进入迭代器的方法
遇到yield return,进入暂停挂起状态,,回到开始调用的地方,获取Current,位置被移到下一项
再次遇到MoveNext()方法,暂停挂起的状态回到运行状态,此时再次遇到yield return,重复暂停挂起的过程
当进行到最后一项时,迭代器并没有立即结束,而是又执行了一次MoveNext()方法,此时MoveNext()返回的值为false,执行finally中的代码,退出迭代器
迭代器的退出除了当迭代器状态结束时会发生,使用yield break也会使迭代器退出:

try {
Console.WriteLine("{0}进入Enumerable方法", Padding);
for (int i = 0; i < 4; i++)
{
Console.WriteLine("{0}yield return {1} 开始",Padding,i);
yield return i;
Console.WriteLine("{0}yield return {1} 结束",Padding,i);
}
yield break;
Console.WriteLine("{0}最后一个yield return 开始", Padding);
yield return -1;
Console.WriteLine("{0}最后一个yield return 结束", Padding);
}
finally
{
Console.WriteLine("{0}Enumerable方法结束", Padding);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
输出结果:

 

在迭代器的foreach循环结束后使用yield break语句,yield break 语句后的迭代过程并没有进行,而是把MoveNext()的返回值设置为false,调用MoveNext()方法后进入到finally中,结束迭代过程。关于迭代器的退出:

在正常迭代进行到最后一项时,迭代没有结束MoveNext()的值被设置为false,再次调用MoveNext(),结束迭代过程
遇到yield break语句,MoveNext()的值被设置为false,再次调用MoveNext(),结束迭代过程
yield return语句只是让迭代器状态暂停挂起,等待下一次的MoveNext()调用,继续进行yield之后的语句
Unity中的StartCoroutine与yield return
使用过Unity的延时WaitForSeconds()的朋友们一定不会对StartCoroutine和yield return这两个关键字感到陌生。UnityGems.com给出了协程的定义:
A coroutine is a function that is executed partially and, presuming suitable conditions are met, will be resumed at some point in the future until its work is done.
即协程是一个分部执行,遇到条件(yield return 语句)会挂起,直到条件满足才会被唤醒继续执行后面的代码。
先来个例子:

bool isStartCall = false;
bool isUpdateCall = false;
bool isLateUpdateCall = false;
void Start () {
if (!isStartCall) {
Debug.Log("Start Call Begin");
StartCoroutine("StartCoroutines");
Debug.Log("Start Call End");
isStartCall = true;
}
}
IEnumerator StartCoroutines() {
Debug.Log("StartCoroutine Call Begin");
yield return null;
Debug.Log("StartCoroutine Call End");
}
void Update() {
if (!isUpdateCall) {
Debug.Log("Update Call Begin");
StartCoroutine("UpdateCoroutines");
Debug.Log("Update Call End");
isUpdateCall = true;
}
}
IEnumerator UpdateCoroutines()
{
Debug.Log("UpdateCoroutine Call Begin");
yield return null;
Debug.Log("UpdateCoroutine Call End");
}
void LateUpdate() {
if (!isLateUpdateCall) {
Debug.Log("LateUpdate Call Begin");
StartCoroutine("LateUpdateCoroutines");
Debug.Log("LateUpdate Call End");
isLateUpdateCall = true;
}
}
IEnumerator LateUpdateCoroutines()
{
Debug.Log("LateUpdateCoroutine Call Begin");
yield return null;
Debug.Log("LateUpdateCoroutine Call End");
}
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
在Start(),Update()和LateUpdate()中分别使用StartCoroutine()方法,传入的参数是一个实现了枚举器的方法名的字符串,枚举器的实现使用的迭代器,通过yield return语句完成,下面是输出结果:

 

输出结果中包含较多的信息,先来看看Start()方法中的StartCoroutine的执行顺序:

输出Start Call Begin
进入StartCoroutines()方法,输出StartCoroutine Call Begin
遇到yield return语句,暂时挂起,回到调用的地方
输出Start Call End
Start()方法执行完毕
当Start()方法执行完毕的时候,程序并没有回到StartCoroutines()内,而是按照上面的过程走完Update(),LataUpdate()方法之后才回到StartCoroutines()内,之后是UpdateCoroutines()和LateUpdateCoroutines(),这是为什么呢?这里涉及到Coroutine的执行顺序,Unity中,Start(),Update(),LateUpdate()依次执行,这没什么好说的,Coroutine的执行是在每一帧的LateUpdate()方法之后,这里需要注意一下,在每个Coroutine的yield return语句中传入的是null,程序会停留一帧,因此是在直到LateUpdate()方法执行完之后才会进入到StartCoroutine()的方法内。
之前我们看到的迭代器退出是在迭代器执行到MoveNext()方法时返回的值为false的情况下才会退出,但是刚才的示例代码中并没有看到MoveNext()的取用,原因在于这个调用和检测过程由Unity完成了:

Unity在每帧调用 协程(迭代器)MoveNext() 方法,如果返回 true ,就从当前位置继续往下执行。
在每个Coroutines里只有一个可列举项,Unity在LateUpdate()执行完后开始调用每个Coroutines中的MoveNext(),(执行一次后MoveNext()的返回值已经为fasle),Coroutines结束暂停挂起,回到运行状态,输出Debug.Log()后,下一帧再次调用MoveNext(),由于已经是false值,Coroutines退出迭代。
Unity中在创建IEnumerator枚举器时,yield return 后面可以有如下表达式:

null - the coroutine executes the next time that it is eligible
WaitForEndOfFrame - the coroutine executes on the frame, after all of the rendering and GUI is complete
WaitForFixedUpdate - causes this coroutine to execute at the next physics step, after all physics is calculated
WaitForSeconds - causes the coroutine not to execute for a given game time period
WWW - waits for a web request to complete (resumes as if WaitForSeconds or null)
Another coroutine - in which case the new coroutine will run to completion before the yielder is resumed
其中有关延时的处理在StartCoroutine()中被特殊处理了,Unity在每一帧调用这几个类的MoveNext之前会先判断延时的条件是否已经满足,如果满足,才会执行后面的MoveNext()操作,如果不满足,会跳出迭代器的方法下一帧再次进行检测,直到满足延时条件,执行MoveNext()操作,当MoveNext()的值为false,退出迭代器。关于被特殊处理的过程,可以参考Coroutine,你究竟干了什么这篇博客。

Coroutine的停止
Unity中Coroutine停止掉的方法,通过将附有脚本的gameObject.SetActive(false)可以停止掉Corotine,就像C#中在迭代器使用yield break一样,不过再重新设置为gameObject.SetActive(true)时,Coroutine并不会恢复。例如,将Update()中的代码修改为:

void Update() {
if (!isUpdateCall) {
Debug.Log("Update Call Begin");
StartCoroutine("UpdateCoroutines");
Debug.Log("Update Call End");
isUpdateCall = true;
gameObject.SetActive(false);
}
1
2
3
4
5
6
7
8
添加了一行gameObject.SetActive(false),再来看一下输出结果:

 

当代码执行到UpdateCoroutines()时,输出”UpdateCoroutine Call Begin”,遇到yield return迭代器进入暂停挂起状态,回到Update()中,输出”Update Call End”,遇到gameObject.SetActive(false),此时开启的Coroutines全部终止,后面的正常方法LateUpdate()和三个Coroutine里面的输出无法进行。
这是gameObject.SetActive(false)放在Coroutine的外部,如果放在内部会是什么情况?修改之前的代码,将gameObject.SetActive(false)放到UpdateCoroutines里面:

IEnumerator UpdateCoroutines()
{
Debug.Log("UpdateCoroutine Call Begin");
yield return null;
gameObject.SetActive(false);
Debug.Log("UpdateCoroutine Call End");
}
1
2
3
4
5
6
7
再来看看输出结果:

 

输出结果是11行,只有最后一个LateUpdateCoroutines中yield return后面的LateUpdateCoroutine Call End没有并执行,通过之前的分析过程,这里的输出结果并不难解释,当代码再次回到UpdateCorotineds的yield return语句之后,前面的输出应该是“StartCoroutines Call End”,这里需要注意的是,尽管 gameObject.SetActive(false)在Debug.Log(“UpdateCoroutine Call End”)语句之前,但是”UpdateCoroutine Call End”还是会输出,也就是说,当gameObject.SetActive(false)在迭代器内部时,代码并不是一走到 gameObject.SetActive(false);就立即终止,而是会离开迭代器之前将离开前的代码执行完。
————————————————
版权声明:本文为CSDN博主「O213」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/u013477973/article/details/65635737

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!