ऑब्जेक्ट संपादन और isDirty() ध्वज

Question

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

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

अतिरिक्त, मैं सोच रहा था कि क्या होगा यदि उपयोगकर्ता किसी ऑब्जेक्ट में किए गए परिवर्तनों को पूर्ववत करता है। IsDirty() ध्वज झूठी वापसी करनी चाहिए। इसलिए मुझे लगता है कि इसे प्राप्त करने का एकमात्र तरीका डोमेन ऑब्जेक्ट के अंदर प्रत्येक प्रॉपर्टी का मूल मान रखना है।

कोई विचार?

Answer 1

सही!

इसके अतिरिक्त, आप दो विधियों का पर्दाफाश कर सकते हैं: BeginEdit - इस विधि में, आप अपने IsDirty ध्वज को सही पर चिह्नित करते हैं। मतलब आप संशोधन कर रहे हैं। जब आप संशोधन करने वाले हैं तो इस विधि को कॉल करें

रद्द करें - इस विधि में, IsDirty ध्वज को गलत पर रीसेट करें। मतलब है कि आपने संपादन प्रक्रिया को घुमाया है और वापस मूल स्थिति में वापस कर दिया है। किए गए किसी भी संशोधन को रद्द करते समय इस विधि को कॉल करें।

और एक बार कोई संशोधन जारी रहेगा, तो आप IsDirty ध्वज को गलत पर रीसेट भी करते हैं।

मुझे उम्मीद है कि इससे मदद मिलती है।

Answer 2

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

Answer 3

हां, यह अच्छी तरह से काम करता है। पूर्ववत करने के बजाय, मैं यह इंगित करने के लिए IsDirty विधि का उपयोग करता हूं कि कुछ ने रिकॉर्ड बदल दिया है और फिर मेरे "रिकॉर्ड परिवर्तन तर्क" को ट्रिगर करता है। मैंने अपना खुद का ढांचा विकसित किया, जहां प्रत्येक टेबल फ़ील्ड वास्तव में किसी वस्तु की संपत्ति है। प्रत्येक बार जब फ़ील्ड "isDirty" ध्वज सेट किया जाता है, तो फ़ील्ड लिखा जाता है। ऑब्जेक्ट की "SaveObject" विधि में (वास्तव में यह एक सहायक वर्ग है लेकिन आसानी से ऑब्जेक्ट में हो सकता है, लेकिन मैं अलग-अलग शिष्टाचार में वस्तुओं को सहेजने की क्षमता चाहता था, जैसे xml, डेटाबेस, ect।), मैं IsDirty की जांच करता हूं और अगर यह झूठा है तो मैं बचाता हूं। यह तर्क को सरल बनाता है क्योंकि हर बार जब मुझे ऑब्जेक्ट को बदलने की संभावना होती है, तो मैं SaveObject को कॉल करता हूं और ढांचे को इसे संभालता हूं।

Answer 4

आप नेट ढांचे का उपयोग कर रहे हैं, तो आप रॉकफोर्ड Lhotka द्वारा CSLA नेट ढांचे पर एक नज़र लेने के लिए चाहते हो सकता है: (IsDirty) http://www.lhotka.net/cslanet/Default.aspx

CSLA एक परिपक्व ढांचे वस्तु राज्य प्रबंधन शामिल है, कार्यक्षमता पूर्ववत, डेटा बाध्यकारी और बहुत कुछ, साथ ही यह मुक्त और मुक्त स्रोत है।

Answer 5

अपने डोमेन के आधार पर, आप अंतर के लिए परीक्षण करने के लिए समानता का उपयोग कर सकते हैं। मूल ऑब्जेक्ट रखें और ऑब्जेक्ट की प्रतिलिपि संपादन के लिए करें। कभी भी एक संपादन किया जा सकता है, यूआई उचित रूप से संशोधित करें।

इस सुझाव का लाभ यह है कि यह आपके डोमेन वस्तुओं पर जीयूआई विशिष्ट कार्यक्षमता (IsDirty() झंडा) छड़ी नहीं करता है, लेकिन YMMV

Answer 6

आप समर्थन कर रहे हैं, तो ऑपरेशन की तुलना में अधिक विवरण के किसी एक स्तर पर पूर्ववत 'आखिरी बचत के बाद से सब कुछ पूर्ववत करें' तो मैं एक पूर्ववत स्टैक का सुझाव दूंगा। जब कुछ संपादित किया जाता है, तो यह (या यह पूर्ववत ऑपरेशन फ़ैक्टर या प्रतिनिधि) स्टैक में जोड़ा जाता है। जब आप पूर्ववत करते हैं, तो आप बस स्टैक पॉप करते हैं और ऑपरेशन को पूर्ववत करते हैं। आपका isDirty() ध्वज तब एक चेक है यदि पूर्ववत स्टैक में अतिरिक्त संग्रहण और अद्यतन करने के लिए तर्क के बजाय आइटम शामिल हैं।

Answer 7

कुछ इंटरफेस हैं जिन्हें आप परिवर्तन ट्रैकिंग और पूर्ववत करने में मदद कर सकते हैं: INotifyPropertyChanged और IEditableObject। इन दोनों इंटरफेस ऑब्जेक्ट को डाटाबेसिंग के साथ अच्छा खेलने की अनुमति देते हैं।

public class Person : INotifyPropertyChanged, IEditableObject 
{ 
    private bool isDirty; 

    public bool IsDirty 
    { 
     get { return isDirty; } 
    } 

    private string firstname = string.Empty; 

    public string Firstname 
    { 
     get { return firstname; } 
     set 
     { 
      if (firstname == value) return; 
      firstname = value; 
      NotifyPropertyChanged("Firstname"); 
     } 
    } 

    private string lastname = string.Empty; 

    public string Lastname 
    { 
     get { return lastname; } 
     set 
     { 
      if (lastname == value) return; 
      lastname = value; 
      NotifyPropertyChanged("Lastname"); 
     } 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 

    public void NotifyPropertyChanged(string propertyName) 
    { 
     isDirty = true; 

     if (PropertyChanged != null) 
      PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); 
    } 

    private bool inTrans; 
    private Person copy; 

    public void BeginEdit() 
    { 
     if (!inTrans) 
     { 
      if (copy == null) 
       copy = new Person(); 

      copy.isDirty = isDirty; 
      copy.Firstname = Firstname; 
      copy.Lastname = Lastname; 


      inTrans = true; 
      isDirty = false; 
     } 
    } 

    public void CancelEdit() 
    { 
     if (inTrans) 
     { 
      isDirty = copy.isDirty; 
      Firstname = copy.Firstname; 
      Lastname = copy.Lastname; 

      inTrans = false; 
     } 
    } 

    public void EndEdit() 
    { 
     if (inTrans) 
     { 
      copy = null; 
      inTrans = false; 
     } 
    } 
}