प्रोग्राम कोड और ग्राफ़िकल इंटरफ़ेस कोड को अलग-अलग वर्गों में पैकेज करने के लिए इसे एक सर्वोत्तम अभ्यास क्यों माना जाता है?

Question

तो मेरे शिक्षक मुझसे कहते हैं कि एक ही कक्षाओं में प्रोग्राम कोड और ग्राफिकल इंटरफ़ेस कोड को एनकैप्सुलेट नहीं करना बहुत महत्वपूर्ण है, लेकिन उन्हें पूरी तरह से स्वतंत्र रखने के लिए। Im वर्तमान में एक ग्रिड के साथ एक iPhone खेल लिख रहा है। मेरे लिए यह एक ही "ग्रिड" वर्ग में चित्रमय ग्रिड और तकनीकी कोड दोनों बनाने के लिए बहुत अधिक समझ में आता है। क्या अन्य प्रोग्रामर इस पर ध्यान केंद्रित करेंगे? क्या वास्तव में ग्राफिकल इंटरफ़ेस और कोड को स्वतंत्र रखना बहुत महत्वपूर्ण है। अगर मैं नहीं करूँ तो क्या समस्याएँ आएंगी?

धन्यवाद!

संपादित करें: धन्यवाद दोस्तों! क्या मेरे लिए यह ठीक होगा कि पहले मैं प्रोजेक्ट लिखूं और फिर कोड को कॉपी करके आसपास के डिजाइन को अलग करूं। मुझे पता है कि यह पूरी तरह से उद्देश्य को हरा सकता है, लेकिन सिर्फ अभ्यास के रूप में ... ताकि अगली बार मैं इस डिजाइन पैटर्न को शुरू से लागू कर सकूं?

Answer 1

आपके शिक्षक जिस अवधारणा का जिक्र कर रहे हैं वह कुछ अलग है जिसे सेपरेशन ऑफ कंसर्न कहा जाता है।

इसे अपने संदर्भ में स्पष्ट करने के लिए, यदि आप अपना कार्यक्रम पूरा करते हैं और फिर निर्णय लेते हैं कि आप इसे एंड्रॉइड पर पोर्ट करना चाहते हैं; यदि आपने ग्रिड लॉजिक को अलग रखा है, तो आपको बहुत अधिक कोड फिर से लिखना होगा।

एक इंटरफ़ेस नियंत्रण केवल ड्राइंग के साथ संबंधित होना चाहिए जो इसे बताया गया है, ग्रिड तर्क केवल ग्रिड में क्या है, इसे कैसे आकर्षित किया जाए, के साथ संबंधित होना चाहिए।

क्या यह मदद करता है ?

Comments

धन्यवाद इससे मदद मिली। बात यह है कि मेरे लिए अपने अंतिम उत्पाद की कल्पना करना मेरे लिए बहुत आसान है जब मैं एक कक्षा में दोनों को एनकैप्सुलेट करता हूं। क्या यह स्वयं के लिए "चिंताओं के अलगाव" का पालन नहीं करने का एक वैध कारण है? या यह बिल्कुल आवश्यक है और मैं खुद को एक उचित प्रोग्रामर नहीं कह सकता: पी?

इस पृथक्करण का एक सकारात्मक प्रभाव यह है, कि आपको अपने खेल तर्क को फिर से लिखना नहीं है, यदि आप उदाहरण के लिए अपने गुई को बदलना चाहते हैं

@ जॉन - यदि आपको अपने डिज़ाइन की कल्पना करने की आवश्यकता है, तो एक विनिर्देश दस्तावेज लिखें। यदि आप इसका वर्णन कर सकते हैं, तो आप गेम लॉजिक से ग्राफ़िकल इंटरफ़ेस कोड को अलग करना शुरू कर सकते हैं।

— रामहुंड

यह ग्रिड कोड को परीक्षण करना भी आसान बनाता है। GUI का परीक्षण करना दर्दनाक है (वातावरण से संभावित भ्रामक मुद्दों के कारण) इसलिए ऐसा हो रहा है कि GUI एक पतली "स्पष्ट रूप से सही" परत है जो परीक्षण करने योग्य है, एक बहुत बड़ी जीत है। (फिर से, यह सेपरेशन ऑफ कंसर्न है।)

— डोनल फैलो

@ जॉन: हममें से कुछ लोग सबसे अच्छा करके सीखते हैं। यह मानते हुए कि यह परियोजना इतनी बड़ी नहीं है, इसे एकल वर्ग के रूप में लिखने का प्रयास करें और इसे आईफोन पर काम करें। अब अपने "दर्द बिंदुओं" पर नज़र रखते हुए, इसे एंड्रॉइड पर पोर्ट करें । अंत में, इसे र सी सी के रूप में सुझाया गया। मुझे लगता है कि आप देखेंगे कि तर्क और प्रस्तुति को अलग करने का तरीका क्या है।

— पीटर रोवेल

Answer 2

अपने कोड को बदलना आसान बनाने के लिए । क्या होगा अगर कल आप एक ग्रिड का उपयोग नहीं करना चाहते लेकिन एक सूची? जब आपका GUI आपके तर्क से अलग हो जाता है तो यह करना आसान होता है।

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

यह आपको कोड भी देता है जो पढ़ने में आसान है। यदि आपका ग्रिड केवल GUI कार्यक्षमता करता है तो आपके कोड को समझना या बदलना आसान है ।

Answer 3

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग का सामान्य दृष्टिकोण चिंताओं को अलग करने के लिए है , जहां कोड को तार्किक कार्यों में अलग किया जाता है। शुरू में, यह अधिक काम की तरह लग सकता है। लेकिन जैसे-जैसे आपकी परियोजना बढ़ती है, आपके कोड को ट्रैक करना और प्रबंधित करना आसान हो जाता है।

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

Answer 4

जब एक आवेदन संरचना में चिंता का पृथक्करण लागू होता है, तो परिणाम बहु स्तरीय वास्तुकला (या एन-टीयर वास्तुकला) http://en.wikipedia.org/wiki/Multitier_altecture है ।

Answer 5

अन्य उत्तरों पर निर्माण करने और आपको एक उदाहरण देने के लिए आपको किसी तरह अपने तर्क / डेटा को अपने ग्रिड या वाइका वर्सा में इंजेक्ट करने की अनुमति देनी चाहिए।

आपका ग्रिड नियंत्रण या तो एक Renderविधि या एक DataBindविधि को उजागर कर सकता है ।

class GridControl
{
    public Render(GridData data) { ... }
}

या

class GridControl
{
    public DataBind(GridData data) { ... }
}

फिर आपकी तार्किक इकाई या तो ग्रिडकंट्रोल ले सकती है और एक डेटा ऑब्जेक्ट को उसमें बाँध सकती है या मैन्युअल रूप से डेटा ऑब्जेक्ट के साथ रेंडर कर सकती है जिसमें कुछ भी बदलाव नहीं हो सकते हैं।

आपके GridLogic में GridControl का भी संदर्भ होना चाहिए ताकि यह होने वाले किसी भी इनपुट / ईवेंट के लिए बाध्य हो सके।

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

किसी भी तरह से अपने तर्क और ग्रिड को विभाजित करना इस तरह से आपको कुछ भी तोड़ने के बिना एक दूसरे को आसानी से बदलने की अनुमति देता है। आप ListControlअपने सभी तर्कों को फिर से लिखे बिना ग्रिड के बजाय एक सूची के रूप में अपने डेटा को दिखाने के लिए एक नया नियंत्रण भी लिख सकते हैं ।

Answer 6

मैं दृढ़ता से अनुशंसा करता हूं कि आप एमवीसी वास्तुकला पर एक नज़र डालें ।

यह आपके द्वारा उल्लिखित अवधारणा (प्रोग्राम कोड और ग्राफिक इंटरफ़ेस का अलग होना) का परिशोधन है। MVC का अर्थ है मॉडल-व्यू-कंट्रोलर। यहां मॉडल डेटा है, व्यू ग्राफिक इंटरफ़ेस कोड है और कॉन्ट्रोलर वह कोड है जो डेटा को प्रोसेस करता है।

इस तरह आपने अपने प्रोग्राम के तीन भाग बना लिए हैं। प्रत्येक भाग को अन्य दो भागों में परिवर्तन की आवश्यकता के बिना बदला जा सकता है।

Answer 7

यह भविष्य में होने वाले परिवर्तनों के प्रकार पर निर्भर करता है। आप जो कम से कम करना चाहते हैं, वह है प्रत्येक एकल कार्यात्मक परिवर्तन को सही ढंग से लागू करने के लिए आवश्यक मैन्युअल कोड परिवर्तनों की संख्या।

जहां एमवीसी जीतता है यदि परिवर्तन वी भाग तक सीमित हैं, या "देखें"।

मेरे अनुभव में, यह बहुत अधिक संभावना है कि परिवर्तन सभी तीन भागों को प्रभावित करते हैं, इसलिए बेहतर है कि वे अलग न हों । यह दिखाने के लिए कि मेरा क्या मतलब है, मैंने लंबे समय से एक ऐसी तकनीक का उपयोग किया है जिसे मैंने डायनामिक डायलॉग्स नाम से विकसित किया है , जिसमें एक नई आवश्यकता, जैसे "उपयोगकर्ता को नाम संपादित करने की अनुमति, और जब पूरा XYZ करते हैं" स्रोत कोड में एक एकल ब्लॉक के रूप में दर्ज किया जाता है पाठ:

if(deTextEdit(&sName)){
  // do XYZ
}

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

यदि आप उस लिंक पर जाते हैं तो आपको एक अधिक जटिल उदाहरण दिखाई देगा।

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

यह स्वतंत्र नहीं है। यह प्रोग्रामर के लिए एक बार सीखने की अवस्था का परिचय देता है।

Answer 8

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