स्पंदन अनुप्रयोगों में अशुद्धता का उपयोग करना

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

अशुद्धियाँ क्या हैं?

एक प्रारंभिक परिचित के लिए, मैं विकिपीडिया से एक उद्धरण दूंगा।

प्रवेश (अंग्रेजी मिश्रण) एक प्रोग्रामिंग भाषा (आमतौर पर एक वर्ग या मॉड्यूल) का एक तत्व है जो कुछ स्पष्ट रूप से परिभाषित व्यवहार को लागू करता है। अन्य वर्गों के व्यवहार को स्पष्ट करने के लिए उपयोग किया जाता है, स्वतंत्र रूप से उपयोग की जाने वाली वस्तुओं को उत्पन्न करने का इरादा नहीं है।

डार्ट में, इस तरह के निर्माण को नाम से पहले मिक्सिन शब्द द्वारा परिभाषित किया गया है।

उपरोक्त परिभाषा का मतलब है कि हमें तार्किक रूप से अलग-थलग व्यवहार की कार्यक्षमता मिलती है जिसे अन्य वर्गों में जोड़ा जा सकता है।

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

मान लीजिए कि हमारे पास एक अमूर्त वर्ग पशु है।

abstract class Animal { void voice(); } 

और कैट और डॉग क्लास भी हैं जो एनिमल क्लास को लागू करते हैं।

 class Cat extends Animal { void voice() { print(“Meow”); } } class Dog extends Animal { void voice() { print(“Woof”); } } 

हां, हां, व्यक्तिगत रूप से मेरे पास विकास के दौरान ऐसी चीजें नहीं हैं।

और कई उत्तराधिकार के मामले में, हम भी ऐसा ही करेंगे।

 class CatDog extends Cat, Dog { } 

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


अशुद्धियों के माध्यम से बिक्री के मामले में, हम इसका सामना नहीं करेंगे।

 lass Animal { void voice() { print(“Hakuna Matata!”); } } mixin Cat { void voice() { print(“Meow”); } } mixin Dog { void voice() { print(“Woof”); } } class CatDog extends Animal with Cat, Dog { } 

और अगर हम अब वॉयस कमांड देंगे तो हम क्या सुनेंगे? इस मामले में - Woof, और जैसा कि आप पहले से ही समझ चुके हैं, यह अशुद्धियों को जोड़ने के क्रम पर निर्भर करता है। ऐसा इसलिए होता है क्योंकि उनका जोड़ समानांतर नहीं होता, लेकिन अनुक्रमिक होता है।

मैंने विशेष रूप से डार्ट 2.1 में शुरू की गई एक विशेषता को चिह्नित करने के लिए पशु वर्ग को लागू किया। इससे पहले, अशुद्धियों को केवल उन कक्षाओं में जोड़ा जा सकता है जो ऑब्जेक्ट से प्राप्त होते हैं। संस्करण 2.1 से शुरू होकर वारिसों के लिए किसी भी वर्ग को शामिल किया गया है।

यह तंत्र कार्यात्मक के सामान्य भागों को बनाने और उपयोग करने के लिए बहुत सुविधाजनक बनाता है, जो कोड दोहराव की समस्या को हल करता है। आइए एक उदाहरण देखें।

 abstract class Sportsman { void readySteadyGo(); } mixin SkiRunner { void run() { print(“Ski, ski, ski”); } } mixin RifleShooter { void shot() { print(“Pew, pew, pew”); } } class Shooter() extends Sportsman with RifleShooter { void readySteadyGo() { shot(); } } class Skier() extends Sportsman with SkiRunner { void readySteadyGo() { run(); } } class Biathlete() extends Sportsman with SkiRunner, RifleShooter { void readySteadyGo() { run(); shot(); } } 

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

विकास के दौरान, ऐसी स्थिति उत्पन्न हो सकती है जब किसी भी अशुद्धियों की कार्यक्षमता सार्वजनिक रूप से सभी वर्गों द्वारा शामिल किए जाने के लिए उपलब्ध नहीं होनी चाहिए। और एक तंत्र जो हमें इन प्रतिबंधों को लागू करने की अनुमति देगा, वह भी उपलब्ध है। यह कक्षा के नाम के साथ प्रवेश घोषणा में कीवर्ड पर है। तो हम केवल उन वर्गों के लिए अशुद्धियों के उपयोग को सीमित करेंगे जो निर्दिष्ट या उससे विरासत में लागू होते हैं।

उदाहरण के लिए:

 class A { } abstract class B { } mixin M1 on A { } mixin M2 on B { } 

फिर हम समान वर्गों की घोषणा कर सकते हैं:

 class C extends A with M1 { } class D implements B with M2 { } 

लेकिन हमें इस तरह से कुछ घोषित करने की कोशिश में त्रुटि मिलती है:

 class E with M1, M2 { } 

स्पंदन अनुप्रयोग में उपयोग

जैसा कि मैंने ऊपर उल्लेख किया है, अशुद्धियाँ आपको कोड के दोहराव से छुटकारा पाने और अलग-अलग तार्किक भागों को बनाने की अनुमति देती हैं जिनका पुन: उपयोग किया जा सकता है। लेकिन यह आम तौर पर स्पंदन के लिए कैसे लागू होता है, जहां सब कुछ परमाणु है और इसलिए विजेट में विभाजित है जो एक निश्चित कार्यक्षमता के लिए जिम्मेदार हैं? एक उदाहरण के रूप में, मैंने तुरंत एक ऐसी स्थिति की कल्पना की जिसमें परियोजना कई विजेट का उपयोग करती है, जिसका प्रदर्शन एक निश्चित आंतरिक स्थिति के आधार पर भिन्न होता है। मैं बीएलओसी वास्तुकला में इस उदाहरण पर विचार करूंगा और आरएक्सडार्ट लाइब्रेरी से संस्थाओं का उपयोग करूंगा।

प्रवाह नियंत्रक को बंद करने के लिए हमें एक इंटरफ़ेस की आवश्यकता है।

 /// Interface for disposable objects abstract class Disposable { void dispose(); } 

एक प्रवेशपत्र जिसके साथ हम राज्य समर्थन लागू करते हैं।

 /// Mixin for object which support state mixin StateProvider implements Disposable { static const NONE_STATE = "None"; final _stateController = BehaviorSubject<String>(seedValue: NONE_STATE); Observable<String> get stateOut => _stateController.stream; String get currentState => _stateController.value; void setState(String state) { _stateController.sink.add(state); } @override void dispose() { _stateController.close(); } } 

तार्किक भाग जो विजेट की स्थिति को नियंत्रित करेगा। उसे विधि को कॉल करके एक स्थिति निर्धारित करने दें और 3 सेकंड के बाद इसे दूसरे में बदल दें।

 /// Example BLoC class ExampleBloc implements Disposable with StateProvider { static const EXAMPLE_STATE_1 = "EX1"; static const EXAMPLE_STATE_2 = "EX2"; Timer _timer; void init() { setState(EXAMPLE_STATE_1); _timer = new Timer(const Duration(seconds: 3), () { _timer = null; setState(EXAMPLE_STATE_2); }); } @override void dispose() { if (_timer != null) { _timer.cancel(); _timer = null; } } } 

और विजेट ही है कि एक राज्य परिवर्तन का जवाब देंगे। निर्भरता इंजेक्शन का उपयोग करके वांछित तार्किक घटक प्राप्त करने की कल्पना करें।

 class ExampleWidget extends StatelessWidget { final bloc = di<HomePageBloc>(); @override Widget build(BuildContext context) { return StreamBuilder( stream: bloc.stateOut, builder: (BuildContext context, AsyncSnapshot<String> snapshot) { // build widget by state }, ); } } 

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

निष्कर्ष

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

संसाधन:
डार्ट भाषा का एक दौरा
विकिपीडिया