🕺🏾 🤞🏻 🐥 MVVM: एक नया रूप 🧘🏽 🚫 👈🏾

चेतावनी!
एमवीवीएम पैटर्न पर अधिक हालिया और प्रगतिशील सामग्री लेख के संदर्भ में एयरो फ्रेमवर्क के माध्यम से मॉडल पैटर्न में प्रस्तुत किए गए हैं और लेखों की अगली श्रृंखला के बारे में विस्तार से चर्चा की गई है ।

प्रस्तावना

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

व्यापार करने के लिए

WPF, सिल्वरलाइट और WinPhone अनुप्रयोगों के डेवलपर्स MVVM (मॉडल - दृश्य - ViewModel) डिजाइन पैटर्न से अच्छी तरह से अवगत हैं। हालाँकि, यदि आप इसके अतिरिक्त थोड़ा और कल्पना करते हैं, तो आप कुछ और दिलचस्प हो सकते हैं, और थोड़ा सा भी, मैं आश्वस्त करने की हिम्मत करता हूँ, क्रांतिकारी।

मान लें कि हमारे पास एक मेनू, टूलबार और स्टेटस बार के साथ एक टेक्स्ट एडिटर की एक क्लासिक विंडो (दृश्य) है, जिसे आप चाहें तो छिपा सकते हैं। हमें विंडो की स्थिति और आकार, साथ ही साथ एप्लिकेशन बंद होने पर तत्वों की दृश्य स्थिति और फिर उन्हें पुनर्स्थापित करने के कार्य से सामना करना पड़ता है।

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

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

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

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

इसलिए, हम कंस्ट्रक्टर में इंजेक्शनों को मना कर देंगे, सौभाग्य से, ऐसे उद्देश्यों के लिए अन्य तरीके हैं, और [डेटाकार्ट] विशेषता के साथ दृश्य मॉडल को चिह्नित करते हैं, और जिन गुणों को [DataMember] विशेषता के साथ क्रमबद्ध करने की आवश्यकता होती है (इन विशेषताओं को क्रमबद्धता को सरल करता है)।

अब एक छोटा सा स्टोर क्लास बनाएं।

public static class Store { private static readonly Dictionary<Type, object> StoredItemsDictionary = new Dictionary<Type, object>(); public static TItem OfType<TItem>(params object[] args) where TItem : class { var itemType = typeof (TItem); if (StoredItemsDictionary.ContainsKey(itemType)) return (TItem) StoredItemsDictionary[itemType]; var hasDataContract = Attribute.IsDefined(itemType, typeof (DataContractAttribute)); var item = hasDataContract ? Serializer.DeserializeDataContract<TItem>() ?? (TItem) Activator.CreateInstance(itemType, args) : (TItem) Activator.CreateInstance(itemType, args); StoredItemsDictionary.Add(itemType, item); return (TItem) StoredItemsDictionary[itemType]; } public static void Snapshot() { StoredItemsDictionary .Where(p => Attribute.IsDefined(p.Key, typeof (DataContractAttribute))) .Select(p => p.Value).ToList() .ForEach(i => i.SerializeDataContract()); } }

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

और एक जसन धारावाहिक लिखें।

  public static class Serializer { public const string JsonExtension = ".json"; public static readonly List<Type> KnownTypes = new List<Type> { typeof (Type), typeof (Dictionary<string, string>), typeof (SolidColorBrush), typeof (MatrixTransform), }; public static void SerializeDataContract(this object item, string file = null, Type type = null) { try { type = type ?? item.GetType(); if (string.IsNullOrEmpty(file)) file = type.Name + JsonExtension; var serializer = new DataContractJsonSerializer(type, KnownTypes); using (var stream = File.Create(file)) { var currentCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; serializer.WriteObject(stream, item); Thread.CurrentThread.CurrentCulture = currentCulture; } } catch (Exception exception) { Trace.WriteLine("Can not serialize json data contract"); Trace.WriteLine(exception.StackTrace); } } public static TItem DeserializeDataContract<TItem>(string file = null) { try { if (string.IsNullOrEmpty(file)) file = typeof (TItem).Name + JsonExtension; var serializer = new DataContractJsonSerializer(typeof (TItem), KnownTypes); using (var stream = File.OpenRead(file)) { var currentCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var item = (TItem) serializer.ReadObject(stream); Thread.CurrentThread.CurrentCulture = currentCulture; return item; } } catch { return default(TItem); } } }

देखने के मॉडल के लिए आधार वर्ग भी जटिल नहीं दिखता है।

  [DataContract] public class ViewModelBase : PropertyNameProvider, INotifyPropertyChanging, INotifyPropertyChanged { protected Dictionary<string, object> Values = new Dictionary<string, object>(); private const string IndexerName = System.Windows.Data.Binding.IndexerName; /* "Item[]" */ public event PropertyChangingEventHandler PropertyChanging = (sender, args) => { }; public event PropertyChangedEventHandler PropertyChanged = (sender, args) => { }; public object this[string key] { get { return Values.ContainsKey(key) ? Values[key] : null; } set { RaisePropertyChanging(IndexerName); if (Values.ContainsKey(key)) Values[key] = value; else Values.Add(key, value); RaisePropertyChanged(IndexerName); } } public object this[string key, object defaultValue] { get { if (Values.ContainsKey(key)) return Values[key]; Values.Add(key, defaultValue); return defaultValue; } set { this[key] = value; } } public void RaisePropertyChanging(string propertyName) { PropertyChanging(this, new PropertyChangingEventArgs(propertyName)); } public void RaisePropertyChanged(string propertyName) { PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); } [OnDeserializing] private void Initialize(StreamingContext context = default(StreamingContext)) { if (PropertyChanging == null) PropertyChanging = (sender, args) => { }; if (PropertyChanged == null) PropertyChanged = (sender, args) => { }; if (Values == null) Values = new Dictionary<string, object>(); } }

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

  [DataContract] public class PropertyNameProvider { public static string GetPropertyName<T>(Expression<Func<T>> expression) { var memberExpression = expression.Body as MemberExpression; var unaryExpression = expression.Body as UnaryExpression; if (unaryExpression != null) memberExpression = unaryExpression.Operand as MemberExpression; if (memberExpression == null || memberExpression.Member.MemberType != MemberTypes.Property) throw new Exception("Invalid lambda expression format."); return memberExpression.Member.Name; } }

खैर, इस स्तर पर हमने सूचकांक गुणों को बांधने की क्षमता को लागू किया है। Xaml में आप निम्नलिखित फॉर्म के भाव लिख सकते हैं

ऊँचाई = "{बाइंडिंग '[ऊँचाई, 600]', मोड = टूवे}"

जहां पहला पैरामीटर संपत्ति का नाम है, और दूसरा (वैकल्पिक) इसका डिफ़ॉल्ट मूल्य है।

यह दृष्टिकोण कुछ हद तक मानक IDataErrorInfo इंटरफ़ेस के कार्यान्वयन की याद दिलाता है। हम इसे लागू क्यों नहीं करते? अच्छा विचार है, लेकिन चलो जल्दी मत करो, लेकिन इसे ध्यान में रखें ... आइए अनुक्रमणिका के पुन: निर्धारण के साथ खेलते हैं। हर कोई ICommand के बारे में याद करता है, और WPF में अभी भी एक अच्छा तंत्र है कि कैसे RoutedCommands और CommandBindings काम करते हैं। इस तरह से दृश्य मॉडल में आदेशों के कार्यान्वयन को लिखना अच्छा होगा।

  this[ApplicationCommands.Save].CanExecute += (sender, args) => args.CanExecute = HasChanged; this[ApplicationCommands.New].CanExecute += (sender, args) => { args.CanExecute = !string.IsNullOrEmpty(FileName) || !string.IsNullOrEmpty(Text); }; this[ApplicationCommands.Help].Executed += (sender, args) => MessageBox.Show("Muse 2014"); this[ApplicationCommands.Open].Executed += (sender, args) => Open(); this[ApplicationCommands.Save].Executed += (sender, args) => Save(); this[ApplicationCommands.SaveAs].Executed += (sender, args) => SaveAs(); this[ApplicationCommands.Close].Executed += (sender, args) => Environment.Exit(0); this[ApplicationCommands.New].Executed += (sender, args) => { Text = string.Empty; FileName = null; HasChanged = false; };

खैर, गुणों और लंबोदर भावों की स्वचालित अधिसूचना के बिना एक दृश्य मॉडल क्या है? यह वैसे भी होना चाहिए।

  public string Text { get { return Get(() => Text); } set { Set(() => Text, value); } }

लेकिन क्या अगर ... एक कमांडबाइंडिंग की तरह एक प्रॉपर्टीबाइंड बनाएं और फिर से इंडेक्सर के साथ थोड़ा सा खेलें?

  this[() => Text].PropertyChanged += (sender, args) => HasChanged = true; this[() => FontSize].Validation += () => 4.0 < FontSize && FontSize < 128.0 ? null : "Invalid font size";

अच्छा लग रहा है, है ना?

और, निश्चित रूप से, हमारे चमत्कार दृश्य मॉडल।

  [DataContract] public class ViewModel : ViewModelBase, IDataErrorInfo { public ViewModel() { Initialize(); } string IDataErrorInfo.this[string propertyName] { get { return PropertyBindings.ContainsKey(propertyName) ? PropertyBindings[propertyName].InvokeValidation() : null; } } public PropertyBinding this[Expression<Func<object>> expression] { get { var propertyName = GetPropertyName(expression); if (!PropertyBindings.ContainsKey(propertyName)) PropertyBindings.Add(propertyName, new PropertyBinding(propertyName)); return PropertyBindings[propertyName]; } } public CommandBinding this[ICommand command] { get { if (!CommandBindings.ContainsKey(command)) CommandBindings.Add(command, new CommandBinding(command)); return CommandBindings[command]; } } public string Error { get; protected set; } public Dictionary<ICommand, CommandBinding> CommandBindings { get; private set; } public Dictionary<string, PropertyBinding> PropertyBindings { get; private set; } public CancelEventHandler OnClosing = (o, e) => { }; public TProperty Get<TProperty>(Expression<Func<TProperty>> expression, TProperty defaultValue = default(TProperty)) { var propertyName = GetPropertyName(expression); if (!Values.ContainsKey(propertyName)) Values.Add(propertyName, defaultValue); return (TProperty) Values[propertyName]; } public void Set<TProperty>(Expression<Func<TProperty>> expression, TProperty value) { var propertyName = GetPropertyName(expression); RaisePropertyChanging(propertyName); if (!Values.ContainsKey(propertyName)) Values.Add(propertyName, value); else Values[propertyName] = value; RaisePropertyChanged(propertyName); } public void RaisePropertyChanging<TProperty>(Expression<Func<TProperty>> expression) { var propertyName = GetPropertyName(expression); RaisePropertyChanging(propertyName); } public void RaisePropertyChanged<TProperty>(Expression<Func<TProperty>> expression) { var propertyName = GetPropertyName(expression); RaisePropertyChanged(propertyName); } [OnDeserializing] private void Initialize(StreamingContext context = default(StreamingContext)) { CommandBindings = new Dictionary<ICommand, CommandBinding>(); PropertyBindings = new Dictionary<string, PropertyBinding>(); PropertyChanging += OnPropertyChanging; PropertyChanged += OnPropertyChanged; } private void OnPropertyChanging(object sender, PropertyChangingEventArgs e) { var propertyName = e.PropertyName; if (!PropertyBindings.ContainsKey(propertyName)) return; var binding = PropertyBindings[propertyName]; if (binding != null) binding.InvokePropertyChanging(sender, e); } private void OnPropertyChanged(object sender, PropertyChangedEventArgs e) { var propertyName = e.PropertyName; if (!PropertyBindings.ContainsKey(propertyName)) return; var binding = PropertyBindings[propertyName]; if (binding != null) binding.InvokePropertyChanged(sender, e); } }

अब हम पूरी तरह से सशस्त्र हैं, लेकिन पूर्णता की कोई सीमा नहीं है। एक नियम के रूप में, दृश्य मॉडल C # कोड में इसके प्रतिनिधित्व (दृश्य) के साथ जुड़ा हुआ है, लेकिन xaml में सीधे इस बंधन को लागू करना कितना सुंदर होगा! कंस्ट्रक्टर में इंजेक्शन के हमारे इनकार के बारे में याद रखें? इसलिए वह हमें ऐसा अवसर देता है। मार्कअप * के लिए एक छोटा सा विस्तार लिखें।

  public class StoreExtension : MarkupExtension { public StoreExtension(Type itemType) { ItemType = itemType; } [ConstructorArgument("ItemType")] public Type ItemType { get; set; } public override object ProvideValue(IServiceProvider serviceProvider) { var service = (IProvideValueTarget) serviceProvider.GetService(typeof (IProvideValueTarget)); var frameworkElement = service.TargetObject as FrameworkElement; var dependancyProperty = service.TargetProperty as DependencyProperty; var methodInfo = typeof(Store).GetMethod("OfType").MakeGenericMethod(ItemType); var item = methodInfo.Invoke(null, new object[] { new object[0] }); if (frameworkElement != null && dependancyProperty == FrameworkElement.DataContextProperty && item is ViewModel) { var viewModel = (ViewModel) item; frameworkElement.CommandBindings.AddRange(viewModel.CommandBindings.Values); var window = frameworkElement as Window; if (window != null) viewModel.OnClosing += (o, e) => { if (!e.Cancel) window.Close(); }; frameworkElement.Initialized += (sender, args) => frameworkElement.DataContext = viewModel; return null; } return item; } }

वोइला, किया!

DataContext = "{स्टोर दृश्यमॉडल: MainViewModel}"

मैं इस तथ्य पर ध्यान आकर्षित करता हूं कि बाइंडिंग के दौरान, नियंत्रण न केवल डेटाकोटेक्स्ट को बदलता है, बल्कि कमांडबाइंडिंग संग्रह को व्यू मॉडल से मूल्यों के साथ आबादी है।

(* ताकि मार्कअप के लिए उपसर्ग "{Foundation: Store viewModels: MainViewModel}" जैसे उपसर्ग न लिखें, उन्हें एक अलग प्रोजेक्ट में लागू किया जाना चाहिए और उसी प्रोजेक्ट में आपको असेंबली में कुछ लिखना होगा।

 [assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Foundation")] [assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Foundation.Converters")] [assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Foundation.MarkupExtensions")]

)

इसी प्रकार, हम ऊपर चर्चा किए गए सूचकांकों के लिए बंधन को सुशोभित करते हैं।

  public class ViewModelExtension : MarkupExtension { private static readonly BooleanConverter BooleanToVisibilityConverter = new BooleanConverter { OnTrue = Visibility.Visible, OnFalse = Visibility.Collapsed, }; private FrameworkElement _targetObject; private DependencyProperty _targetProperty; public ViewModelExtension() { } public ViewModelExtension(string key) { Key = key; } public ViewModelExtension(string key, object defaultValue) { Key = key; DefaultValue = defaultValue; } public string Key { get; set; } public string StringFormat { get; set; } public string ElementName { get; set; } public object DefaultValue { get; set; } public object FallbackValue { get; set; } public object TargetNullValue { get; set; } public IValueConverter Converter { get; set; } public RelativeSource RelativeSource { get; set; } public override object ProvideValue(IServiceProvider serviceProvider) { var service = (IProvideValueTarget) serviceProvider.GetService(typeof (IProvideValueTarget)); _targetProperty = service.TargetProperty as DependencyProperty; _targetObject = service.TargetObject as FrameworkElement; if (_targetObject == null || _targetProperty == null) return this; var key = Key; if (_targetProperty == UIElement.VisibilityProperty && string.IsNullOrWhiteSpace(key)) key = string.Format("Show{0}", string.IsNullOrWhiteSpace(_targetObject.Name) ? _targetObject.Tag : _targetObject.Name); key = string.IsNullOrWhiteSpace(key) ? _targetProperty.Name : key; if (!string.IsNullOrWhiteSpace(StringFormat)) Key = string.Format(StringFormat, _targetObject.Tag); var index = DefaultValue == null ? key : key + "," + DefaultValue; var path = string.IsNullOrWhiteSpace(ElementName) && RelativeSource == null ? "[" + index + "]" : "DataContext[" + index + "]"; if (_targetProperty == UIElement.VisibilityProperty && Converter == null) Converter = BooleanToVisibilityConverter; var binding = new Binding(path) {Mode = BindingMode.TwoWay, Converter = Converter}; if (ElementName != null) binding.ElementName = ElementName; if (FallbackValue != null) binding.FallbackValue = FallbackValue; if (TargetNullValue != null) binding.TargetNullValue = TargetNullValue; if (RelativeSource != null) binding.RelativeSource = RelativeSource; _targetObject.SetBinding(_targetProperty, binding); return binding.ProvideValue(serviceProvider); } }

Xaml में आप इस तरह लिख सकते हैं:

चौड़ाई = "{ViewModel DefaultValue = 800}"

परिणाम

शायद पर्याप्त है, मैंने बहुत सारी जानकारी संक्षिप्त रूप में प्रस्तुत की है, इसलिए पूर्णता के लिए, उदाहरण परियोजना के साथ खुद को परिचित करना बेहतर है।

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

विपक्ष:
- कंस्ट्रक्टर में इंजेक्शन से इनकार (हालांकि यह एक अनिवार्य आवश्यकता नहीं है);
- एक व्यक्ति के लिए कुछ निहित निर्णय उसके साथ परिचित नहीं है।

इस दृष्टिकोण में महारत हासिल करने और अपने निपटान में केवल कुछ आधार कक्षाएं होने के बाद, आप आराम से, जल्दी और कुशलता से एक समृद्ध इंटरैक्टिव इंटरफ़ेस के साथ एप्लिकेशन लिख सकते हैं, जबकि दृश्य मॉडल को साफ और कॉम्पैक्ट छोड़ सकते हैं।

मुझे वास्तव में उम्मीद है कि लेख आपके लिए उपयोगी होगा! आपका ध्यान के लिए धन्यवाद!

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

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

आप को प्रेरणा!

~~~~~~~~~~~~~~~~~~~~~~~~~
टिप्पणियाँ:

- आप किसी भी नियंत्रण को एक दृश्य के रूप में उपयोग कर सकते हैं, इसलिए कभी-कभी एक अलग इकाई (एक नया वर्ग) के रूप में एक दृश्य का चयन करना आवश्यक नहीं है, या किसी अन्य दृश्य मॉडल में एक संपत्ति जोड़ें। मैं एक उदाहरण के साथ समझाऊंगा:

 <Window DataContext={Store viewModels:MainViewModel}> … <!--<TextBlock DataContext={Store viewModels:DetailsViewModel} Text={Binding Name}/>--!> <TextBlock Text={Binding Name, Source={Store viewModels:DetailsViewModel}}/> … </Window>

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

- लेख में मैंने मूल सिद्धांत दिखाए, जिनके उपयोग से आप जल्दी और कुशलता से एक कार्यात्मक आवेदन कर सकते हैं। यह सब कुछ का उपयोग करने के लिए बिल्कुल आवश्यक नहीं है क्योंकि यह आपके पास सुधार, संशोधन और कल्पना करने का अधिकार है! यही विकास है, सफलता है!

MVVM: एक नया रूप

More articles: