डायनेमिकडाटा: बदलते संग्रह, एमवीवीएम डिजाइन पैटर्न, और प्रतिक्रियाशील एक्सटेंशन

फरवरी 2019 में, ReactiveUI 9 , Microsoft .NET प्लेटफॉर्म पर GUI अनुप्रयोगों के निर्माण के लिए एक क्रॉस-प्लेटफॉर्म फ्रेमवर्क जारी किया गया था। ReactiveUI MVVM डिज़ाइन पैटर्न के साथ प्रतिक्रियात्मक विस्तार को कसने के लिए एक उपकरण है। फ्रेमवर्क के साथ परिचित होने की शुरुआत हैबे पर लेखों की एक श्रृंखला के साथ या प्रलेखन के पहले पृष्ठ से की जा सकती है । ReactiveUI 9 अपडेट में कई फ़िक्सेस और सुधार शामिल हैं , लेकिन शायद सबसे दिलचस्प और महत्वपूर्ण बदलाव डायनेमिकडाटा फ्रेमवर्क के साथ तंग एकीकरण है , जो प्रतिक्रियाशील शैली में बदलते संग्रह के साथ काम करने की अनुमति देता है। आइए यह पता लगाने की कोशिश करें कि डायनेमिकडाटा किन मामलों में काम आ सकता है और कैसे इस शक्तिशाली प्रतिक्रियाशील ढांचे को अंदर व्यवस्थित किया जाता है!

आवश्यक शर्तें

सबसे पहले, हम उन कार्यों की श्रेणी को परिभाषित करते हैं जो डायनामेटाटा हल करता है और यह पता लगाता है कि System.Collections.ObjectModel से डेटा सेट बदलने के साथ काम करने के लिए मानक उपकरण क्यों हैं।

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



INotifyPropertyChanged और ICommand का कार्यान्वयन आमतौर पर डेवलपर और MVVM फ्रेमवर्क के विवेक पर रहता है, लेकिन ObservableCollection का उपयोग हम पर कई प्रतिबंध लगाता है! उदाहरण के लिए, हम Dispatcher.Invoke या इसी तरह की कॉल के बिना बैकग्राउंड थ्रेड से एक संग्रह नहीं बदल सकते हैं, और डेटा सरणियों के साथ काम करने के मामले में यह उपयोगी हो सकता है कि कुछ पृष्ठभूमि ऑपरेशन सर्वर के साथ सिंक्रनाइज़ होते हैं। यह ध्यान दिया जाना चाहिए कि मुहावरेदार MVVM में, मॉडल लेयर का उपयोग किए गए GUI एप्लिकेशन की वास्तुकला के बारे में जानने की आवश्यकता नहीं है, और MVC या MVP से मॉडल के साथ संगत होना चाहिए, और यही कारण है कि कई Dispatcher.Invoke बैकग्राउंड थ्रेड से उपयोगकर्ता इंटरफ़ेस नियंत्रण तक पहुंचने की अनुमति देते हैं। एक डोमेन सेवा में, आवेदन परतों के बीच जिम्मेदारी साझा करने के सिद्धांत का उल्लंघन करते हैं।

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

प्रतिक्रियाशील विस्तार। डेटा स्ट्रीम प्रबंधित करें

डायनेमिकडाटा द्वारा पेश किए गए अमूर्तताओं और बदलते प्रतिक्रियाशील डेटासेट के साथ काम करने के सिद्धांतों की पूरी समझ के लिए, आइए याद करते हैं कि Microsoft .NET प्लेटफ़ॉर्म और MVVM डिज़ाइन पैटर्न के संदर्भ में प्रतिक्रियाशील प्रोग्रामिंग क्या है और इसे कैसे लागू किया जाए । कार्यक्रम के घटकों के बीच बातचीत को व्यवस्थित करने का एक तरीका इंटरैक्टिव और प्रतिक्रियाशील हो सकता है। इंटरएक्टिव बातचीत में, उपभोक्ता फ़ंक्शन सिंक्रोनाइज़ेशन फ़ंक्शन (पुल-आधारित अप्रोच, T , IEnumerable ) से डेटा प्राप्त करता है, और प्रतिक्रियाशील इंटरैक्शन में, उपभोक्ता फ़ंक्शन एसिंक्रोनसली उपभोक्ता फ़ंक्शन (पुश-आधारित दृष्टिकोण, Task , IObservable ) को डेटा डिलीवर करता है।



प्रतिक्रियाशील प्रोग्रामिंग अतुल्यकालिक डेटा धाराओं का उपयोग करके प्रोग्रामिंग कर रहा है, और प्रतिक्रियाशील एक्सटेंशन इसके कार्यान्वयन का एक विशेष मामला है, जो सिस्टम नेमस्पेस से IObservable और IObserver पर आधारित है, जो IObservable इंटरफ़ेस पर कई IObservable जैसे ऑपरेशन्स को परिभाषित करता है, जिन्हें LINQ ओवर IObservable कहा जाता है। प्रतिक्रियाशील एक्सटेंशन .NET मानक का समर्थन करते हैं और जहां भी Microsoft .NET प्लेटफ़ॉर्म काम करता है, वहां काम करता है।



ReactiveUI फ्रेमवर्क, एप्लीकेशन डेवलपर्स को ReactiveCommand<TIn, TOut> और WhenAnyValue के प्रतिक्रियाशील कार्यान्वयन का लाभ उठाने के लिए आमंत्रित करता है, जो ReactiveCommand<TIn, TOut> और WhenAnyValue जैसे शक्तिशाली उपकरण प्रदान करता है। WhenAnyValue एक वर्ग की संपत्ति को बदलने की अनुमति देता है जो IObservable<T> प्रकार की घटना स्ट्रीम में IObservable<T> , जो आश्रित गुणों के कार्यान्वयन को सरल करता है।

 public class ExampleViewModel : ReactiveObject { [Reactive] //  ReactiveUI.Fody,  // -  // OnPropertyChanged   Name. public string Name { get; set; } public ExampleViewModel() { //  OnPropertyChanged("Name"). this.WhenAnyValue(x => x.Name) //   IObservable<string> .Subscribe(Console.WriteLine); } } 

ReactiveCommand<TIn, TOut> आपको कमांड के साथ काम करने की अनुमति देता है, प्रकार IObservable<TOut> की एक घटना के साथ, जो जब भी कमांड पूरा होता है, तब इसे प्रकाशित किया जाता है। इसके अलावा, किसी भी कमांड में IObservable<Exception> प्रकार की ThrownExceptions संपत्ति है।

 // ReactiveCommand<Unit, int> var command = ReactiveCommand.Create(() => 42); command //   IObservable<int> .Subscribe(Console.WriteLine); command .ThrownExceptions //   IObservable<Exception> .Select(exception => exception.Message) //   IObservable<string> .Subscribe(Console.WriteLine); command.Execute().Subscribe(); // : 42 

यह सब समय हमने IObservable<T> साथ काम किया, एक घटना के रूप में जो टाइप T का एक नया मान प्रकाशित करता है जब भी वस्तु की स्थिति में बदलाव होता है। सीधे शब्दों में कहें, IObservable<T> घटनाओं की एक धारा है, एक अनुक्रम समय के साथ बढ़ा।

बेशक, हम संग्रह के साथ आसानी से और स्वाभाविक रूप से काम कर सकते हैं - जब भी कोई संग्रह बदलता है, तो बदले हुए तत्वों के साथ एक नया संग्रह प्रकाशित करें। इस स्थिति में, प्रकाशित मान IEnumerable<T> या अधिक विशिष्ट प्रकार का होगा, और घटना स्वयं IObservable<IEnumerable<T>> प्रकार की IObservable<IEnumerable<T>> । लेकिन, जैसा कि गंभीर रूप से सोचने वाले पाठक सही ढंग से बताते हैं, यह अनुप्रयोग प्रदर्शन के साथ गंभीर समस्याओं से भरा है, खासकर अगर हमारे संग्रह में एक दर्जन तत्व नहीं हैं, लेकिन एक सौ, या कई हजार भी हैं!

डायनामैटडाटा का परिचय

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



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

क्लासिक IObservable<T> बजाय, IObservable<IChangeSet<T>>> और IObservable<IChangeSet<TValue, TKey>> IObservable<IChangeSet<T>>> पर संचालन को परिभाषित करता है, जहां IChangeSet संग्रह परिवर्तन के बारे में जानकारी वाला एक हिस्सा है - परिवर्तन का प्रकार और प्रभावित होने वाले तत्व। यह दृष्टिकोण प्रतिक्रियात्मक शैली में लिखे गए संग्रह के साथ काम करने के लिए कोड के प्रदर्शन में काफी सुधार कर सकता है। एक ही समय में, IObservable<IChangeSet<T>> को हमेशा एक नियमित IObservable<IEnumerable<T>> में तब्दील किया जा सकता है, अगर एक बार में संग्रह के सभी तत्वों को संसाधित करना आवश्यक हो जाता है। यदि यह जटिल लगता है - चिंता मत करो, कोड उदाहरणों से सब कुछ स्पष्ट और पारदर्शी हो जाएगा!

डायनामाडाटा उदाहरण

आइए बेहतर तरीके से यह समझने के लिए उदाहरणों की एक श्रृंखला देखें कि डायनामाडाटा कैसे काम करता है, यह System.Reactive से कैसे भिन्न होता है System.Reactive और GUI के साथ एप्लिकेशन सॉफ़्टवेयर के सामान्य डेवलपर्स क्या कार्य कर सकते हैं। चलिए GitHub पर DynamicData द्वारा पोस्ट किए गए एक व्यापक उदाहरण से शुरू करते हैं। उदाहरण में, डेटा स्रोत SourceCache<Trade, long> , जिसमें लेनदेन का संग्रह होता है। कार्य केवल सक्रिय लेनदेन दिखाना है, मॉडल को प्रॉक्सी ऑब्जेक्ट में बदलना, संग्रह को सॉर्ट करना है।

 //    System.Collections.ObjectModel, //       . ReadOnlyObservableCollection<TradeProxy> list; //   ,   . //   Add, Remove, Insert   . var source = new SourceCache<Trade, long>(trade => trade.Id); var cancellation = source //      . //   IObservable<IChangeSet<Trade, long>> .Connect() //       . .Filter(trade => trade.Status == TradeStatus.Live) //    -. //   IObservable<IChangeSet<TrandeProxy, long>> .Transform(trade => new TradeProxy(trade)) //    . .Sort(SortExpressionComparer<TradeProxy> .Descending(trade => trade.Timestamp)) //  GUI    . .ObserveOnDispatcher() //    - //    System.Collections.ObjectModel. .Bind(out list) // ,       //    . .DisposeMany() .Subscribe(); 

ऊपर दिए गए उदाहरण में, जब आप SourceCache को SourceCache , जो डेटा स्रोत है, तो ReadOnlyObservableCollection भी उसी के अनुसार बदल ReadOnlyObservableCollection । इस स्थिति में, संग्रह से तत्वों को हटाते समय, Dispose विधि को बुलाया जाएगा, संग्रह को हमेशा केवल GUI स्ट्रीम में अपडेट किया जाएगा और छांटा और फ़िल्टर किया जाएगा। कूल, नो Dispatcher.Invoke और क्लिष्ट कोड!

SourceList और SourceCache डेटा स्रोत

डायनेमिकडाटा दो विशेष संग्रह प्रदान करता है जिनका उपयोग एक परिवर्तनशील डेटा स्रोत के रूप में किया जा सकता है। ये संग्रह SourceList और SourceCache<TObject, TKey> । जब भी SourceCache पास एक अद्वितीय कुंजी हो, तो SourceCache का उपयोग करने की अनुशंसा की जाती है, अन्यथा SourceList उपयोग करें ये ऑब्जेक्ट डेटा को संशोधित करने के लिए परिचित .NET डेवलपर्स एपीआई प्रदान करते हैं - Add , Remove , Insert और जैसे। डेटा स्रोतों को IObservable<IChangeSet<T>> या IObservable<IChangeSet<T, TKey>> में .Connect() करने के लिए .Connect() ऑपरेटर का उपयोग करें। उदाहरण के लिए, यदि आपके पास एक ऐसी सेवा है जो पृष्ठभूमि में तत्वों के संग्रह को अपडेट करती है, तो आप Dispatcher.Invoke बिना इन तत्वों की सूची को आसानी से GUI के साथ सिंक्रनाइज़ कर सकते हैं।

 public class BackgroundService : IBackgroundService { //    . private readonly SourceList<Trade> _trades; //     . //  ,     , //    Publish()  Rx. public IObservable<IChangeSet<Trade>> Connect() => _trades.Connect(); public BackgroundService() { _trades = new SourceList<Trade>(); _trades.Add(new Trade()); //    ! //    . } } 

डायनेमिकडाटा बाहरी दुनिया में डेटा मैप करने के लिए अंतर्निहित .NET प्रकारों का उपयोग करता है। शक्तिशाली IObservable<IChangeSet<Trade>> ऑपरेटरों का उपयोग करके, हम अपने दृश्य मॉडल के IObservable<IChangeSet<Trade>> ReadOnlyObservableCollection में बदल सकते हैं।

 public class TradesViewModel : ReactiveObject { private readonly ReadOnlyObservableCollection<TradeVm> _trades; public ReadOnlyObservableCollection<TradeVm> Trades => _trades; public TradesViewModel(IBackgroundService background) { //   ,  ,  //     System.Collections.ObjectModel. background.Connect() .Transform(x => new TradeVm(x)) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _trades) .DisposeMany() .Subscribe(); } } 

Transform , Filter और Sort , डायनेमिकडाटा में अन्य ऑपरेटरों का एक समूह शामिल है, समूहन, तार्किक संचालन का समर्थन करता है, एक संग्रह को चौरसाई करता है, एकत्रीकरण कार्यों का उपयोग करते हुए, समान तत्वों को छोड़कर, तत्वों की गिनती, और यहां तक ​​कि प्रतिनिधित्व के मॉडल के वर्चुअलाइजेशन भी शामिल है। GitHub पर README परियोजना के सभी ऑपरेटरों के बारे में और पढ़ें।

एकल थ्रेडेड संग्रह और परिवर्तन ट्रैकिंग

SourceList और SourceCache अलावा, SourceCache लाइब्रेरी में एक उत्परिवर्तित संग्रह का एकल-थ्रेडेड कार्यान्वयन भी शामिल है - ObservableCollectionExtended । अपने दृश्य मॉडल में दो संग्रहों को सिंक्रनाइज़ करने के लिए, एक को ToObservableChangeSet रूप में घोषित करें और दूसरे को ReadOnlyObservableCollection रूप में घोषित करें और ToObservableChangeSet ऑपरेटर का उपयोग करें, जो Connect के समान व्यवहार करता है, लेकिन ToObservableChangeSet साथ काम करने के लिए डिज़ाइन किया गया है।

 //   . ReadOnlyObservableCollection<TradeVm> _derived; //    -. var source = new ObservableCollectionExtended<Trade>(); source.ToObservableChangeSet(trade => trade.Key) .Transform(trade => new TradeProxy(trade)) .Filter(proxy => proxy.IsChecked) .Bind(out _derived) .Subscribe(); 

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

 //  IObservable<bool> var isValid = databases .ToObservableChangeSet() //      IsValid. .AutoRefresh(database => database.IsValid) //       . .ToCollection() // ,    . .Select(x => x.All(y => y.IsValid)); //   ReactiveUI, IObservable<bool> //     ObservableAsProperty. _isValid = isValid .ObserveOn(RxApp.MainThreadScheduler) .ToProperty(this, x => x.IsValid); 

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

निष्कर्ष

प्रतिक्रियाशील एक्सटेंशन एक शक्तिशाली उपकरण है जो आपको डेटा और उपयोगकर्ता इंटरफ़ेस के साथ घोषणात्मक रूप से काम करने की अनुमति देता है, पोर्टेबल और समर्थित कोड लिखता है, और सरल और सुरुचिपूर्ण तरीके से जटिल समस्याओं को हल करता है। ReactiveUI .NET डेवलपर्स को INotifyCollectionChanged प्रतिक्रियाशील कार्यान्वयन प्रदान करके MVVM वास्तुकला का उपयोग करके अपनी परियोजनाओं में प्रतिक्रियात्मक एक्सटेंशन को बारीकी से एकीकृत करने की अनुमति देता है, जबकि INotifyCollectionChanged को लागू करके संग्रह सिंक्रनाइज़ेशन का ध्यान INotifyCollectionChanged , प्रतिक्रियाशील एक्सटेंशन की क्षमताओं का विस्तार करता है और प्रदर्शन की देखभाल करता है।

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