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. }   
5.     
6. public interface IEnumerator   
7. {   
8.     bool MoveNext();   
9.     void Reset();   
10.     
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;   
3.   
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.     }   
8.   
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;   
18.   
19.         [DebuggerHidden]   
20.         public <GetCounter>d__0(int <>1__state)   
21.         {   
22.             this.<>1__state = <>1__state;   
23.         }   
24.   
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;   
43.   
44.                 case 1:   
45.                     goto Label_004B;   
46.             }   
47.             return false;   
48.         }   
49.   
50.         [DebuggerHidden]   
51.         void IEnumerator.Reset()   
52.         {   
53.             throw new NotSupportedException();   
54.         }   
55.   
56.         void IDisposable.Dispose()   
57.         {   
58.         }   
59.   
60.         object IEnumerator<object>.Current   
61.         {   
62.             [DebuggerHidden]   
63.             get   
64.             {   
65.                 return this.<>2__current;   
66.             }   
67.         }   
68.   
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;   
3.   
4. private void MoveNext()   
5. {   
6.         elapesedTime += Time.deltaTime;   
7.            
8.         if(time <= elapsedTime)   
9.                 return false;   
10.         else return true;   
11.   
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;   
13.   
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.     }   
6.        
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());   
6.        
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;   
5.   
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; }   
15.                
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.     }   
25.        
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.     }   
38.        
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;   
48.            
49.         private LockQueue lockedCoroutines; //reference to objects lockdict   
50.         private bool lockable;   
51.            
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.         }   
64.            
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.         }   
73.            
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.             }   
111.                
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 + "\n" + e.StackTrace);    
126.                     if (lockable) lockedCoroutines.Remove(lockID, coroutine);   
127.                     yield break;   
128.                 }   
129.                    
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.     }   
144.        
145.        
146.     /// <summary>   
147.     /// coroutine lock and queue   
148.     /// </summary>   
149.     public class LockQueue   
150.     {   
151.         private Dictionary<string, List<IEnumerator>> LockedCoroutines { get; set; }   
152.            
153.         public LockQueue()   
154.         {   
155.             LockedCoroutines = new Dictionary<string, List<IEnumerator>>();   
156.         }   
157.            
158.         /// <summary>   
159.         /// check if LockID is locked   
160.         /// </summary>   
161.         public bool Contains(string lockID)   
162.         {   
163.             return LockedCoroutines.ContainsKey(lockID);   
164.         }   
165.            
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.         }   
181.            
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.             }   
191.                
192.             if (!LockedCoroutines[lockID].Contains(coroutine))   
193.             {   
194.                 LockedCoroutines[lockID].Add(coroutine);   
195.             }   
196.         }   
197.            
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.                 }   
210.                    
211.                 if (LockedCoroutines[lockID].Count == 0)   
212.                 {   
213.                     ret = LockedCoroutines.Remove(lockID);   
214.                 }   
215.             }   
216.             return ret;   
217.         }   
218.            
219.     }   
220.   
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 + "\n" + 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