碼上快樂

相關內容    簡體    繁體

Unity協程（Coroutine）原理深入剖析再續

本文轉載自   查看原文   2014-05-03 11:23   4974    Unity(轉)

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

 

小結：

       本文主要是對 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


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Unity 協程(Coroutine)原理與用法詳解 unity協程coroutine淺析 協程的原理（Coroutine Theory） 【Unity】協程Coroutine及Yield常見用法 關於Unity3D的協程（Coroutine） Unity怎樣在Editor下運行協程(coroutine) Python 協程 (Coroutine) 協程簡介（coroutine） Python之協程(coroutine) 協程Coroutine
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM