本文包含两个部分，前半部分是通俗解释一下Unity中的协程，后半部分讲讲C#的IEnumerator迭代器
协程是什么，能干什么？
为了能通俗的解释，我们先用一个简单的例子来看看协程可以干什么
首先，我突发奇想，要实现一个倒计时器，我可能是这样写的：
public class CoroutineTest : MonoBehaviour
{
public float sumtime = 3;
void Update()//Update是每帧调用的
{
{
sumtime -= Time.deltaTime;
if (sumtime <= 0)
Debug.Log("Done!");
}
}
}我们知道，写进 Update() 里的代码会被每帧调用一次，
所以，让总时间sumtime在Update()中每一帧减去一个增量时间Time.deltaTime（可以理解成帧与帧的间隔时间）就能实现一个简单的倒计时器
但是，当我们需要多个独立的计时器时，用同样的思路，我们的代码可能就会写成这样：
public class CoroutineTest : MonoBehaviour
{
public float sumtime1 = 3;
public float sumtime2 = 2;
public float sumtime3 = 1;
void Update()
{
sumtime1 -= Time.deltaTime;
if (sumtime1 <= 0)
Debug.Log("timer1 Done!");
sumtime2 -= Time.deltaTime;
if (sumtime2 <= 0)
Debug.Log("timer2 Done!");
sumtime3 -= Time.deltaTime;
if (sumtime3 <= 0)
Debug.Log("timer3 Done!");
}
}重复度很高，计时器越多看的越麻烦
然后有朋友可能会提到，我们是不是可以用一个循环来解决这个问题
for (float sumtime = 3; sumtime >= 0; sumtime -= Time.deltaTime)
{
//nothing
}
Debug.Log("This happens after 5 seconds");现在每一个计时器变量都成为for循环的一部分了，这看上去好多了，而且我不需要去单独设置每一个跌倒变量。
但是
但是
但是
我们知道Update() 是每帧调用一次的，我们不能把这个循环直接写进Update() 里，更不能写一个方法在Update() 里调用，因为这相当于每帧开启一个独立的循环
那么有没有办法，再Update()这个主线程之外再开一个单独的线程，帮我们管理这个计时呢？
好了，你可能知道我想说什么了，我们正好可以用协程来干这个
先来看一段简单的协程代码
public class CoroutineTest : MonoBehaviour
{
void Start()
{
StartCoroutine(Count3sec());
}
IEnumerator Count3sec()
{
for (float sumtime = 3; sumtime >= 0; sumtime -= Time.deltaTime)
yield return 0;
Debug.Log("This happens after 3 seconds");
}
}你很可能看不懂上面的几个关键字，但不急，我们一个个解释上面的代码干了什么
StartCoroutine(Count3sec());
这一句用来开始我们的Count3sec方法
然后你可能想问的是
- IEnumerator 是什么？返回值是什么？
- For循环中的yield return是什么？
理解以下的话稍有难度，但暂时理解不了问题也不大
详细的讲：
IEnumerator 是C#的一个迭代器，你可以把它当成指向一个序列的某个节点的指针，C#提供了两个重要的接口，分别是Current（返回当前指向的元素）和 MoveNext()（将指针向前移动一个单位，如果移动成功，则返回true）
通常，如果你想实现一个接口，你可以写一个类，实现成员，等等。迭代器块（iterator block） 是一个方便的方式实现IEnumerator，你只需要遵循一些规则，并实现IEnumerator由编译器自动生成。
一个迭代器块具备如下特征：
- 返回IEnumerator
- 使用yield关键字
那么yield关键字是干嘛的？它用来声明序列中的下一个值，或者一个无意义的值。如果使用yield x（x是指一个具体的对象或数值）的话，那么movenext返回为true并且current被赋值为x，如果使用yield break使得movenext()返回false（停止整个协程）
看不太懂？问题不大
简单来说：
你现在只需要理解，上面代码中，IEnumerator类型的方法Count3sec就是一个协程，并且可以通过yield关键字控制协程的运行
一个协程的执行，可以在任何地方用yield语句来暂停，yield return的值决定了什么时候协程恢复执行。通俗点讲，当你“yield”一个方法时，你相当于对这个程序说：“现在停止这个方法，然后在下一帧中，从这里重新开始！”
yield return 0;
然后你可能会问，yield return后面的数字表示什么？比如yield return 10，是不是表示延缓10帧再处理？
并不！
并不！
并不！
yield return 0表示暂缓一帧，也就是让你的程序等待一帧，再继续运行。（不一定是一帧，下面会讲到如何控制等待时间）就算你把这个0换成任意的int类型的值，都是都是表示暂停一帧，从下一帧开始执行
它的效果类似于主线程单独出了一个子线程来处理一些问题，而且性能开销较小
现在你大致学会了怎么开启协程，怎么写协程了，来看看我们还能干点什么：
IEnumerator count5times()
{
yield return 0;
Debug.Log("1");
yield return 0;
Debug.Log("2");
yield return 0;
Debug.Log("3");
yield return 0;
Debug.Log("4");
yield return 0;
Debug.Log("5");
}在这个协程中，我们每隔一帧输出了一次Hello，当然你也可以改成一个循环
IEnumerator count5times()
{
for (int i = 0; i < 5; i++)
{
Debug.Log("i+1");
yield return 0;
}
}重点来了，有意思的是，你可以在这里加一个记录始末状态的变量：
public class CoroutineTest : MonoBehaviour
{
bool isDone = false;
IEnumerator count5times()
{
Debug.Log(isDone);
for (int i = 0; i < 5; i++)
{
Debug.Log("i+1");
yield return 0;
}
isDone = true;
Debug.Log(isDone);
}
void Start()
{
StartCoroutine(count5times());
}
}很容易看得出上面的代码实现了什么，也就就是我们一开始的需求，计时器
这个协程方法突出了协程一个“非常有用的，和Update()不同的地方：方法的状态能被存储，这使得方法中定义的这些变量（比如isUpdate）都会保存它们的值，即使是在不同的帧中
再修改一下，就是一个简单的协程计时器了
public class CoroutineTest : MonoBehaviour
{
IEnumerator countdown(int count, float frequency)
{
Debug.Log("countdown START!");
for (int i = 0; i < count; i++)
{
for (float timer = 0; timer < frequency; timer += Time.deltaTime)
yield return 0;
}
Debug.Log("countdown DONE!");
}
void Start()
{
StartCoroutine(countdown(5, 1.0f));
}
}在上面的例子我们也能看出，和普通方法一样，协程方法也可以带参数
你甚至可以通过yield一个WaitForSeconds()更方便简洁地实现倒计时
协程计时器
public class CoroutineTest : MonoBehaviour
{
IEnumerator countdown(float sec)//参数为倒计时时间
{
Debug.Log("countdown START!");
yield return new WaitForSeconds(sec);
Debug.Log("countdown DONE!");
}
void Start()
{
StartCoroutine(countdown(5.0f));
}
}好了，可能你已经注意到了，yield的用法还是很多的
在此之前，我们之前的代码yield的时候总是用0（或者可以用null），这仅仅告诉程序在继续执行前等待下一帧。现在你又学会了用yield return new WaitForSeconds(sec)来控制等待时间，你已经可以做更多的骚操作了！
协程另外强大的一个功能就是，你甚至可以yeild另一个协程，也就是说，你可以通过使用yield语句来相互嵌套协程，
public class CoroutineTest : MonoBehaviour
{
IEnumerator SaySomeThings()
{
Debug.Log("The routine has started");
yield return StartCoroutine(Wait(1.0f));
Debug.Log("1 second has passed since the last message");
yield return StartCoroutine(Wait(2.5f));
Debug.Log("2.5 seconds have passed since the last message");
}
IEnumerator Wait(float waitsec)
{
for (float timer = 0; timer < waitsec; timer += Time.deltaTime)
yield return 0;
}
void Start()
{
StartCoroutine(SaySomeThings());
}
}yield return StartCoroutine(Wait(1.0f));
这里的Wait指的是另一个协程，这相当于是说，“暂停执行本程序，等到直到Wait协程结束”
协程控制对象行为
根据我们上面讲的特性，协程还能像创建计时器一样方便的控制对象行为，比如物体运动到某一个位置
IEnumerator MoveToPosition(Vector3 target)
{
while (transform.position != target)
{
transform.position = Vector3.MoveTowards(transform.position, target, moveSpeed * Time.deltaTime);
yield return 0;
}
}我们还可以让上面的程序做更多，不仅仅是一个指定位置，还可以通过数组来给它指定更多的位置，然后通过MoveToPosition() ，可以让它在这些点之间持续运动。
我们还可以再加入一个bool变量，控制在对象运动到最后一个点时是否要进行循环
再把上文的Wait()方法加进来，这样就能让我们的对象在某个点就可以选择是否暂停下来，停多久，就像一个正在巡逻的守卫一样 （这里没有实现，各位读者可以尝试自己写一个）
public class CoroutineTest : MonoBehaviour
{
public Vector3[] path;
public float moveSpeed;
void Start()
{
StartCoroutine(MoveOnPath(true));
}
IEnumerator MoveOnPath(bool loop)
{
do
{
foreach (var point in path)
yield return StartCoroutine(MoveToPosition(point));
}
while (loop);
}
IEnumerator MoveToPosition(Vector3 target)
{
while (transform.position != target)
{
transform.position = Vector3.MoveTowards(transform.position, target, moveSpeed * Time.deltaTime);
yield return 0;
}
}
IEnumerator Wait(float waitsec)
{
for (float timer = 0; timer < waitsec; timer += Time.deltaTime)
yield return 0;
}
}yield其他
这里列举了yield后面可以有的表达式
null,0,1,...... 暂缓一帧，下一帧继续执行
- 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)
StartCoroutine(Another coroutine) - in which case the new coroutine will run to completion before the yielder is resumed 等待另一个协程暂停
值得注意的是 WaitForSeconds()受Time.timeScale影响，当Time.timeScale = 0f 时，yield return new WaitForSecond(x) 将不会满足
停止协程
- StopCoroutine(string methodName);
- StopAllCoroutine();
- 设置gameobject的active为false时可以终止协同程序，但是再次设置为true后协程不会再启动。
总结一下
协程就是：你可以写一段顺序代码，然后标明哪里需要暂停，然后在指定在下一帧或者任意间后，系统会继续执行这段代码
当然，协程不是真多线程，而是在一个线程中实现的
通过协程我们可以方便的做出一个计时器，甚至利用协程控制游戏物体平滑运动
如果你刚接触协程，我希望这篇博客能帮助你了解它们是如何工作的，以及如何来使用它们
深入讲讲IEnumerator
基础迭代器IEnumerator
迭代器是C#中一个普通的接口类，类似于C++ iterator的概念，基础迭代器是为了实现类似for循环 对指定数组或者对象 的 子元素 逐个的访问而产生的。
public interface IEnumerator { object Current { get; } bool MoveNext(); void Reset(); }
以上是IEnumerator的定义
Current() 的实现应该是返回调用者需要的指定类型的指定对象。
MoveNext() 的实现应该是让迭代器前进。
Reset() 的实现应该是让迭代器重置未开始位置
就像上文提到的，C#提供了两个重要的接口，分别是Current（返回当前指向的元素）和 MoveNext()（将指针向前移动一个单位，如果移动成功，则返回true）当然IEnumerator是一个interface接口，你不用担心的具体实现
注意以上用的都是“应该是”，也就是说我们可以任意实现一个派生自” IEnumerator”类的3个函数的功能，但是如果不按设定的功能去写，可能会造成被调用过程出错，无限循环
一个简单的例子，遍历并打印一个字符串数组：
public string[] m_StrArray = new string[4];就可以派生一个迭代器接口的子类
public class StringPrintEnumerator : IEnumerator
{
private int m_CurPt = -1;
private string[] m_StrArray;
public StringPrintEnumerator(string[] StrArray)
{
m_StrArray = StrArray;
}
///实现
public object Current
{
get
{
return m_StrArray[m_CurPt];
}
}
public bool MoveNext()
{
m_CurPt++;
if (m_CurPt == m_StrArray.Length)
return false;
return true;
}
public void Reset()
{
m_CurPt = -1;
}
///实现END
public static void Run()
{
string[] StrArray = new string[4];
StrArray[0] = "A";
StrArray[1] = "B";
StrArray[2] = "C";
StrArray[3] = "D";
StringPrintEnumerator StrEnum = new StringPrintEnumerator(StrArray);
while (StrEnum.MoveNext())
{
(string)ObjI = (string)StrEnum.Current;
Debug.Log(ObjI);
}
}
}运行会依次输出A B C D
但是如果：
不正确的实现Current（返回null，数组下表越界）执行到Debug.Log时候会报错。
不正确地MoveNext()，可能会出现无限循环（当然如果逻辑上正需要这样，也是正确的）
不正确地Reset()，下次再用同一个迭代器时候不能正确工作
所以这三个方法如何才是正确的实现，完全要根据由上层的调用者约定来写
迭代器扩展应用foreach，IEnumerable
C#使用foreach语句取代了每次手写while(StrEnum.MoveNext())进行遍历
同时新定了一个接口类来包装迭代器IEnumerator，也就是IEnumerable，定义为：
public interface IEnumerable { IEnumerator GetEnumerator(); }
IEnumerable和IEnumerator的区别
可以看到IEnumerable接口非常的简单，只包含一个抽象的方法GetEnumerator()，它返回一个可用于循环访问集合的IEnumerator对象。
IEnumerable的作用仅仅是需要派生类写一个返回指定迭代器的实现方法，也就是说IEnumerable仅仅是IEnumerator的一个包装而已。
那么返回的IEnumerator对象呢？它是一个真正的集合访问器，没有它，就不能使用foreach语句遍历集合或数组，因为只有IEnumerator对象才能访问集合中的项，才能进行集合的循环遍历。
那么我们回到foreach
foreach
就像上面提到的，foreach需要的是一个定义了IEnumerator GetEnumerator()方法的对象，当然如果他是派生自IEnumerable对象那就更好了。
我们继续写上文的StringPrintEnumerator类
这里新定义他的IEnumerable派生类MyEnumerable