2012-01-01 17 views
5

मैं एक सेटिंग फार्म के लिए, सूचीदृश्य के दो संस्करणों की तुलना पर काम कर रहा हूँ कर रहे हैं दो ObservableCollection (रों) को देखने के लिए। मुझे यह जानने की ज़रूरत है कि क्या उपयोगकर्ता वास्तव में सूची को संशोधित करता है, इस स्थिति में जब वे "सहेजें" पर क्लिक करते हैं तो मैं वास्तव में सहेज लेगा। वे कुछ भी नहीं बदला है, जब वे "सहेजें" क्लिक मैं स्मृति/समय फिर से सहेजते समय कुछ वे परिवर्तन नहीं किया बर्बाद नहीं किया जाएगा।तुलना ही वे अलग

वैसे भी, मैं कैसे अगर वे बिल्कुल अलग हैं देखने के लिए दो ObservableCollections तुलना कर सकते हैं?

अग्रिम धन्यवाद!

उत्तर

1

जिस तरीके से हम इसे संभालते हैं, उसके लिए आगे थोड़ा और काम करने की आवश्यकता होती है, लेकिन इसे वीएस मैक्रोज़ या कोड-जेन टूल्स जैसे कोडस्मिथ का उपयोग करके स्वचालित किया जा सकता है।

हालांकि, यह दृष्टिकोण यूआई में किसी भी यूआई निर्माण के लिए एक्स्टेंसिबल है जिसे संग्रह के लिए बाध्य किया गया है और जब भी आपको पता होना चाहिए कि परिवर्तन हैं या नहीं, तो यूआई में फिर से लागू नहीं किया जाना चाहिए।

अवधारणा संग्रह और व्यापार वस्तु के भीतर झंडे को अद्यतन करने के लिए यह निर्धारित करने के लिए है कि संग्रह सदस्यता बदल गई है या संग्रह के भीतर कोई भी रिकॉर्ड बदल गया है या नहीं।

कार्यान्वयन काफी सरल है:

व्यापार वस्तु वर्ग के लिए एक HasChanged संपत्ति जोड़ें।

संग्रह में कोई भी हटाई गई संपत्ति जोड़ें। यह केवल तभी सेट किया जाएगा जब संग्रह से आइटम हटा दिए जाते हैं।

डीबी से रिकॉर्ड पढ़ने के बाद इन मानों को गलत में आरंभ करें।

(अब अर्ध-थकाऊ हिस्सा) कक्षा में प्रत्येक संपत्ति के लिए, यदि वास्तव में मूल्य बदलता है तो HasChanged संपत्ति को सत्य पर सेट करें। शून्य मूल्यों से सावधान रहें। उदाहरण के लिए:

public bool IsSelected 
    { 
     get 
     { 
      return m_fIsSelected; 
     } 
     set 
     { 
      if (m_fIsSelected != value) 
      { 
       this.HasChanged = true; 
       m_fIsSelected = value; 
      } 
     } 
    } 

सत्य पर AnyDeleted गुण सेट करने के लिए संग्रह को संशोधित जब एक रिकॉर्ड हटा दी जाती है:

protected override void RemoveItem(int index) 
    { 
     this.AnyDeleted = true; 

     base.RemoveItem(index); 
    } 

अंत में, इंगित करने के लिए किया जाए या नहीं कुछ भी बदल गया है संग्रह के लिए एक विधि जोड़ें। यह तरीका है कि आप यह निर्धारित करने के लिए कॉल करेंगे कि किसी भी बदलाव को सहेजने की आवश्यकता है या नहीं:

public bool HasAnyChanges() 
    { 
     // Exceptions are handled by the caller 

     // If anything was deleted, return true 
     if (this.AnyDeleted) 
     { 
      return true; 
     } 
     else 
     { 
      foreach (T theItem in this) 
      { 
       if (theItem.HasAnyChanges()) 
       { 
        return true; 
       } 
      } 
     } 

     return false; 
    } 
0

संपादित करें:

void ListView_ItemInserted(Object sender, ListViewInsertedEventArgs e) 
    { 
    if (e.Exception == null) 
    { 
     if (e.AffectedRows > 0) 
     { 
     flag = True; 
     } 
     else 
     { 
     flag = False; 
     } 
    } 

void ListView_Itemdeleted(Object sender, ListViewDeletedEventArgs e) 
    { 
    if (e.Exception == null) 
    { 
     if (e.AffectedRows > 0) 
     { 
     flag = True; 
     } 
     else 
     { 
     flag = False; 
     } 
    } 


void ListView_ItemUpdated(Object sender, ListViewUpdatedEventArgs e) 
    { 
    if (e.Exception == null) 
    { 
     if (e.AffectedRows > 0) 
     { 
     flag = True; 
     } 
     else 
     { 
     flag = False; 
     } 
    } 

आप सहेजने से पहले इस ध्वज चर देख सकते हैं। यह होगा! अगर यह सच है, इसे बचाओ!

+0

दो सूचीदृश्य नहीं हैं, वास्तव में, केवल एक। – mattsven

+0

आपका प्रश्न सूचीदृश्य के दो संस्करणों को इंगित करता है! तो इसका मतलब क्या है? आपने दो बार तुलना करने के बारे में फिर से उल्लेख किया है! – King

+0

आप कुछ डेटा संरचना जैसे xml या स्ट्रिंग के रूप में रखते हुए सूची में बाध्यकारी हैं और फिर सेटिंग में सहेज रहे हैं? ऐसा है क्या ? @NeXXeuS अगर मैं आपका प्रश्न इस तरह समझता हूं। तब तक जब तक एप्लिकेशन में स्मृति में सेटिंग्स और लगातार अद्यतन नहीं होते हैं, तो आपको सेटिंग्स को पढ़ना होगा और इसे करना होगा। इसे जितना बचा उतना ही। मुझे नहीं लगता कि यह प्रदर्शन के मामले में एक फर्क पड़ता है अगर ऐसा है। – King

4

आप विधि को छोड़कर LINQ का उपयोग कर सकते हैं: दो दृश्यों के सेट अंतर उत्पन्न करता है।

http://msdn.microsoft.com/en-us/library/system.linq.enumerable.except.aspx

निम्न नमूना विधि पर विचार करें ...

public void ExceptFunctioni() 
{ 
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 }; 
    int[] numbersB = { 1, 3, 5, 7, 8 }; 
    IEnumerable<int> aOnlyNumbers = numbersA.Except(numbersB); 
    if(aOnlyNumbers.Count()>0) 
    { 
     // do something 
    } 
} 

विधि को छोड़कर पहला संग्रह पर लागू और एक तर्क के रूप दूसरा संग्रह पारित कर दिया है। परिणाम में मतभेद होंगे। फिर आप परिणाम पूछ सकते हैं और तदनुसार कार्रवाई कर सकते हैं। यदि दोनों अनुक्रम बराबर हैं, तो परिणाम की गणना शून्य होगी।

यह कहकर, यह ध्यान देने योग्य है कि एमवीवीएम दुनिया में पसंदीदा रणनीति इस विधि का उपयोग यह नियंत्रित करने के लिए होगी कि आपका 'सहेजें' बटन सक्षम है या नहीं। इस दृष्टिकोण में, यदि दो संग्रह बराबर हैं, 'सहेजें' बटन विकलांग हो जाएगा और उपयोगकर्ता इसे उपयोग नहीं कर सका। , टिप्पणियाँ आप 'बेवकूफ की' टिप्पणी के जवाब में बनाया देखकर अपने 'oldList' होगा:

लेकिन किसी भी तरह, LINQ विधि को प्राप्त करने के लिए क्या आप के बाद कर रहे हैं की एक बहुत ही गाढ़ा तरीका प्रदान करता है ...

जोड़ना ऊपर नमूना कोड में numbersB के अनुरूप ...


इसके अलावा comment 'Stonetip' से (जिसे करने के लिए धन्यवाद) ...

More succinct: if(numbersA.Except(numbersB).Any()) { // do something } 
+0

मुझे लगता है कि वे शब्द थोड़ा उलझन में हैं और "पुरानी सूची केवल पुरानी सूची है (उपयोगकर्ता द्वारा उन्हें बदलने से पहले वर्तमान सेटिंग्स)" का अर्थ है कि वह कह सकता है कि कोई पहले से ही सेटिंग में सहेजा गया है और वर्तमान सूची का मतलब बचत नहीं है। उसके पास दो संग्रह नहीं हो सकते हैं लेकिन एक पहले से ही बचाया गया है (जिसे वह एक संग्रह के रूप में हमारे लिए वर्चुअलाइज करता है) और एक सूचीदृश्य पर। यदि उसके पास दोनों संग्रह स्मृति में हैं, तो LINQ की विधि को छोड़कर इसका उपयोग करना अच्छा है। LINQ (संक्षिप्त दृष्टिकोण) का उपयोग करने के लिए +1। आइए उसके काम पर अधिक विवरण के बारे में सुनें। – King

+0

@ डंब, हाय और नया साल मुबारक हो! क्या आप भ्रमित भाग में संशोधन करने के लिए 'संपादन' सुविधा का उपयोग करेंगे ताकि यह स्पष्ट हो? क्या आप का मतलब है कि सेटिंग्स लगातार बने रहने के लिए नहीं हैं? –

+0

नया साल मुबारक हो! मैं उसके लिए कुछ और स्पष्टीकरण देने का इंतजार कर रहा हूं ताकि हम उसे समझ सकें कि उसे क्या चाहिए और हम उन्हें संपादित कर सकते हैं। हाँ। मुझे यह विचार मिलता है कि उसका डेटा लगातार नहीं है। लेकिन निश्चित रूप से दो संस्करणों में टिप्पणियों में जो कहा गया है उसके साथ सुसंगत प्रतीत नहीं होता है! तो मेबेबे वह सूचीदृश्य के साथ हर बार कुछ करना चाहता है, यही कारण है कि मैंने सूचीदृश्य दृष्टिकोण के लिए घटनाओं की जांच करने का सुझाव दिया। लेकिन अगर उसके पास लगातार डेटा के दो संस्करण हैं, तो मैं आपके दृष्टिकोण का उपयोग करने की सलाह दूंगा! – King

0

मैं वें स्याही, आप गलत दृष्टिकोण पर ध्यान केंद्रित कर रहे हैं। आपको ListView पर बाध्य 2 सूचियों की सामग्री की तुलना नहीं करनी चाहिए, क्योंकि उनके पास मौजूद वस्तुओं की मात्रा निषिद्ध रूप से बड़ी हो सकती है।

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

  • या आप मान सकते हैं कि अगर कोई set बाइंडेड संग्रह संपत्ति के अंदर विधि का उपयोग करता है, तो इसका मतलब है कि संग्रह बदल दिया गया था।

दूसरे शब्दों में, रिले या आपके आवेदन की पूर्वनिर्धारित कार्यप्रवाह पर, या सामग्री को बदलने के लिए एक API परिभाषित करते हैं, तो आप अगर संग्रह में से सामग्री बदल गया था यह पता लगाने की जब और में सक्षम हो जाएगा ।

और एक और धारणा अभी तक: वहाँ क्लिक Save और नहीं सहेजते उपयोगकर्ता के लिए जाने के लिए कोई मतलब नहीं है। यदि Save पर क्लिक करना संभव है तो उपयोगकर्ता द्वारा अनुरोधित आदेश को निष्पादित करना होगा। यदि आप प्रदर्शन के बारे में सावधान हैं (आप कुछ सहेजना नहीं चाहते हैं, अगर यह अंतिम सहेजने से नहीं बदला गया था), तो Save बटन को अक्षम करें, अगर सहेज उचित नहीं है। दूसरे शब्दों में, UI बनाएं और अपने ऐप द्वारा अपेक्षित व्यवहार करें। उपयोगकर्ता को यह स्पष्ट करना कि ऐप अब क्या करता है और यह क्या नहीं करता है।

संबंधित मुद्दे