WPF / सिल्वरलाइट में नॉन-विजुअल ऑब्जेक्ट्स के लिए एक DataContext सेट करना

WPF के लिए DXScheduler को विकसित करते समय, हमें उपयोगकर्ता से एक स्क्रिप्ट मिली जिसमें MVVM टेम्पलेट का उपयोग किया गया था।
उपयोगकर्ता-परिभाषित ऑब्जेक्ट को हमारे अनुसूचक के DataContext संपत्ति को सौंपा गया था, और XAML मार्कअप में, ऑब्जेक्ट के संबंधित गुणों के लिए "बाइंडिंग" को बाइंडिंग अभिव्यक्तियों का उपयोग करके किया गया था।
लेकिन एक समस्या थी - शेड्यूलर में एक गैर-दृश्य संग्रहण ऑब्जेक्ट शामिल था जो डेटा के लिए सेटिंग्स का एक संग्रह संग्रहीत करता था। जिस रूप में बाइंडिंग अभिव्यक्ति लिखी गई थी, उस रूप में स्टोर ऑब्जेक्ट के गुणों को अपडेट नहीं किया गया था।

आप इस बारे में अधिक जानेंगे कि इस समस्या को कैसे हल किया गया ...

लेख एक सरलीकृत समाधान प्रदान करता है जो ऊपर वर्णित परिदृश्य को प्रदर्शित करता है। इसलिए, मैं MVVM टेम्पलेट के पूर्ण कार्यान्वयन के साथ दिए गए कोड को जटिल नहीं करूंगा, INotifyPropertyChanged इंटरफेस को ढेर कर सकता हूं, आदि। हमारा काम उदाहरण को सरल बनाना है ताकि समस्या का सार प्रतिबिंबित हो सके।

तो, चलो दृश्य नियंत्रण से शुरू करते हैं, जो मॉडल का प्रतिनिधित्व होगा।

वर्ग देखें

दृश्य नियंत्रण जिसमें नेस्टेड डेटास्टोर के लिए संपत्ति होती है। इसे XAML में बनाया और सौंपा जाएगा।

public class SomeVisualControl : Control { public static readonly DependencyProperty InnerDataStoreProperty = DependencyProperty.Register("InnerDataStore", typeof(DataStore), typeof(SomeVisualControl), new PropertyMetadata(null)); public DataStore InnerDataStore { get { return (DataStore)GetValue(InnerDataStoreProperty); } set { SetValue(InnerDataStoreProperty, value); } } } 

क्लास डेटास्टर

एक गैर-दृश्य डेटा स्टोर XAML में बनाया गया था और SomeVisualControl में एक आंतरिक संपत्ति के रूप में निहित था।

DXScheduler में, एक समान आंतरिक ऑब्जेक्ट DependencyObject का वंशज था और परिभाषा के अनुसार, इसमें DataContext नहीं था। परिणामस्वरूप, इस ऑब्जेक्ट के गुणों पर बाइंडिंग अभिव्यक्ति काम नहीं करती थी। इसलिए, पहली बात जो दिमाग में आती है, वह है इस ऑब्जेक्ट को डेटाकोटेक्स्ट वाले वर्ग से वारिस करना, और समस्या हल हो जाएगी।

ऐसा वर्ग फ्रेमवर्क है, और हम इसे आधार वर्ग के रूप में उपयोग करेंगे।

 public class DataStore : FrameworkElement { public static readonly DependencyProperty ConnectionStringProperty = DependencyProperty.Register("ConnectionString", typeof(string), typeof(DataStore), new PropertyMetadata(string.Empty)); public string ConnectionString { get { return (string)GetValue(ConnectionStringProperty); } set { SetValue(ConnectionStringProperty, value); } } } 

अब उपयोगकर्ता स्तर की वस्तुओं को परिभाषित करें।

मॉडल वर्ग

एक कस्टम ऑब्जेक्ट को परिभाषित करता है। ConnectionString गुण आंतरिक दृश्य नियंत्रण संग्रहण की संपत्ति के साथ "संबद्ध" होगा।

 public class DataStoreModel { public string ConnectionString { get; set; } public DataStoreModel(string connection) { ConnectionString = connection; } } 

मॉडलव्यू क्लास

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

 public class DataStoreViewModel { DataStoreModel dataStore; public DataStoreViewModel(DataStoreModel dataStore) { if (dataStore == null) throw new ArgumentNullException("dataStore"); this.dataStore = dataStore; } public string ModelConnectionString { get { return dataStore.ConnectionString; } } } 

प्राप्त वर्गों का एक चित्र नीचे दिखाया गया है:


तो, हम समस्या को हल करते हैं: मॉडल की संपत्ति के साथ एक आंतरिक गैर-दृश्य वस्तु की संपत्ति को जोड़ने के लिए ।

आइए आवेदन पर आगे बढ़ें और एक्सएएमएल मार्कअप में आवश्यक नियंत्रण बनाएं

< Window x:Class ="DataContextWpfSample.MainWindow"
xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x ="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local ="clr-namespace:DataContextWpfSample"
Loaded ="Window_Loaded"
Title ="MainWindow" Height ="350" Width ="525" >
< Grid >
< local:SomeVisualControl x:Name ="MyVisualControl" >
< local:SomeVisualControl.InnerDataStore >
< local:DataStore ConnectionString ="{Binding ModelConnectionString}" />
</ local:SomeVisualControl.InnerDataStore >

< local:SomeVisualControl.Template >
< ControlTemplate >
< StackPanel >
< TextBlock Text ="DataStore Connection:" FontWeight ="Bold" />
< TextBlock Text ="{Binding Path=InnerDataStore.ConnectionString, RelativeSource={RelativeSource Mode=TemplatedParent}}" TextWrapping ="Wrap" />
</ StackPanel >
</ ControlTemplate >
</ local:SomeVisualControl.Template >
</ local:SomeVisualControl >
</ Grid >
</ Window >

* This source code was highlighted with Source Code Highlighter .

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

विंडो क्लास फ़ाइल में मॉडल आरंभीकरण कोड निम्नानुसार है:

 public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void Window_Loaded(object sender, RoutedEventArgs e) { string connection = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\MyDB.mdb;Persist Security Info=True"; DataStoreModel sourceData = new DataStoreModel(connection); DataStoreViewModel sourceDataModel = new DataStoreViewModel(sourceData); this.MyVisualControl.DataContext = sourceDataModel; } 

हम विशेष रूप से अंतिम पंक्ति को ध्यान में रखते हैं - एक DataContext असाइन करना इस प्रकार आपको बाध्यकारी अभिव्यक्तियों का उपयोग करके मॉडल के गुणों के साथ नियंत्रण के गुणों को "लिंक" करने की अनुमति देगा।

हम एप्लिकेशन शुरू करते हैं, लेकिन अपेक्षित कनेक्शन स्ट्रिंग के बजाय, हम एक खाली देखते हैं।
हम SNOOP उपयोगिता का उपयोग करेंगे और सुनिश्चित करेंगे कि संग्रहण ऑब्जेक्ट का DataContext असाइन नहीं किया गया है:



यह इस तथ्य के कारण प्रतीत होता है कि:
DataStore ऑब्जेक्ट दृश्य ट्री में नहीं है, और इसलिए मूल संदर्भ इस पर सेट नहीं है ।

DataContext का उद्देश्य

इस प्रकार, हमें यह निर्धारित करने की आवश्यकता है कि कब DataContext दृश्य नियंत्रण में असाइन किया गया है, और इस मान को आंतरिक DataStore पर सेट करें।

FrameworkContentElement वर्ग में DataContextChanged ईवेंट होता है।
हम इसका उपयोग करेंगे और, एक सरल कोड लिखकर, हम सही परिणाम प्राप्त करेंगे।

 public class SomeVisualControl : Control { // ... public SomeVisualControl() { this.DataContextChanged += new DependencyPropertyChangedEventHandler(SomeVisualControl_DataContextChanged); } void SomeVisualControl_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e) { InnerDataStore.DataContext = e.NewValue; } } 

दुर्भाग्य से, वहाँ एक है ...
यदि आप WPF का उपयोग करते हैं, तो आप इस दृष्टिकोण का उपयोग कर सकते हैं। बात यह है कि सिल्वरलाइट के वर्तमान संस्करण में एक DataContextChanged इवेंट नहीं है।
और चूंकि हम डब्ल्यूपीएफ और एसएल नियंत्रण के लिए सामान्य कोड लिख रहे हैं, इसलिए एक सार्वभौमिक समाधान लिखना आवश्यक था।

तो जब आप दृश्य नियंत्रण के DataContext को बदलते हैं तो आप कैसे जानते हैं?

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

आगे देखते हुए, मैं कहता हूँ कि हम एक इंटरफ़ेस परिभाषित करेंगे जो रिपोर्ट करेगा कि DataContext संपत्ति बदल गई है और इसे नेस्टेड ऑब्जेक्ट को सौंपा जाना चाहिए।

 public interface IDataContextOwner { object DataContext { get; } void UpdateInnerDataContext(object dataContext); } 

हम DataContext और PropertyChangedCallback पद्धति पर बाइंडिंग से ऊपर वर्णित वर्ग को लागू करते हैं।
उसी समय, हम क्लास के निर्माता के पास जाएंगे जो IDataContextOwner इंटरफ़ेस को लागू करता है (हमारे मामले में यह SomeVisualControl होगा) और इंटरफ़ेस विधि को कॉल करें UpdateInnerDonContext को हमारे दृश्य नियंत्रण को बताने के लिए कि यह उसके आंतरिक भंडारण के संदर्भ को अपडेट करने का समय है।

 public class DataContextBinder : DependencyObject { IDataContextOwner owner; public DataContextBinder(IDataContextOwner owner) { if (owner == null) throw new ArgumentNullException("owner"); this.owner = owner; InitializeBinding(); } protected virtual void InitializeBinding() { Binding binding = new Binding("DataContext"); binding.Source = owner; binding.Mode = BindingMode.OneWay; BindingOperations.SetBinding(this, DataContextProperty, binding); } public object DataContext { get { return (object)GetValue(DataContextProperty); } set { SetValue(DataContextProperty, value); } } public static readonly DependencyProperty DataContextProperty = DependencyProperty.Register("DataContext", typeof(object), typeof(DataContextBinder), new PropertyMetadata(null, new PropertyChangedCallback(OnDataContextChanged))); public static void OnDataContextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ((DataContextBinder)d).OnDataContextChanged(e.OldValue, e.NewValue); } private void OnDataContextChanged(object oldValue, object newValue) { owner.UpdateInnerDataContext(newValue); } } 

अब आइए हमारे देखें (SomeVisualControl) में IDataContextOwner इंटरफ़ेस का एक बहुत ही सरल कार्यान्वयन लिखें:

 public class SomeVisualControl : Control, IDataContextOwner { // ... object IDataContextOwner.DataContext { get { return DataContext; } } void IDataContextOwner.UpdateInnerDataContext(object dataContext) { if (InnerDataStore != null) InnerDataStore.DataContext = dataContext; } } 

आखिरी बात यह है कि View के अंदर DataContextBinder का एक उदाहरण बनाएं।
आप इसे सीधे क्लास कंस्ट्रक्टर में कर सकते हैं:

 public SomeVisualControl() { this.dataContextBinder = new DataContextBinder(this); } 

एप्लिकेशन को चलाएं और सुनिश्चित करें कि संदर्भ आंतरिक ऑब्जेक्ट को सौंपा गया है और मॉडल से लाइन डेटास्टोर ऑब्जेक्ट पर सही ढंग से सेट है। अब एप्लिकेशन विंडो उपयोगकर्ता द्वारा परिभाषित मॉडल से डेटा प्रदर्शित करती है।

निष्कर्ष

यह कार्यान्वयन किसी विशिष्ट वर्ग से जुड़ा हुआ नहीं है और इसे लागू किया जा सकता है जहां एक DataContext को एक ऐसी वस्तु को निर्दिष्ट करने की आवश्यकता होती है जिसे "नियमित" साधनों द्वारा प्राप्त नहीं किया जा सकता है।
एक ही समय में, जब गैर-दृश्य वस्तुओं के पदानुक्रम में संदर्भ को गहराई से पारित करने की आवश्यकता होती है, तो आप बस DataContextBinder वर्ग का एक ऑब्जेक्ट बनाते हैं और IDataContextOwner इंटरफ़ेस को लागू करते हैं।
यह आपको निर्भरता गुणों के बोझिल लेखन और प्रत्येक वर्ग में उनके बीच बंधन की परिभाषा से मुक्त करता है। DataContextBinder कार्यक्षमता को एन्क्रिप्ट करता है और कुछ बिंदु पर नेस्टेड ऑब्जेक्ट पर एक नया संदर्भ मान सेट करने की आवश्यकता के मालिक को सूचित करता है।

नमूना स्रोत यहां उपलब्ध हैं:
WPF और सिल्वरलाइट