Unity协程（Coroutine）原理深入剖析再续

Unity协程（Coroutine）原理深入剖析再续
http://dsqiu.iteye.com/blog/2049743

Unity协程（Coroutine）原理深入剖析再续

By D.S.Qiu

尊重他人的劳动，支持原创，转载请注明出处：http.dsqiu.iteye.com

前面已经介绍过对协程（Coroutine）的认识和理解，主要讲到了Unity引擎在执行协程（Coroutine）的原理（Unity协程（Coroutine）原理深入剖析）和对协程（Coroutine）状态的控制（Unity协程(Coroutine)管理类——TaskManager工具分享），到这使用Coroutine的疑问就没有了，但是D.S.Qiu还是有点没嚼烂，所以觉得很有必要再续。

本文主要分为三部分：

1）yield return， IEnumerator 和 Unity StartCoroutine 的关系和理解

2）Cortoutine 扩展——Extending Coroutines: Return Values and Error Handling

3）Cortountine Locking

总之，引用③的一句话：Coroutines – More than you want to know.

1）yield return， IEnumerator 和 Unity StartCoroutine 的关系和理解

yield 和 IEnumerator都是C#的东西，前者是一个关键字，后者是枚举类的接口。对于IEnumerator 只引用②对 IEnumerable与IEnumerator区别的论述：

先贴出 IEnumerable 和 IEnumerator的定义：
C#代码
1. public interface IEnumerable
2. {
3. IEnumerator GetEnumerator();
4. }
6. public interface IEnumerator
7. {
8. bool MoveNext();
9. void Reset();
11. Object Current { get; }
12. }
```
public interface IEnumerable
{
    IEnumerator GetEnumerator();
}
 
public interface IEnumerator
{
    bool MoveNext();
    void Reset();
 
    Object Current { get; }
}
```
IEnumerable和IEnumerator有什么区别？这是一个很让人困惑的问题（在很多forum里都看到有人在问这个问题）。研究了半天，得到以下几点认识：

1、一个Collection要支持foreach方式的遍历，必须实现IEnumerable接口（亦即，必须以某种方式返回IEnumerator object）。

2、IEnumerator object具体实现了iterator（通过MoveNext()，Reset()，Current）。

3、从这两个接口的用词选择上，也可以看出其不同：IEnumerable是一个声明式的接口，声明实现该接口的class是“可枚举（enumerable）”的，但并没有说明如何实现枚举器（iterator）；IEnumerator是一个实现式的接口，IEnumerator object就是一个iterator。

4、IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，client可以通过IEnumerable的GetEnumerator()得到IEnumerator object，在这个意义上，将GetEnumerator()看作IEnumerator object的factory method也未尝不可。

IEnumerator 是所有枚举数的基接口。

枚举数只允许读取集合中的数据。枚举数无法用于修改基础集合。

最初，枚举数被定位于集合中第一个元素的前面。Reset 也将枚举数返回到此位置。在此位置，调用 Current 会引发异常。因此，在读取 Current 的值之前，必须调用 MoveNext 将枚举数提前到集合的第一个元素。

在调用 MoveNext 或 Reset 之前，Current 返回同一对象。MoveNext 将 Current 设置为下一个元素。

在传递到集合的末尾之后，枚举数放在集合中最后一个元素后面，且调用 MoveNext 会返回 false。如果最后一次调用 MoveNext 返回 false，则调用 Current 会引发异常。若要再次将 Current 设置为集合的第一个元素，可以调用 Reset，然后再调用 MoveNext。

只要集合保持不变，枚举数就将保持有效。如果对集合进行了更改（例如添加、修改或删除元素），则该枚举数将失效且不可恢复，并且下一次对 MoveNext 或 Reset 的调用将引发 InvalidOperationException。如果在 MoveNext 和 Current 之间修改集合，那么即使枚举数已经无效，Current 也将返回它所设置成的元素。

枚举数没有对集合的独占访问权；因此，枚举一个集合在本质上不是一个线程安全的过程。甚至在对集合进行同步处理时，其他线程仍可以修改该集合，这会导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。

Yield关键字

在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它的形式为下列之一⑥：

　　yield return <expression_r>;

　　yield break;

备注 :

　　计算表达式并以枚举数对象值的形式返回；expression_r 必须可以隐式转换为迭代器的 yield 类型。

　　yield 语句只能出现在 iterator 块中，该块可用作方法、运算符或访问器的体。这类方法、运算符或访问器的体受以下约束的控制：

　　不允许不安全块。

　　方法、运算符或访问器的参数不能是 ref 或 out。

　　yield 语句不能出现在匿名方法中。

　　当和 expression_r 一起使用时，yield return 语句不能出现在 catch 块中或含有一个或多个 catch 子句的 try 块中。

　　yield return 提供了迭代器一个比较重要的功能，即取到一个数据后马上返回该数据，不需要全部数据装入数列完毕，这样有效提高了遍历效率。

Unity StartCoroutine

Unity使用 StartCoroutine(routine: IEnumerator): Coroutine 启动协程，参数必须是 IEnumerator 对象。那么Unity在背后做什么神奇的处理呢？

StartCoroutine函数的参数我一般都是通过传入一个返回值为 IEnumerator的函数得到的：
C#代码
1. IEnumerator WaitAndPrint(float waitTime) {
2. yield return new WaitForSeconds(waitTime);
3. print("WaitAndPrint " + Time.time);
4. }
```
IEnumerator WaitAndPrint(float waitTime) {
    yield return new WaitForSeconds(waitTime);
    print("WaitAndPrint " + Time.time);
}
```
在函数内使用前面介绍 yield 关键字返回 IEnumerator 对象，Unity 中实现了 YieldInstruction 作为 yield 返回的基类，有 Cortoutine, WaitForSecondes, WaitForEndOfFrame, WaitForFixedUpdate, WWW 几个子类实现。StartCoroutine 将传入的 IEnumerator 封装为 Coroutine 返回，引擎会对 Corountines 存储和检查 IEnumerator 的 Current值。

③枚举了 WWW ,WaitForSeconds , null 和 WaitForEndOfFrame 检查 Current值在MonoBebaviour生存周期的时间（没有WaitForFixedUpdate ，D.S.Qiu猜测是其作者成文是Unity引擎还没有提供这个实现）：

WWW - after Updates happen for all game objects; check the isDone flag. If true, call the IEnumerator's MoveNext() function;

WaitForSeconds - after Updates happen for all game objects; check if the time has elapsed, if it has, call MoveNext();

null or some unknown value - after Updates happen for all game objects; Call MoveNext();

WaitForEndOfFrame - after Render happens for all cameras; Call MoveNext().

如果最后一个 yield return 的 IEnumerator 已经迭代到最后一个是，MoveNext 就会返回 false 。这时，Unity就会将这个 IEnumerator 从 cortoutines list 中移除。

所以很容易一个出现的误解：协程 Coroutines 并不是并行的，它和你的其他代码都运行在同一个线程中，所以才会在Update 和 Coroutine中使用同一个值时才会变得线程安全。这就是Unity对线程安全的解决策略——直接不使用线程，最近Unity 5 将要发布说的很热，看到就有完全多线程的支持，不知道是怎么实现的，从技术的角度，还是很期待的哈。

总结下：在协程方法中使用 yield return 其实就是为了返回 IEnumerator对象，只有当这个对象的 MoveNext() 返回 false 时，即该 IEnumertator 的 Current 已经迭代到最后一个元素了，才会执行 yield return 后面的语句。也就是说， yield return 被会“翻译”为一个 IEnmerator 对象，要想深入了解这方面的更多细节，可以猛击⑤查看。

根据⑤ C# in depth 的理解——C# 编译器会生成一个 IEnumerator 对象，这个对象实现的 MoveNext() 包含函数内所有 yield return 的处理，这里仅附上一个例子：
C#代码
1. using System;
2. using System.Collections;
4. class Test
5. {
6. static IEnumerator GetCounter()
7. {
8. for (int count = 0; count < 10; count++)
9. {
10. yield return count;
11. }
12. }
13. }
```
using System;
using System.Collections;

class Test
{
    static IEnumerator GetCounter()
    {
        for (int count = 0; count < 10; count++)
        {
            yield return count;
        }
    }
}
```
C#编译器对应生成：
Cpp代码
1. internal class Test
2. {
3. // Note how this doesn't execute any of our original code
4. private static IEnumerator GetCounter()
5. {
6. return new <GetCounter>d__0(0);
7. }
9. // Nested type automatically created by the compiler to implement the iterator
10. [CompilerGenerated]
11. private sealed class <GetCounter>d__0 : IEnumerator<object>, IEnumerator, IDisposable
12. {
13. // Fields: there'll always be a "state" and "current", but the "count"
14. // comes from the local variable in our iterator block.
15. private int <>1__state;
16. private object <>2__current;
17. public int <count>5__1;
19. [DebuggerHidden]
20. public <GetCounter>d__0(int <>1__state)
21. {
22. this.<>1__state = <>1__state;
23. }
25. // Almost all of the real work happens here
26. private bool MoveNext()
27. {
28. switch (this.<>1__state)
29. {
30. case 0:
31. this.<>1__state = -1;
32. this.<count>5__1 = 0;
33. while (this.<count>5__1 < 10) //这里针对循环处理
34. {
35. this.<>2__current = this.<count>5__1;
36. this.<>1__state = 1;
37. return true;
38. Label_004B:
39. this.<>1__state = -1;
40. this.<count>5__1++;
41. }
42. break;
44. case 1:
45. goto Label_004B;
46. }
47. return false;
48. }
50. [DebuggerHidden]
51. void IEnumerator.Reset()
52. {
53. throw new NotSupportedException();
54. }
56. void IDisposable.Dispose()
57. {
58. }
60. object IEnumerator<object>.Current
61. {
62. [DebuggerHidden]
63. get
64. {
65. return this.<>2__current;
66. }
67. }
69. object IEnumerator.Current
70. {
71. [DebuggerHidden]
72. get
73. {
74. return this.<>2__current;
75. }
76. }
77. }
78. }
```
internal class Test
{
    // Note how this doesn't execute any of our original code
    private static IEnumerator GetCounter()
    {
        return new <GetCounter>d__0(0);
    }

    // Nested type automatically created by the compiler to implement the iterator
    [CompilerGenerated]
    private sealed class <GetCounter>d__0 : IEnumerator<object>, IEnumerator, IDisposable
    {
        // Fields: there'll always be a "state" and "current", but the "count"
        // comes from the local variable in our iterator block.
        private int <>1__state;
        private object <>2__current;
        public int <count>5__1;

        [DebuggerHidden]
        public <GetCounter>d__0(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        // Almost all of the real work happens here
        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    this.<count>5__1 = 0;
                    while (this.<count>5__1 < 10)        //这里针对循环处理
                    {
                        this.<>2__current = this.<count>5__1;
                        this.<>1__state = 1;
                        return true;
                    Label_004B:
                        this.<>1__state = -1;
                        this.<count>5__1++;
                    }
                    break;

                case 1:
                    goto Label_004B;
            }
            return false;
        }

        [DebuggerHidden]
        void IEnumerator.Reset()
        {
            throw new NotSupportedException();
        }

        void IDisposable.Dispose()
        {
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }
    }
}
```
从上面的C#实现可以知道：函数内有多少个 yield return 在对应的 MoveNext() 就会返回多少次 true （不包含嵌套）。另外非常重要的一点的是：同一个函数内的其他代码（不是 yield return 语句）会被移到 MoveNext 中去，也就是说，每次 MoveNext 都会顺带执行同一个函数中 yield return 之前，之后和两个 yield return 之间的代码。

对于Unity 引擎的 YieldInstruction 实现，其实就可以看着一个函数体，这个函数体每帧会实现去 check MoveNext 是否返回 false 。例如：
C#代码
1. yield retrun new WaitForSeconds(2f);
```
yield retrun new WaitForSeconds(2f);
```
上面这行代码的伪代码实现:
C#代码
1. private float elapsedTime;
2. private float time;
4. private void MoveNext()
5. {
6. elapesedTime += Time.deltaTime;
8. if(time <= elapsedTime)
9. return false;
10. else return true;
12. }
```
private float elapsedTime;
private float time;

private void MoveNext()
{
        elapesedTime += Time.deltaTime;
        
        if(time <= elapsedTime)
                return false;
        else return true;

}
```
增补于： 2014年04月22日 8:00

2）Cortoutine 扩展——Extending Coroutines: Return Values and Error Handling

不知道你们调用 StartCortoutine 的时候有没有注意到 StartCortoutine 返回了 YieldInstruction 的子类 Cortoutine 对象，这个返回除了嵌套使用 StartCortoutine 在 yiled retrun StartCortoutine 有用到，其他情况机会就没有考虑它的存在，反正D.S.Qiu是这样的，一直认为物“极”所用，所以每次调用 StartCortoutine 都很纠结，好吧，有点强迫症。

Unity引擎讲 StartCoroutine 传入的参数 IEnumerator 封装为一个 Coroutine 对象中，而 Coroutine 对象其实也是 IEnumerator 枚举对象。yield return 的 IEnumerator 对象都存储在这个 Coroutine 中，只有当上一个yield return 的 IEnumerator 迭代完成，才会运行下一个。这个在猜测下Unity底层对Cortountine 的统一管理（也就是上面说的检查 Current 值）：Unity底层应该有一个正在运行的 Cortoutine 的 list 然后在每帧的不同时间去 Check。

还是回归到主题，上面介绍 yield 关键字有说不允许不安全块，也就是说不能出现在 try catch 块中，就不能在 yield return 执行是进行错误检查。③利用 StartCortoutine 返回值 Cortoutine 得到了当前的 Current 值和进行错误捕获处理。

先定义封装包裹返回值和错误信息的类：
C#代码
1. public class Coroutine<T>{
2. public T Value {
3. get{
4. if(e != null){
5. throw e;
6. }
7. return returnVal;
8. }
9. }
10. private T returnVal; //当前迭代器的Current 值
11. private Exception e; //抛出的错误信息
12. public Coroutine coroutine;
14. public IEnumerator InternalRoutine(IEnumerator coroutine){
15. //先省略这部分的处理
16. }
17. }
```
public class Coroutine<T>{
public T Value {
	get{
		if(e != null){
			throw e;
		}
		return returnVal;
	}
}
private T returnVal;  //当前迭代器的Current 值
private Exception e;    //抛出的错误信息
public Coroutine coroutine;

public IEnumerator InternalRoutine(IEnumerator coroutine){
	//先省略这部分的处理
	}
}
```
InteralRoutine是对返回 Current 值和抛出的异常信息（如果有的话）：
C#代码
1. public IEnumerator InternalRoutine(IEnumerator coroutine){
2. while(true){
3. try{
4. if(!coroutine.MoveNext()){
5. yield break;
6. }
7. }
8. catch(Exception e){
9. this.e = e;
10. yield break;
11. }
12. object yielded = coroutine.Current;
13. if(yielded != null && yielded.GetType() == typeof(T)){
14. returnVal = (T)yielded;
15. yield break;
16. }
17. else{
18. yield return coroutine.Current;
19. }
20. }
```
public IEnumerator InternalRoutine(IEnumerator coroutine){
	while(true){
		try{
			if(!coroutine.MoveNext()){
				yield break;
			}
		}
		catch(Exception e){
			this.e = e;
			yield break;
		}
		object yielded = coroutine.Current;
		if(yielded != null && yielded.GetType() == typeof(T)){
			returnVal = (T)yielded;
			yield break;
		}
		else{
			yield return coroutine.Current;
		}
	}
```
下面为这个类扩展MonoBehavior：
C#代码
1. public static class MonoBehaviorExt{
2. public static Coroutine<T> StartCoroutine<T>(this MonoBehaviour obj, IEnumerator coroutine){
3. Coroutine<T> coroutineObject = new Coroutine<T>();
4. coroutineObject.coroutine = obj.StartCoroutine(coroutineObject.InternalRoutine(coroutine));
5. return coroutineObject;
6. }
7. }
```
public static class MonoBehaviorExt{
	public static Coroutine<T> StartCoroutine<T>(this MonoBehaviour obj, IEnumerator coroutine){
		Coroutine<T> coroutineObject = new Coroutine<T>();
		coroutineObject.coroutine = obj.StartCoroutine(coroutineObject.InternalRoutine(coroutine));
		return coroutineObject;
	}
}
```
最后给出一个 Example：
C#代码
1. IEnumerator Start () {
2. var routine = StartCoroutine<int>(TestNewRoutine()); //Start our new routine
3. yield return routine.coroutine; // wait as we normally can
4. Debug.Log(routine.Value); // print the result now that it is finished.
5. }
7. IEnumerator TestNewRoutine(){
8. yield return null;
9. yield return new WaitForSeconds(2f);
10. yield return 10;
11. yield return 5;
12. }
```
IEnumerator Start () {
		var routine = StartCoroutine<int>(TestNewRoutine()); //Start our new routine
		yield return routine.coroutine; // wait as we normally can
		Debug.Log(routine.Value); // print the result now that it is finished.
	}
	
	IEnumerator TestNewRoutine(){
		yield return null;
		yield return new WaitForSeconds(2f);
		yield return 10;
                yield return 5;
	}
```
最后输出是10,因为Cortoutine<T> 遇到满足条件的 T 类型就执行 yield break;就不执行 yield return 5; 这条语句了。

如果将中 yield break; 语句去掉的话，最后输出的是 5 而不是10。
C#代码
1. if(yielded != null && yielded.GetType() == typeof(T)){
2. returnVal = (T)yielded;
3. yield break;
4. }
```
if(yielded != null && yielded.GetType() == typeof(T)){
			returnVal = (T)yielded;
			yield break;
		}
```
其实就是Unity引擎每帧去 check yield return 后面的表达式，如果满足就继续向下执行。

下面在测试一个例子：连续两次调用 yield return coroutine;
C#代码
1. private Coroutine routine1;
2. void Start ()
3. {
4. routine1 = StartCoroutine(TestCoroutineExtention1()); //Start our new routine
5. StartCoroutine(TestCortoutine());
7. }
8. IEnumerator TestCoroutineExtention1()
9. {
10. yield return new WaitForSeconds(1);
11. yield return 10;
12. Debug.Log("Run 10!");
13. yield return new WaitForSeconds(5);
14. yield return 5;
15. Debug.Log("Run 5!");
16. }
17. IEnumerator TestCortoutine()
18. {
19. //wwwState = true;
20. yield return routine1; // wait as we normally can
21. Debug.Log(" routine1");
22. yield return routine1; // wait as we normally can
23. Debug.Log(" routine2");
24. }
```
     private Coroutine routine1;
     void Start () 
     {
        routine1 = StartCoroutine(TestCoroutineExtention1()); //Start our new routine  
        StartCoroutine(TestCortoutine());
        
    }
    IEnumerator TestCoroutineExtention1()
    {
        yield return new WaitForSeconds(1);
        yield return 10;
        Debug.Log("Run 10!");
        yield return new WaitForSeconds(5);
        yield return 5;
        Debug.Log("Run 5!");
    }
    IEnumerator TestCortoutine()
    {
        //wwwState = true;
        yield return routine1; // wait as we normally can  
        Debug.Log(" routine1");
        yield return routine1; // wait as we normally can 
        Debug.Log(" routine2");
    }
```
测试运行会发现只会输出：

Run 10!

Run 5!

routine1

总结下： yield return expression 只有表达式完全执行结束才会继续执行后面的代码，连续两次执行 yield return StartCortoutine() 的返回值是不会满足的，说明 yield return 有区分开始和结束的两种状态。

3）Cortoutine Locking

虽然Cortoutine不是多线程机制，但仍会“并发”问题——同时多次调用 StartCortoutine ，当然通过Unity提供的api也能得到解决方案，每次StartCoroutine 之前先调用 StopCortoutine 方法停止，但这利用的是反射，显然效率不好。④对③的方案进行了扩展提供了 Cortoutine Locking 的支持，使用字符串（方法名）来标记同一个 Coroutine 方法，对于同一个方法如果等待时间超过 timeout 就会终止前面一个 Coroutine 方法，下面直接贴出代码：
C#代码
1. using UnityEngine;
2. using System;
3. using System.Collections;
4. using System.Collections.Generic;
6. /// <summary>
7. /// Extending MonoBehaviour to add some extra functionality
8. /// Exception handling from: http://twistedoakstudios.com/blog/Post83_coroutines-more-than-you-want-to-know
9. ///
10. /// 2013 Tim Tregubov
11. /// </summary>
12. public class TTMonoBehaviour : MonoBehaviour
13. {
14. private LockQueue LockedCoroutineQueue { get; set; }
16. /// <summary>
17. /// Coroutine with return value AND exception handling on the return value.
18. /// </summary>
19. public Coroutine<T> StartCoroutine<T>(IEnumerator coroutine)
20. {
21. Coroutine<T> coroutineObj = new Coroutine<T>();
22. coroutineObj.coroutine = base.StartCoroutine(coroutineObj.InternalRoutine(coroutine));
23. return coroutineObj;
24. }
26. /// <summary>
27. /// Lockable coroutine. Can either wait for a previous coroutine to finish or a timeout or just bail if previous one isn't done.
28. /// Caution: the default timeout is 10 seconds. Coroutines that timeout just drop so if its essential increase this timeout.
29. /// Set waitTime to 0 for no wait
30. /// </summary>
31. public Coroutine<T> StartCoroutine<T>(IEnumerator coroutine, string lockID, float waitTime = 10f)
32. {
33. if (LockedCoroutineQueue == null) LockedCoroutineQueue = new LockQueue();
34. Coroutine<T> coroutineObj = new Coroutine<T>(lockID, waitTime, LockedCoroutineQueue);
35. coroutineObj.coroutine = base.StartCoroutine(coroutineObj.InternalRoutine(coroutine));
36. return coroutineObj;
37. }
39. /// <summary>
40. /// Coroutine with return value AND exception handling AND lockable
41. /// </summary>
42. public class Coroutine<T>
43. {
44. private T returnVal;
45. private Exception e;
46. private string lockID;
47. private float waitTime;
49. private LockQueue lockedCoroutines; //reference to objects lockdict
50. private bool lockable;
52. public Coroutine coroutine;
53. public T Value
54. {
55. get
56. {
57. if (e != null)
58. {
59. throw e;
60. }
61. return returnVal;
62. }
63. }
65. public Coroutine() { lockable = false; }
66. public Coroutine(string lockID, float waitTime, LockQueue lockedCoroutines)
67. {
68. this.lockable = true;
69. this.lockID = lockID;
70. this.lockedCoroutines = lockedCoroutines;
71. this.waitTime = waitTime;
72. }
74. public IEnumerator InternalRoutine(IEnumerator coroutine)
75. {
76. if (lockable && lockedCoroutines != null)
77. {
78. if (lockedCoroutines.Contains(lockID))
79. {
80. if (waitTime == 0f)
81. {
82. //Debug.Log(this.GetType().Name + ": coroutine already running and wait not requested so exiting: " + lockID);
83. yield break;
84. }
85. else
86. {
87. //Debug.Log(this.GetType().Name + ": previous coroutine already running waiting max " + waitTime + " for my turn: " + lockID);
88. float starttime = Time.time;
89. float counter = 0f;
90. lockedCoroutines.Add(lockID, coroutine);
91. while (!lockedCoroutines.First(lockID, coroutine) && (Time.time - starttime) < waitTime)
92. {
93. yield return null;
94. counter += Time.deltaTime;
95. }
96. if (counter >= waitTime)
97. {
98. string error = this.GetType().Name + ": coroutine " + lockID + " bailing! due to timeout: " + counter;
99. Debug.LogError(error);
100. this.e = new Exception(error);
101. lockedCoroutines.Remove(lockID, coroutine);
102. yield break;
103. }
104. }
105. }
106. else
107. {
108. lockedCoroutines.Add(lockID, coroutine);
109. }
110. }
112. while (true)
113. {
114. try
115. {
116. if (!coroutine.MoveNext())
117. {
118. if (lockable) lockedCoroutines.Remove(lockID, coroutine);
119. yield break;
120. }
121. }
122. catch (Exception e)
123. {
124. this.e = e;
125. Debug.LogError(this.GetType().Name + ": caught Coroutine exception! " + e.Message + " " + e.StackTrace);
126. if (lockable) lockedCoroutines.Remove(lockID, coroutine);
127. yield break;
128. }
130. object yielded = coroutine.Current;
131. if (yielded != null && yielded.GetType() == typeof(T))
132. {
133. returnVal = (T)yielded;
134. if (lockable) lockedCoroutines.Remove(lockID, coroutine);
135. yield break;
136. }
137. else
138. {
139. yield return coroutine.Current;
140. }
141. }
142. }
143. }
146. /// <summary>
147. /// coroutine lock and queue
148. /// </summary>
149. public class LockQueue
150. {
151. private Dictionary<string, List<IEnumerator>> LockedCoroutines { get; set; }
153. public LockQueue()
154. {
155. LockedCoroutines = new Dictionary<string, List<IEnumerator>>();
156. }
158. /// <summary>
159. /// check if LockID is locked
160. /// </summary>
161. public bool Contains(string lockID)
162. {
163. return LockedCoroutines.ContainsKey(lockID);
164. }
166. /// <summary>
167. /// check if given coroutine is first in the queue
168. /// </summary>
169. public bool First(string lockID, IEnumerator coroutine)
170. {
171. bool ret = false;
172. if (Contains(lockID))
173. {
174. if (LockedCoroutines[lockID].Count > 0)
175. {
176. ret = LockedCoroutines[lockID][0] == coroutine;
177. }
178. }
179. return ret;
180. }
182. /// <summary>
183. /// Add the specified lockID and coroutine to the coroutine lockqueue
184. /// </summary>
185. public void Add(string lockID, IEnumerator coroutine)
186. {
187. if (!LockedCoroutines.ContainsKey(lockID))
188. {
189. LockedCoroutines.Add(lockID, new List<IEnumerator>());
190. }
192. if (!LockedCoroutines[lockID].Contains(coroutine))
193. {
194. LockedCoroutines[lockID].Add(coroutine);
195. }
196. }
198. /// <summary>
199. /// Remove the specified coroutine and queue if empty
200. /// </summary>
201. public bool Remove(string lockID, IEnumerator coroutine)
202. {
203. bool ret = false;
204. if (LockedCoroutines.ContainsKey(lockID))
205. {
206. if (LockedCoroutines[lockID].Contains(coroutine))
207. {
208. ret = LockedCoroutines[lockID].Remove(coroutine);
209. }
211. if (LockedCoroutines[lockID].Count == 0)
212. {
213. ret = LockedCoroutines.Remove(lockID);
214. }
215. }
216. return ret;
217. }
219. }
221. }
```
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

/// <summary>
/// Extending MonoBehaviour to add some extra functionality
/// Exception handling from: http://twistedoakstudios.com/blog/Post83_coroutines-more-than-you-want-to-know
/// 
/// 2013 Tim Tregubov
/// </summary>
public class TTMonoBehaviour : MonoBehaviour
{
	private LockQueue LockedCoroutineQueue { get; set; }
			
	/// <summary>
	/// Coroutine with return value AND exception handling on the return value. 
	/// </summary>
	public Coroutine<T> StartCoroutine<T>(IEnumerator coroutine)
	{
		Coroutine<T> coroutineObj = new Coroutine<T>();
		coroutineObj.coroutine = base.StartCoroutine(coroutineObj.InternalRoutine(coroutine));
		return coroutineObj;
	}
	
	/// <summary>
	/// Lockable coroutine. Can either wait for a previous coroutine to finish or a timeout or just bail if previous one isn't done.
	/// Caution: the default timeout is 10 seconds. Coroutines that timeout just drop so if its essential increase this timeout.
	/// Set waitTime to 0 for no wait
	/// </summary>
	public Coroutine<T> StartCoroutine<T>(IEnumerator coroutine, string lockID, float waitTime = 10f)
	{
		if (LockedCoroutineQueue == null) LockedCoroutineQueue = new LockQueue();
		Coroutine<T> coroutineObj = new Coroutine<T>(lockID, waitTime, LockedCoroutineQueue);
		coroutineObj.coroutine = base.StartCoroutine(coroutineObj.InternalRoutine(coroutine));
		return coroutineObj;
	}
	
	/// <summary>
	/// Coroutine with return value AND exception handling AND lockable
	/// </summary>
	public class Coroutine<T>
	{
		private T returnVal;
		private Exception e;
		private string lockID;
		private float waitTime;
		
		private LockQueue lockedCoroutines; //reference to objects lockdict
		private bool lockable;
		
		public Coroutine coroutine;
		public T Value
		{
			get 
			{ 
				if (e != null)
				{
					throw e;
				}
				return returnVal;
			}
		}
		
		public Coroutine() { lockable = false; }
		public Coroutine(string lockID, float waitTime, LockQueue lockedCoroutines)
		{
			this.lockable = true;
			this.lockID = lockID;
			this.lockedCoroutines = lockedCoroutines;
			this.waitTime = waitTime;
		}
		
		public IEnumerator InternalRoutine(IEnumerator coroutine)
		{
			if (lockable && lockedCoroutines != null)
			{		
				if (lockedCoroutines.Contains(lockID))
				{
					if (waitTime == 0f)
					{
						//Debug.Log(this.GetType().Name + ": coroutine already running and wait not requested so exiting: " + lockID);
						yield break;
					}
					else
					{
						//Debug.Log(this.GetType().Name + ": previous coroutine already running waiting max " + waitTime + " for my turn: " + lockID);
						float starttime = Time.time;
						float counter = 0f;
						lockedCoroutines.Add(lockID, coroutine);
						while (!lockedCoroutines.First(lockID, coroutine) && (Time.time - starttime) < waitTime)
						{
							yield return null;
							counter += Time.deltaTime;
						}
						if (counter >= waitTime)
						{ 
							string error = this.GetType().Name + ": coroutine " + lockID + " bailing! due to timeout: " + counter;
							Debug.LogError(error);
							this.e = new Exception(error);
							lockedCoroutines.Remove(lockID, coroutine);
							yield break;
						}
					}
				}
				else
				{
					lockedCoroutines.Add(lockID, coroutine);
				}
			}
			
			while (true)
			{
				try 
				{
					if (!coroutine.MoveNext())
					{
						if (lockable) lockedCoroutines.Remove(lockID, coroutine);
						yield break;
					}
				}
				catch (Exception e)
				{
					this.e = e;
					Debug.LogError(this.GetType().Name + ": caught Coroutine exception! " + e.Message + "
" + e.StackTrace); 
					if (lockable) lockedCoroutines.Remove(lockID, coroutine);
					yield break;
				}
				
				object yielded = coroutine.Current;
				if (yielded != null && yielded.GetType() == typeof(T))
				{
					returnVal = (T)yielded;
					if (lockable) lockedCoroutines.Remove(lockID, coroutine);
					yield break;
				}
				else
				{
					yield return coroutine.Current;
				}
			}
		}
	}
	
	
	/// <summary>
	/// coroutine lock and queue
	/// </summary>
	public class LockQueue
	{
		private Dictionary<string, List<IEnumerator>> LockedCoroutines { get; set; }
		
		public LockQueue()
		{
			LockedCoroutines = new Dictionary<string, List<IEnumerator>>();
		}
		
		/// <summary>
		/// check if LockID is locked
		/// </summary>
		public bool Contains(string lockID)
		{
			return LockedCoroutines.ContainsKey(lockID);
		}
		
		/// <summary>
		/// check if given coroutine is first in the queue
		/// </summary>
		public bool First(string lockID, IEnumerator coroutine)
		{
			bool ret = false;
			if (Contains(lockID))
			{
				if (LockedCoroutines[lockID].Count > 0)
				{
					ret = LockedCoroutines[lockID][0] == coroutine;
				}
			}
			return ret;
		}
		
		/// <summary>
		/// Add the specified lockID and coroutine to the coroutine lockqueue
		/// </summary>
		public void Add(string lockID, IEnumerator coroutine)
		{
			if (!LockedCoroutines.ContainsKey(lockID))
			{
				LockedCoroutines.Add(lockID, new List<IEnumerator>());
			}
			
			if (!LockedCoroutines[lockID].Contains(coroutine))
			{
				LockedCoroutines[lockID].Add(coroutine);
			}
		}
		
		/// <summary>
		/// Remove the specified coroutine and queue if empty
		/// </summary>
		public bool Remove(string lockID, IEnumerator coroutine)
		{
			bool ret = false;
			if (LockedCoroutines.ContainsKey(lockID))
			{
				if (LockedCoroutines[lockID].Contains(coroutine))
				{
					ret = LockedCoroutines[lockID].Remove(coroutine);
				}
				
				if (LockedCoroutines[lockID].Count == 0)
				{
					ret = LockedCoroutines.Remove(lockID);
				}
			}
			return ret;
		}
		
	}

}
```
小结：

本文主要是对 Unity StartCoroutine 进行了理解，从C# 的yileld 和 IEnumerator 到 Unity 的 StartCoroutine，最后并对Cortoutine 进行了扩展，虽然感觉不是很实用（用到的情况非常至少），但还是有利于对Coroutine 的理解和思考。

对于第三部分的代码感觉有不妥，没有进行测试，附件里有代码，有需求的话请自取

如果您对D.S.Qiu有任何建议或意见可以在文章后面评论，或者发邮件（gd.s.qiu@gmail.com)交流，您的鼓励和支持是我前进的动力，希望能有更多更好的分享。

转载请在文首注明出处：http://dsqiu.iteye.com/blog/2049743

更多精彩请关注D.S.Qiu的博客和微博（ID：静水逐风）

参考：

①琪琪爸的程序学习笔记 :-P：http://www.cnblogs.com/easyfrog/archive/2011/12/29/IEnumerable_IEnumerator_yield.html

②杰仔：http://www.cnblogs.com/illele/archive/2008/04/21/1164696.html

③Twisted Oak Studios: http://twistedoakstudios.com/blog/Post83_coroutines-more-than-you-want-to-know

④tim tregubov：http://zingweb.com/blog/2013/02/05/unity-coroutine-wrapper/

⑤C# in Depth： http://csharpindepth.com/articles/chapter6/iteratorblockimplementation.aspx

⑥zhw1125： http://blog.sina.com.cn/s/blog_3e29b20b0100g6ix.html
相关阅读:
Git 常用命令大全-转载
 Powershell重命名文件夹
 C#使用qq邮箱发送邮件
 iOS开发-YUV颜色格式
 iOS开发小记（十一）
iOS开发-AFNetworking
iOS开发-NSURLSession
iOS开发-类的加载load函数和initialize函数
 iOS开发-调试（debug）
iOS开发-graphics
原文地址：https://www.cnblogs.com/nafio/p/9137563.html