Unity协程(Coroutine)原理深入剖析再续

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. }  

 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. }  

       在函数内使用前面介绍 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. }  

 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. }  

       从上面的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);  

       上面这行代码的伪代码实现:

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. }  

                                                                                                                                                                       增补于: 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. }  

 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.     }  

 下面为这个类扩展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. }  

 最后给出一个 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.     }  

 最后输出是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.         }  


其实就是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. }  

 测试运行会发现只会输出:

        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 { getset; }  
  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 { getset; }  
  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. }  

 

小结:

       本文主要是对 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:静水逐风) 

 

 

 

参考:

琪琪爸的程序学习笔记 :-Phttp://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 tregubovhttp://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

posted @ 2014-05-03 11:23  ing...  阅读(5414)  评论(0编辑  收藏  举报