एकता में कोराटाइन के साथ काम करना

एकता में Cority (Coroutines, coroutines) ऐसे कार्यों को चलाने के लिए एक सरल और सुविधाजनक तरीका है जो कुछ समय के लिए समानांतर में काम करना चाहिए। कोरआउट के साथ काम करने में मौलिक रूप से कुछ भी जटिल नहीं है और इंटरनेट उनके काम के सतही विवरण के साथ लेखों से भरा है। फिर भी, मुझे उनके पूरा होने के बाद निरंतर काम के साथ कोरटाइन के समूह को लॉन्च करने की संभावना का वर्णन करने वाला एक भी लेख नहीं मिला।
मैं आपको एक छोटा पैटर्न प्रदान करना चाहता हूं जो इस अवसर को लागू करता है, साथ ही साथ कोरटाइन के बारे में जानकारी का चयन भी करता है।



Coroutines सरल C # पुनरावृत्तियाँ हैं जो एक IEnumerator लौटाते हैं और उपज कीवर्ड का उपयोग करते हैं। एकता में, कोरटाइन्स को दर्ज किया गया है और पहली उपज से पहले स्टार्टकॉरटाइन विधि का उपयोग करके निष्पादित किया गया है। इसके बाद, यूनिटी प्रत्येक कॉल के बाद अद्यतन करने के लिए और लेट यूपीडेट को कॉल करने से पहले, पंजीकृत कोड के अगले ब्लॉक में आगे बढ़ने के लिए पैदावार में लौटाए गए मूल्य से निर्धारित करते हुए यूनिटी को पोल करती है।

उपज में रिटर्न वैल्यू के कई विकल्प हैं:

निम्नलिखित फिक्स्डडेट के बाद जारी रखें:

yield return new WaitForFixedUpdate(); 

निम्नलिखित लेटअपडेट और दृश्य रेंडरिंग के बाद जारी रखें:

 yield return new WaitForEndOfFrame(); 

थोड़ी देर बाद जारी रखें:

 yield return new WaitForSeconds(0.1f); //    100ms 

एक और corutin को पूरा करना जारी रखें:

 yield return StartCoroutine(AnotherCoroutine()); 

दूरस्थ संसाधन लोड करने के बाद जारी रखें:

 yield return new WWW(someLink); 

अन्य सभी रिटर्न मान इंगित करते हैं कि अपडेट लूप की वर्तमान पुनरावृत्ति को पारित करने के बाद क्या जारी रखने की आवश्यकता है:

 yield return null; 

आप कोरुटिन को इस तरह से बाहर निकाल सकते हैं:

 yield return break; 

WaitForSeconds का उपयोग करने से मेमोरी में लंबे समय तक रहने वाली वस्तु (हीप द्वारा प्रबंधित) बनाई जाती है, इसलिए तेज़ लूप में इसका उपयोग करना एक बुरा विचार हो सकता है।

मैंने पहले ही लिखा था कि कोरटाइन समानांतर रूप से काम करते हैं, यह स्पष्ट किया जाना चाहिए कि वे अतुल्यकालिक रूप से काम नहीं करते हैं, अर्थात, वे एक ही धागे में निष्पादित होते हैं।

कोरुटिन का एक सरल उदाहरण:

 void Start() { StartCoroutine(TestCoroutine()); } IEnumerator TestCoroutine() { while(true) { yield return null; Debug.Log(Time.deltaTime); } } 

यह कोड एक लूप के साथ कोरटाइन शुरू करता है जो अंतिम फ्रेम के बाद से गुजरे हुए कंसोल को लिखेगा।
यह ध्यान दिया जाना चाहिए कि कोरटीन में, उपज रिटर्न नल को पहले कहा जाता है, और उसके बाद ही एक लॉग प्रविष्टि होती है। हमारे मामले में, यह इसलिए मायने रखता है क्योंकि कोरटाइन का निष्पादन फिलहाल शुरू होता है StartCoroutine (TestCoroutine ()) कहा जाता है , और उपज वापसी के बाद कोड के अगले ब्लॉक में संक्रमण अद्यतन विधि के बाद किया जाएगा, इसलिए पहले उपज के पहले और बाद में अशक्त हो जाता है । डेल्टा एक ही मूल्य को इंगित करेगा।

यह भी ध्यान दिया जाना चाहिए कि अनंत लूप वाले कोरटीन को स्टॉपअलॉरूटीन () , स्टॉपकॉरटाइन ("टेस्टकॉरटाइन") कहकर या अभिभावक गेमऑब्जेक्ट को नष्ट करके अभी भी बाधित किया जा सकता है।

सब ठीक है। इसलिए हम कोरटाइन्स की मदद से प्रत्येक फ्रेम के कुछ मानों की जाँच करने वाले ट्रिगर्स बना सकते हैं, हम एक के बाद एक लॉन्च किए गए कोरआउट्स का एक क्रम बना सकते हैं, उदाहरण के लिए, विभिन्न चरणों में विभिन्न गणनाओं के साथ एनिमेशन की एक श्रृंखला खेल रहे हैं। या सिर्फ पैदावार वापसी के बिना कोरटाइन के अंदर अन्य कोराउटाइन चलाएं और निष्पादन जारी रखें। लेकिन कोरटाइन्स के समूह को कैसे लॉन्च किया जाए, समानांतर में काम कर रहे हैं, और केवल उनके पूरा होने पर जारी है?

बेशक, आप उस वर्ग में जोड़ सकते हैं जिसमें कोरटाइन को एक चर के रूप में परिभाषित किया गया है जो वर्तमान स्थिति को इंगित करता है:

ले जाने के लिए कक्षा:

 public bool IsMoving = false; IEnumerator MoveCoroutine(Vector3 moveTo) { IsMoving = true; //        var iniPosition = transform.position; while (transform.position != moveTo) { //              //     yield return null; } IsMoving = false; } 

एक वर्ग जिसे स्थानांतरित करने के लिए कक्षाओं के समूह के साथ काम किया जाता है:

 IEnumetaror PerformMovingCoroutine() { //   foreach(MovableObjectScript s in objectsToMove) { //   StartCoroutine(s.MoveCoroutine(moveTo)); } bool isMoving = true; while (isMoving) { isMoving = false; Array.ForEach(objectsToMove, s => { if (s.IsMoving) isMoving = true; }); if (isMoving) yield return null; } //    } 

MoveToroutine coroutine को ऑब्जेक्ट्सटोमोव सरणी में प्रत्येक ऑब्जेक्ट के पूरा होने के बाद "अधिक काम करें" ब्लॉक निष्पादित किया जाना शुरू हो जाएगा।

खैर, पहले से ही अधिक दिलचस्प है।
लेकिन क्या होगा अगर हम किसी भी समय, कहीं भी जाँच करने की क्षमता के साथ, कोरटाइन का एक समूह बनाना चाहते हैं, क्या समूह ने अपना काम पूरा कर लिया है?
चलो करते हैं!

सुविधा के लिए, हम सब कुछ विस्तार विधियों के रूप में करेंगे:

 public static class CoroutineExtension { //     < ,   > static private readonly Dictionary<string, int> Runners = new Dictionary<string, int>(); // MonoBehaviour          public static void ParallelCoroutinesGroup(this IEnumerator coroutine, MonoBehaviour parent, string groupName) { if (!Runners.ContainsKey(groupName)) Runners.Add(groupName, 0); Runners[groupName]++; parent.StartCoroutine(DoParallel(coroutine, parent, groupName)); } static IEnumerator DoParallel(IEnumerator coroutine, MonoBehaviour parent, string groupName) { yield return parent.StartCoroutine(coroutine); Runners[groupName]--; } //   ,   ,       public static bool GroupProcessing(string groupName) { return (Runners.ContainsKey(groupName) && Runners[groupName] > 0); } } 

अब यह कोरटाइन्स पर पैरेललॉरॉइंट्सग्रुप विधि को कॉल करने के लिए पर्याप्त है और तब तक प्रतीक्षा करें जब तक कि कोरटाइनटेक्स्टेंशन.ग्रुपप्रोसेसिंग विधि सही न हो जाए:

 public class CoroutinesTest : MonoBehaviour { // Use this for initialization void Start() { StartCoroutine(GlobalCoroutine()); } IEnumerator GlobalCoroutine() { for (int i = 0; i < 5; i++) RegularCoroutine(i).ParallelCoroutinesGroup(this, "test"); while (CoroutineExtension.GroupProcessing("test")) yield return null; Debug.Log("Group 1 finished"); for (int i = 10; i < 15; i++) RegularCoroutine(i).ParallelCoroutinesGroup(this, "anotherTest"); while (CoroutineExtension.GroupProcessing("anotherTest")) yield return null; Debug.Log("Group 2 finished"); } IEnumerator RegularCoroutine(int id) { int iterationsCount = Random.Range(1, 5); for (int i = 1; i <= iterationsCount; i++) { yield return new WaitForSeconds(1); } Debug.Log(string.Format("{0}: Coroutine {1} finished", Time.realtimeSinceStartup, id)); } } 

हो गया!