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

परिचय

आइए पहले डायनामैडेटा के लिए उपयोग के मामलों को निर्धारित करें और पता करें कि हमें System.Collections.ObjectModel नाम स्थान से डायनेमिक डेटासेट के साथ काम करने के लिए डिफ़ॉल्ट टूल के बारे में क्या पसंद नहीं है।

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

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

बेशक, हम एक डोमेन सेवा में एक घटना की घोषणा कर सकते हैं, और घटना तर्क के रूप में परिवर्तित आइटम के साथ एक हिस्सा संचारित कर सकते हैं, फिर घटना के लिए सदस्यता लें, Dispatcher.Invoke को Dispatcher.Invoke करें। इंटरफ़ेस के पीछे कॉल करें, ताकि हमारा ऐप किसी भी GUI पर निर्भर न हो। फ्रेमवर्क, उस मॉडल को व्यू मॉडल से कॉल करें और उसके अनुसार ObservableCollection<T> संशोधित करें, लेकिन पहिया को फिर से स्थापित करने की आवश्यकता के बिना इस तरह के मुद्दों से निपटने का एक बहुत अधिक सुरुचिपूर्ण तरीका है। फिर हम किस चीज का इंतजार कर रहे हैं?

प्रतिक्रियात्मक विस्तार। अवलोकन डेटा धाराओं का प्रबंधन करना

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

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

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

 public class ExampleViewModel : ReactiveObject { [Reactive] // Attribute from the ReactiveUI.Fody package, // takes care of aspect-oriented INPC implementation // for this particular property. public string Name { get; set; } public ExampleViewModel() { // Here we subscribe to OnPropertyChanged("Name") events. 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(); // Outputs: 42 

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

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

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

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

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

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

कार्रवाई में गतिशील डेटा

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

 // The default collection from the System.Collections.ObjectModel // namespace, to which we bind XAML UI controls. ReadOnlyObservableCollection<TradeProxy> list; // The mutable data source, containing the list of transactions. // We can use Add, Remove, Insert and similar methods on it. var source = new SourceCache<Trade, long>(trade => trade.Id); var cancellation = source // Here we transform the data source to an observable change set. .Connect() // Now we have IObservable<IChangeSet<Trade, long>> here. // Filter only active transactions. .Filter(trade => trade.Status == TradeStatus.Live) // Transform the models into proxy objects. .Transform(trade => new TradeProxy(trade)) // No we have IObservable<IChangeSet<TrandeProxy, long>> // Order the trade proxies by timestamp. .Sort(SortExpressionComparer<TradeProxy> .Descending(trade => trade.Timestamp)) // Use the dispatcher scheduler to update the GUI. .ObserveOnDispatcher() // Bind the sorted objects to the collection from the // System.Collections.ObjectModel namespace. .Bind(out list) // Ensure that when deleting elements from the // collections, the resources will get disposed. .DisposeMany() .Subscribe(); 

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

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

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

 public class BackgroundService : IBackgroundService { // Declare the mutable data source containing trades. private readonly SourceList<Trade> _trades; // Expose the observable change set to the outside world. // If we have more than one subscriber, it is recommended // to use the Publish() operator from reactive extensions. public IObservable<IChangeSet<Trade>> Connect() => _trades.Connect(); public BackgroundService() { _trades = new SourceList<Trade>(); _trades.Add(new Trade()); // Mutate the source list! // Even from the background thread. } } 

शक्तिशाली IObservable<IChangeSet<Trade>> ऑपरेटरों की मदद से, हम अपने दृश्य मॉडल में घोषित IObservable<IChangeSet<Trade>> बदल सकते हैं।

 public class TradesViewModel : ReactiveObject { private readonly ReadOnlyObservableCollection<TradeVm> _trades; public ReadOnlyObservableCollection<TradeVm> Trades => _trades; public TradesViewModel(IBackgroundService background) { // Connect to the data source, transform elements, bind // them to the read-only observable collection. background.Connect() .Transform(x => new TradeVm(x)) .ObserveOn(RxApp.MainThreadScheduler) .Bind(out _trades) .DisposeMany() .Subscribe(); } } 

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

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

 // Declare the derived collection. ReadOnlyObservableCollection<TradeVm> _derived; // Declare and initialize the source collection. 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 ऑपरेटर का उपयोग करें और आवश्यक संपत्ति चयनकर्ता में पास करें। AutoRefresh और अन्य AutoRefresh ऑपरेटर आपको स्क्रीन पर प्रदर्शित रूप और नेस्टेड रूपों की एक बड़ी संख्या को अनायास सत्यापित करने की अनुमति दे सकते हैं!

 // IObservable<bool> var isValid = databases .ToObservableChangeSet() // Subscribe only to IsValid property changes. .AutoRefresh(database => database.IsValid) // Materialize the collection. .ToCollection() // Determine if all forms are valid. .Select(x => x.All(y => y.IsValid)); // If ReactiveUI is used, you can transform the // IObservable<bool> variable to a property declared // as ObservableAsPropertyHelper<bool>, eg IsValid. _isValid = isValid .ObserveOn(RxApp.MainThreadScheduler) .ToProperty(this, x => x.IsValid); 

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

निष्कर्ष

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

ReactiveUI और DynamicData लाइब्रेरी .NET प्लेटफॉर्म पर सभी GUI फ्रेमवर्क के साथ पूरी तरह से संगत हैं, जिसमें Windows Presentation Foundation, Universal Windows Platform, Avalonia , Xamarin.Android, Xamarin Forms और Xamarin iOS शामिल हैं। आप ReactiveUI प्रलेखन के संबंधित पृष्ठ पर डायनामैडाटा का अध्ययन शुरू कर सकते हैं। डायनेमाडाटा स्निपेट्स परियोजना के साथ अपने आप को परिचित करने का भी ध्यान रखें, जिसमें आपकी जरूरत की लगभग सभी चीजों के लिए कोड नमूने हों।