एकता में थोड़ा और अधिक सुविधाजनक बनाने के लिए कैसे करें

प्रत्येक डेवलपर यूनिटी में कोरटाइन का उपयोग करने के अपने फायदे और नुकसान पाता है। और वह यह तय करता है कि किन परिदृश्यों में उन्हें लागू किया जाए, और जिसमें विकल्पों को वरीयता दी जाए।

रोजमर्रा के अभ्यास में, मैं अक्सर विभिन्न प्रकार के कार्यों के लिए कोरटाइन का उपयोग करता हूं। एक बार, मुझे एहसास हुआ कि यह वह था जिसने मुझे परेशान किया और उनमें कई नए लोगों को खारिज कर दिया।

बुरा सपना

इंजन केवल कुछ तरीके प्रदान करता है और कोरटाइन के साथ काम करने के लिए उनके कई अधिभार:

लॉन्च ( डॉक्स )

• StartCoroutine(string name, object value = null)
• StartCoroutine(IEnumerator routine)

बंद करो ( डॉक्स )

• StopCoroutine(string methodName)
• StopCoroutine(IEnumerator routine)
• StopCoroutine(Coroutine routine)

स्ट्रिंग मापदंडों के साथ ओवरलोड (उनकी भ्रामक सुविधा के बावजूद) तुरंत कर सकते हैं कूड़ेदान में भेजें कम से कम तीन कारणों से भूल जाओ।

• स्ट्रिंग विधि के नामों का स्पष्ट उपयोग भविष्य के कोड विश्लेषण, डीबगिंग और अधिक को जटिल करेगा।
• प्रलेखन के अनुसार, स्ट्रिंग ओवरलोड अधिक समय लेते हैं और केवल एक अतिरिक्त पैरामीटर को पारित करने की अनुमति देते हैं।
• मेरे व्यवहार में, अक्सर यह पता चला है कि जब StopCoroutine स्ट्रिंग अधिभार को StopCoroutine गया था तो कुछ भी नहीं हुआ था। कोरटीन को अंजाम दिया जाता रहा।

एक ओर, प्रदान की गई विधियाँ बुनियादी जरूरतों को पूरा करने के लिए पर्याप्त हैं। लेकिन समय के साथ, मैंने नोटिस करना शुरू कर दिया कि सक्रिय उपयोग के साथ मुझे बड़ी मात्रा में बॉयलरप्लेट कोड लिखना होगा - यह थकाऊ है, और इसकी पठनीयता को बाधित करता है।

बिंदु के करीब

इस लेख में मैं एक छोटे रैपर का वर्णन करना चाहता हूं जो मैं लंबे समय से उपयोग कर रहा हूं। उसके लिए धन्यवाद, कोरटाइन के बारे में विचारों के साथ, टेम्पलेट कोड के टुकड़े अब मेरे सिर में दिखाई नहीं देते हैं जिसके साथ मुझे उनके चारों ओर नृत्य करना था। इसके अलावा, पूरी टीम उन घटकों को पढ़ने और समझने में आसान हो गई है जहां कॉरआउट का उपयोग किया जाता है।

मान लें कि हमारे पास निम्नलिखित कार्य हैं - एक घटक लिखने के लिए जो आपको किसी दिए गए बिंदु पर एक वस्तु को स्थानांतरित करने की अनुमति देता है।

इस क्षण में, इससे कोई फर्क नहीं पड़ता कि स्थानांतरित करने के लिए और किस निर्देशांक में किस विधि का उपयोग किया जाएगा। मेरे द्वारा चुने गए कई विकल्पों में से केवल एक ही होगा - ये प्रक्षेप और वैश्विक निर्देशांक हैं।

कृपया ध्यान दें कि किसी ऑब्जेक्ट को उसके माथे पर "माथे पर" बदलकर नहीं ले जाने की अनुशंसा की जाती है, अर्थात, निर्माण transform.position = newPosition यदि RigidBody घटक का उपयोग किया जाता है (विशेषकर Update विधि में) ( डॉक्स )।

मानक कार्यान्वयन

मैं आवश्यक घटक के निम्नलिखित कार्यान्वयन का प्रस्ताव करता हूं:

 using IEnumerator = System.Collections.IEnumerator; using UnityEngine; public sealed class MoveToPoint : MonoBehaviour { public Vector3 target; [Space] public float speed; public float threshold; public void Move() { if (moveRoutine == null) StartCoroutine(MoveRoutine()); } private IEnumerator MoveRoutine() { while (Vector3.Distance(transform.position, target) > threshold) { transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime); yield return null; } } } 

यह सब अब के लिए है, हमारा घटक काफी सरल है। और फिलहाल कोई समस्या नहीं है। लेकिन, यह घटक क्या है जो आपको एक बिंदु पर एक वस्तु को स्थानांतरित करने की अनुमति देता है, लेकिन इसे रोकने का अवसर प्रदान नहीं करता है। आइए इस अन्याय को ठीक करें।

चूँकि आपने और मैंने दुष्ट पक्ष पर नहीं जाने का फैसला किया था, और स्ट्रिंग मापदंडों के साथ अतिभार का उपयोग नहीं किया था, अब हमें कहीं न कहीं दौड़ने वाली कोरटाइन की एक कड़ी को बचाने की जरूरत है। नहीं तो फिर उसे कैसे रोका जाए?

एक फ़ील्ड जोड़ें:

 private Coroutine moveRoutine; 

Move ठीक करें:

 public void Move() { if (moveRoutine == null) moveRoutine = StartCoroutine(MoveRoutine()); } 

स्टॉप मोशन विधि जोड़ें:

 public void Stop() { if (moveRoutine != null) StopCoroutine(moveRoutine); } 

 using IEnumerator = System.Collections.IEnumerator; using UnityEngine; public sealed class MoveToPoint : MonoBehaviour { public Vector3 target; [Space] public float speed; public float threshold; private Coroutine moveRoutine; public void Move() { if (moveRoutine == null) moveRoutine = StartCoroutine(MoveRoutine()); } public void Stop() { if (moveRoutine != null) StopCoroutine(moveRoutine); } private IEnumerator MoveRoutine() { while (Vector3.Distance(transform.position, target) > threshold) { transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime); yield return null; } } } 

एक पूरी तरह से अलग मामला! कम से कम घाव पर लगाएं।

So. हमारे पास एक छोटा घटक है जो कार्य करता है। मेरा आक्रोश क्या है?

समस्याएं और उनका समाधान

समय के साथ, परियोजना बढ़ती है, और इसके साथ घटकों की संख्या, जिनमें कोरटाइन का उपयोग करने वाले शामिल हैं। और हर बार, ये चीजें मुझे अधिक से अधिक परेशान कर रही हैं:

• चल रहा है सैंडविच कॉल

 StartCoroutine(MoveRoutine()); 

 StopCoroutine(moveRoutine); 

बस उन्हें देखने से मेरी आंख मरोड़ती है, और ऐसा कोड पढ़ना एक संदिग्ध खुशी है (मैं सहमत हूं, यह बदतर हो सकता है)। लेकिन यह बहुत अच्छा होगा और अधिक दृश्य कुछ ऐसा होगा:

 moveRoutine.Start(); 

 moveRoutine.Stop(); 

• हर बार जब आप StartCoroutine कॉल StartCoroutine तो आपको रिटर्न वैल्यू बचाने के लिए याद रखना चाहिए:

 moveRoutine = StartCoroutine(MoveRoutine()); 

अन्यथा, कोरटाइन के संदर्भ में कमी के कारण, आप इसे रोक नहीं सकते।

• लगातार जांच:

 if (moveRoutine == null) 

 if (moveRoutine != null) 

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

   moveRoutine = null; 

यदि आप भूल जाते हैं, तो आपको एक बार का धन प्राप्त होगा। moveRoutine में पहले रन के बाद, moveRoutine के लिए लिंक रहेगा, और नया रन काम नहीं करेगा।

उसी तरह, आपको मजबूर स्टॉप के मामले में करने की आवश्यकता है:

 public void Stop() { if (moveRoutine != null) { StopCoroutine(moveRoutine); moveRoutine = null; } } 

 public sealed class MoveToPoint : MonoBehaviour { public Vector3 target; [Space] public float speed; public float threshold; private Coroutine moveRoutine; public void Move() { moveRoutine = StartCoroutine(MoveRoutine()); } public void Stop() { if (moveRoutine != null) { StopCoroutine(moveRoutine); moveRoutine = null; } } private IEnumerator MoveRoutine() { while (Vector3.Distance(transform.position, target) > threshold) { transform.localPosition = Vector3.Lerp(transform.position, target, speed * Time.deltaTime); yield return null; } moveRoutine = null; } } 

एक बिंदु पर, मैं वास्तव में एक बार इस पूरे बहाने को कहीं बाहर ले जाना चाहता हूं, और केवल अपने लिए आवश्यक विधियों को छोड़ता हूं: Start , Stop और कुछ और घटनाओं और गुणों को।

चलो अंत में यह करो!

 using System.Collections; using System; using UnityEngine; public sealed class CoroutineObject { public MonoBehaviour Owner { get; private set; } public Coroutine Coroutine { get; private set; } public Func<IEnumerator> Routine { get; private set; } public bool IsProcessing => Coroutine != null; public CoroutineObject(MonoBehaviour owner, Func<IEnumerator> routine) { Owner = owner; Routine = routine; } private IEnumerator Process() { yield return Routine.Invoke(); Coroutine = null; } public void Start() { Stop(); Coroutine = Owner.StartCoroutine(Process()); } public void Stop() { if (IsProcessing) { Owner.StopCoroutine(Coroutine); Coroutine = null; } } } 

इस प्रकार, हमें बड़ी मात्रा में सिरदर्द से छुटकारा मिलता है, और हमारा घटक पूरी तरह से अलग दिखता है:

 using IEnumerator = System.Collections; using UnityEngine; public sealed class MoveToPoint : MonoBehaviour { public Vector3 target; [Space] public float speed; public float threshold; private CoroutineObject moveRoutine; private void Awake() { moveRoutine = new CoroutineObject(this, MoveRoutine); } public void Move() => moveRoutine.Start(); public void Stop() => moveRoutine.Stop(); private IEnumerator MoveRoutine() { while (Vector3.Distance(transform.position, target) > threshold) { transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime); yield return null; } } } 

जो कुछ भी शेष है, वह स्वयं और इसके साथ काम करने के लिए कोड की कुछ पंक्तियां हैं। काफी बेहतर है।

मान लीजिए कि एक नया कार्य आया है - आपको किसी भी कोड को निष्पादित करने की क्षमता जोड़ने की आवश्यकता है क्योंकि ऑब्जेक्ट अपने लक्ष्य तक पहुंच गया है।

मूल संस्करण में, हमें प्रत्येक coroutine में एक अतिरिक्त प्रतिनिधि पैरामीटर जोड़ना होगा जो इसके पूरा होने के बाद खींचा जा सकता है।

 private IEnumerator MoveRoutine(System.Action callback) { while (Vector3.Distance(transform.position, target) > threshold) { transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime); yield return null; } moveRoutine = null callback?.Invoke(); } 

और निम्नानुसार कॉल करें:

 moveRoutine = StartCoroutine(moveRoutine(CallbackHandler)); private void CallbackHandler() { // do something } 

और अगर एक हैंडलर के रूप में कुछ मेमने हैं, तो यह और भी बुरा लग रहा है।

हमारे आवरण के साथ, यह इस घटना को केवल एक बार जोड़ने के लिए पर्याप्त है।

 public Action Finish; 

 private IEnumerator Process() { yield return Routine.Invoke(); Coroutine = null; Finish?.Invoke(); } 

और फिर, यदि आवश्यक हो, तो सदस्यता लें।

 moveRoutine.Finished += OnFinish; private void OnFinish() { // do something } 

मेरा मानना ​​है कि आपने पहले ही ध्यान दिया है कि रैपर का वर्तमान संस्करण बिना मापदंडों के केवल कोरटाइन के साथ काम करने की क्षमता प्रदान करता है। इसलिए, हम एक पैरामीटर के साथ कोरटाइन के लिए एक सामान्यीकृत आवरण लिख सकते हैं। बाकी सब सादृश्य द्वारा किया जाता है।

लेकिन, अच्छे के लिए, पहले कोड डालना अच्छा होगा, जो कि सभी रैपरों के लिए, कुछ आधार वर्ग में समान होगा, ताकि एक ही चीज़ न लिखें। हम इससे लड़ रहे हैं।

हम इसे हटा देते हैं:

• गुण Owner , Coroutine , IsProcessing
• घटना Finished

 using Action = System.Action; using UnityEngine; public abstract class CoroutineObjectBase { public MonoBehaviour Owner { get; protected set; } public Coroutine Coroutine { get; protected set; } public bool IsProcessing => Coroutine != null; public abstract event Action Finished; } 

 using System; using System.Collections; using UnityEngine; public sealed class CoroutineObject : CoroutineObjectBase { public Func<IEnumerator> Routine { get; private set; } public override event Action Finished; public CoroutineObject(MonoBehaviour owner, Func<IEnumerator> routine) { Owner = owner; Routine = routine; } private IEnumerator Process() { yield return Routine.Invoke(); Coroutine = null; Finished?.Invoke(); } public void Start() { Stop(); Coroutine = Owner.StartCoroutine(Process()); } public void Stop() { if(IsProcessing) { Owner.StopCoroutine(Coroutine); Coroutine = null; } } } 

और अब, वास्तव में, एक पैरामीटर के साथ कोरटाइन के लिए एक आवरण:

 using System; using System.Collections; using UnityEngine; public sealed class CoroutineObject<T> : CoroutineObjectBase { public Func<T, IEnumerator> Routine { get; private set; } public override event Action Finished; public CoroutineObject(MonoBehaviour owner, Func<T, IEnumerator> routine) { Owner = owner; Routine = routine; } private IEnumerator Process(T arg) { yield return Routine.Invoke(arg); Coroutine = null; Finished?.Invoke(); } public void Start(T arg) { Stop(); Coroutine = Owner.StartCoroutine(Process(arg)); } public void Stop() { if(IsProcessing) { Owner.StopCoroutine(Coroutine); Coroutine = null; } } } 

जैसा कि आप देख सकते हैं, कोड लगभग समान है। तर्कों की संख्या के आधार पर केवल कुछ स्थानों में टुकड़े जोड़े गए थे।

मान लीजिए कि हमें MoveToPoint घटक को अपडेट करने के लिए कहा गया था, ताकि बिंदु को संपादक में Inspector विंडो के माध्यम से सेट नहीं किया जा सके, लेकिन जब कोड विधि को कॉल किया गया तो कोड द्वारा।

 using IEnumerator = System.Collections.IEnumerator; using UnityEngine; public sealed class MoveToPoint : MonoBehaviour { public float speed; public float threshold; private CoroutineObject<Vector3> moveRoutine; public bool IsMoving => moveRoutine.IsProcessing; private void Awake() { moveRoutine = new CoroutineObject<Vector3>(this, MoveRoutine); } public void Move(Vector3 target) => moveRoutine.Start(target); public void Stop() => moveRoutine.Stop(); private IEnumerator MoveRoutine(Vector3 target) { while (Vector3.Distance(transform.position, target) > threshold) { transform.localPosition = Vector3.Lerp(transform.position, target, speed); yield return null; } } } 

इस रैपर की कार्यक्षमता को अधिक से अधिक बढ़ाने के लिए कई विकल्प हैं: एक विलंबित लॉन्च, मापदंडों के साथ ईवेंट, कोरटाइन प्रगति की संभावित ट्रैकिंग और बहुत कुछ जोड़ें। लेकिन मैं इस स्तर पर रुकने का सुझाव देता हूं।

इस लेख का उद्देश्य उन दबाव की समस्याओं को साझा करने की इच्छा है जो मैंने सामना किया और उनके समाधान का प्रस्ताव किया, न कि सभी डेवलपर्स की संभावित जरूरतों को कवर करने के लिए।

मुझे उम्मीद है कि मेरे अनुभव से शुरुआती और अनुभवी दोनों कामरेड लाभान्वित होंगे। शायद वे अपनी टिप्पणी साझा करेंगे या उन त्रुटियों को इंगित करेंगे जो मैं कर सकता था।