संग्रह के साथ दृश्य सिंक्रनाइज़ करना

कई आधुनिक प्रोग्रामिंग भाषाओं और रूपरेखाओं में विशेष संग्रह कक्षाएं हैं जो ग्राहकों को उनके द्वारा किए जाने वाले हर बदलाव के साथ सूचित कर सकती हैं। फ्लेक्स में, इस वर्ग को ArrayCollection, in .Net - ObsJableCollection, ExtJS में - Ext.util.MixedCollection और Ext.data.Store, jWidget - JW.Collection में कहा जाता है । एमवीसी योजना (मॉडल, व्यू, कंट्रोलर) का उपयोग करते हुए एप्लिकेशन विकसित करते समय ऐसी डेटा संरचनाएं आवश्यक हैं। अधिकांश अक्सर उन्हें यूआई घटकों के विभिन्न प्रकारों के लिए एक मॉडल के रूप में उपयोग किया जाता है: सूची, टेबल, समझौते आदि। जटिल अनुप्रयोगों में, सिस्टम की कई परतों को एक दूसरे के साथ जोड़ने के लिए संग्रह की आवश्यकता होती है।

आज मैं आपको संग्रह के साथ काम करने के एक मूल तरीके के बारे में बताऊंगा।


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

आदर्श	विचार
संग्रह	सूची, तालिका
संग्रह की वस्तु	सूची पंक्ति, तालिका

संग्रह में एक आइटम जोड़ा गया - आपको सूची में तुरंत एक पंक्ति जोड़ने की आवश्यकता है। संग्रह से आइटम को हटा दिया गया - आपको सूची से संबंधित पंक्ति को तुरंत हटा देना चाहिए। और इसी तरह।

संग्रह कैसे काम करते हैं? आमतौर पर, एक प्रोग्रामर को तुच्छ घटनाओं की एक श्रृंखला की सदस्यता का अवसर दिया जाता है:

• जोड़ा (सम्मिलित तत्व)
• हटाया (आइटम हटाया गया)
• प्रतिस्थापित (निर्दिष्ट सेल में आइटम को प्रतिस्थापित)
• स्थानांतरित (किसी आइटम को एक स्थान से दूसरे स्थान पर ले जाना)
• साफ़ किया गया (सभी आइटम हटा दिया गया)

प्रदर्शन के नुकसान से बचने के लिए और अधिक उन्नत कार्यान्वयन, घटनाओं को भी शामिल करते हैं:

• पुन: क्रमबद्ध (सॉर्ट किए गए आइटम)
• फ़िल्टर्ड (फ़िल्टर्ड आइटम)
• रीसेट किया गया (संग्रह को मनमाने ढंग से बदल दिया गया)

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

---

एक साधारण उदाहरण पर विचार करें। मान लीजिए कि हम LiveJournal का एक AJAX संस्करण बनाते हैं, अर्थात्, एक ब्लॉग है जहाँ एक पृष्ठ प्रकाशित करना, उसे संपादित करना, टिप्पणी करना आदि, पृष्ठ को फिर से लोड किए बिना होता है। संग्रह की एक मिसाल के रूप में लेखों की सूची लें। प्रकाशन तिथि द्वारा लेखों को स्पष्ट रूप से आदेश दिया गया है, अर्थात, प्रत्येक की अपनी सूची है - सामान्य सूची में एक स्थान। सबसे पुराने लेख में 0 का सूचकांक है, सबसे हाल ही में एन 1 है, जहां एन लेखों की संख्या है। यह ध्यान दिया जाना चाहिए कि हर लेख में कई प्रतिनिधित्व हैं:

1. ब्लॉग के मुख्य भाग में लेख का सारांश
   
2. इस पृष्ठ पर सूची (साइडबार)
   
3. लेख टैग की सूची के प्रदर्शन को प्रभावित करता है।
   
4. लेख कैलेंडर प्रदर्शन को प्रभावित करता है
   

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

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

जब लेखक लेख को बदलता है, तो उसे संग्रह के अंत में फेंक दिया जाता है, जिसके परिणामस्वरूप "स्थानांतरित" घटना को फेंक दिया जाता है, और विचारों को एक तरह से या किसी अन्य तरीके से फिर से अपडेट किया जाता है।

अच्छी तरह से और इतने पर ...

---

सामान्य तौर पर, संग्रह बदल रहा है और इसके बारे में सभी को सूचित करता है, और ब्लॉग वेब पेज पर परिवर्तनों की जिम्मेदारी प्रस्तुति कक्षाओं के साथ है। यही एमवीसी योजना हमें तय करती है।

नोट: कभी-कभी एक "अपडेट" घटना भी होती है - उन्होंने एक तत्व को बदल दिया (वे पूरी तरह से उन्हें प्रतिस्थापित नहीं करते हैं, उन्होंने बस एक मौजूदा तत्व की कुछ संपत्ति को बदल दिया है), लेकिन मुझे लगता है कि इस घटना को संग्रह द्वारा नहीं सुना जाना चाहिए, लेकिन तत्वों द्वारा स्वयं; इस घटना के स्वचालन से प्रदर्शन में बड़ा नुकसान होता है।

अगला, हम पहले पांच घटनाओं पर ध्यान केंद्रित करेंगे, जैसा कि सबसे अधिक इस्तेमाल किया जाता है: जोड़ा, हटाया, प्रतिस्थापित किया गया, स्थानांतरित किया गया, साफ़ किया गया।

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

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

तो एक नया पैटर्न पैदा हुआ। इसे "संग्रह दृश्य सुविधा" कहना सही होगा, लेकिन किसी कारण से मुझे "सिंटचर" पसंद है।

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

अर्थ विज्ञान	विवरण	उदाहरण
निर्माता (डेटा): देखें	प्रस्तुति तत्व बनाएँ	तालिका पंक्ति बनाएँ
आवेषण (देखें, सूचकांक)	निर्दिष्ट स्थान पर एक मौजूदा दृश्य आइटम डालें	तालिका में पंक्ति डालें
पदच्युत (सूचकांक): देखें	निर्दिष्ट स्थान से दृश्य आइटम निकालें	तालिका से पंक्ति हटाएं
विध्वंसक (देखें)	दृश्य आइटम को नष्ट करें	एक तालिका पंक्ति को नष्ट करें
क्लीयर (): व्यू का एरियर	संग्रह से सभी आइटम निकालें और उन्हें वापस करें।	सभी तालिका पंक्तियों को हटा दें और उन्हें वापस करें

जाहिर है, ये एल्गोरिदम बहुत सरल हैं और एक दूसरे से पूरी तरह से स्वतंत्र हैं (सिवाय, शायद, बाद वाले - लेकिन यह अनुकूलन के लिए आवश्यक है)। उन्हें महसूस करना मुश्किल नहीं है। लेकिन वे प्रदर्शन के किसी भी नुकसान के बिना, एक निश्चित संग्रह के साथ सिंक्रनाइज़ करने के लिए पर्याप्त हैं। देखिए कि मानक संग्रह की घटनाओं का सरल और कुशल संचालन अब कैसा है:

• जोड़ा (सूचकांक, डेटा)
  
  1. देखें = निर्माता (डेटा)
  2. आवेषण (दृश्य, सूचकांक)
  
  
• हटाया (सूचकांक, डेटा)
  
  1. दृश्य = पदच्युत (सूचकांक)
  2. विध्वंसक (देखें)
  
  
• प्रतिस्थापित (सूचकांक, पुराना, नयाडाटा)
  
  1. oldView = रिमूवर (सूचकांक)
  2. विध्वंसक (पुराना दृश्य)
  3. newView = निर्माता (newData)
  4. सम्मिलित (newView, अनुक्रमणिका)
  
  
• चले गए (fromIndex, toIndex)
  
  1. दृश्य = रिमूवर (fromIndex)
  2. आवेषण (देखें, इंडेक्स)
  
  
• साफ़ किया हुआ ()
  
  1. विचार = स्पष्ट ()
  2. foreach (विचारों में देखें) विध्वंसक (दृश्य)
  
  

और अब हम एक सहायक वर्ग और आनन्द में यह सब मिलाते हैं! यहाँ JW.Collection: JW.Syncher के लिए इस बात का कार्यान्वयन है। और यहाँ एक परीक्षण है जिसे एक उदाहरण के रूप में माना जा सकता है: JW.Tests.Util.SyncherTestCase ।

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