WPF CAL MVVM

Question

में मॉडल को प्रारंभ करने और देखने का सही तरीका क्या है I WPF CAL MVVM में दृश्य और दृश्य मॉडल प्रारंभ करने के दो तरीकों से आ गए हैं।

1 - अधिक लोकप्रिय होने लगता है। दृश्य को स्वचालित रूप से हल करने के लिए ViewModel को हल करने के लिए आपको आवश्यक है। व्यूमोडेल में व्यू के बारे में जानकारी है।

public interface IView 
    { 
     void SetModel(IViewModel model); 
    } 

    public interface IViewModel 
    { 
     IView View { get; } 
    } 

    public class View 
    { 
     public void SetModel(IViewModel model) 
     { 
      this.DataContext = model; 
     } 
    } 

    public class ViewModel 
    { 
     private IView view; 

     public ViewModel(IView view) 
     { 
      this.view = view; 
     } 

     public IView View { return this.view; } 
    } 

2 - बहुत साफ क्लीनर लगता है और व्यूमोडेल से दृश्य को हटा देता है। ViewModel को स्वचालित रूप से हल करने के लिए दृश्य को हल करने के लिए आपको आवश्यक है। वस्तुओं को दृश्य में इंजेक्ट करता है (सुनिश्चित नहीं है कि यह अच्छा है या नहीं)।

public interface IView 
    { 
    } 

    public interface IViewModel 
    { 
    } 

    public class View 
    { 
     private IViewModel model; 

     public View(IUnityContainer unityContainer) 
     { 
      this.model = unityContainer.Resolve<IViewModel>(); 
      this.DataContext = this.model; 
     } 
    } 

    public class ViewModel 
    { 
    } 

विचारों और मॉडलों को शुरू करने की स्वीकार्य विधि क्या है और प्रत्येक विधि के फायदे और नुकसान क्या हैं। क्या आप अपने विचार में वस्तुओं को इंजेक्शन दे रहे हैं?

Answer 1

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

अंतर यह है कि # 1 निर्भरता इंजेक्शन और # 2 सेवा स्थान कहा जाता है कहा जाता है। वे अक्सर भ्रमित होते हैं क्योंकि वे आम तौर पर कुछ प्रकार के आईओसी कंटेनर का उपयोग करते हैं (हालांकि यह मामला नहीं होना चाहिए)।

यह अंत में वरीयता का मामला है, लेकिन जैसा कि मैंने कहा था कि मुझे लगता है कि आपको # 1 परीक्षण करने में बहुत आसान लगेगा ... आपको अपने परीक्षण/मॉकिंग में IUnityContainer इंटरफ़ेस शामिल नहीं करना होगा।

Answer 2

विकल्प 1 सही दिखता है, दृश्य को व्यूमोडेल का संदर्भ दें।

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

विकल्प 2 बिल्कुल सही नहीं दिखता है। कक्षाओं में आईओसी कंटेनर का संदर्भ पास करना मेरी पुस्तक में एक बड़ी कोड गंध है। एक आईओसी कंटेनर को कॉल कम किया जाना चाहिए। मेरे अधिकांश अनुप्रयोगों में मैं केवल सामान को तार करने के लिए प्रोग्राम की शुरुआत में कंटेनर में कॉल करता हूं। फैक्ट्री कक्षाओं के साथ आमतौर पर अधिक गतिशील वस्तु निर्माण किया जाता है।

Answer 3

मैं XAML में दृश्य मॉडल को परिभाषित करने और टाइप पहुँच के लिए केवल पढ़ने के लिए संपत्ति प्रदान करने के लिए पसंद करते हैं:

<UserControl ...> 
    <UserControl.DataContext> 
     <local:MyViewModel/> 
    </UserControl.DataContext> 

    ... 

</UserControl> 

public partial class MyView : UserControl, IMyView 
{ 
    public MyViewModel ViewModel 
    { 
     get { return this.DataContext as MyViewModel; } 
    } 

    ... 
} 

Answer 4

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

एक विकल्प विकल्प 2 को विकल्प 1 के रूप में टेस्ट करने योग्य होने की अनुमति देता है, लेकिन अवधारणात्मक रूप से स्पष्ट है कि व्यूमोडेल दृश्य के बारे में कभी नहीं जानता है।

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

वैकल्पिक:

public interface IView 
{ 
} 

public interface IViewModel 
{ 
} 

public class View : IView 
{ 
    private IViewModel model; 

    public View(IViewModel m) 
    { 
     this.model = m; 
     this.DataContext = this.model; 
    } 
} 

public class ViewModel : IViewModel 
{ 
} 

और कहीं और तुम हो:

Container.RegisterType<IViewModel, ViewModel>(/* appropriate container config */); 
Container.RegisterType<IView, View>(/* appropriate container config */); 

और उसे अपने साथ कहीं भी एक दृश्य बना सकते हैं:

Container.Resolve<IViewModel>();