एक साथ कई ऑब्जेक्ट्स जोड़ने और अधिसूचित होने के लिए कौन सा .NET संग्रह?

Question

System.Collections.ObjectModel ObservableCollection<T> कक्षा पर विचार कर रहा था। यह एक अजीब बात है क्योंकि

• यह एक जोड़ें विधि जो एक आइटम केवल लेता है। कोई AddRange या समकक्ष नहीं।
• अधिसूचना घटना तर्क एक NewItems संपत्ति है, जो एक IList (वस्तुओं की .. नहीं टी)

मेरे जरूरत यहाँ एक संग्रह और श्रोता भी हो जाता है करने के लिए वस्तुओं की एक बैच को जोड़ने के लिए है है अधिसूचना के हिस्से के रूप में बैच। क्या मुझे पर्यवेक्षण चयन के साथ कुछ याद आ रही है? क्या कोई और वर्ग है जो मेरी कल्पना को पूरा करता है?

अपडेट: अपने आप को यथासंभव यथासंभव रोल नहीं करना चाहते हैं। मुझे जोड़ने/निकालने/बदलने आदि में निर्माण करना होगा .. सामान की एक बहुत सारी चीज़ें।

---

संबंधित प्रश्न:
सूची < टी से https://stackoverflow.com/questions/670577/observablecollection-doesnt-support-addrange-method-so-i-get-notified-for-each

Answer 1

इनहेरिट> और ओवरराइड जोड़ें() और AddRange() पद्धतियों एक घटना को बढ़ाने के लिए?

Answer 2

यदि आप किसी प्रकार के संग्रह से उत्तराधिकारी बनना चाहते हैं, तो शायद आप System.Collections.ObjectModel.Collection से विरासत से बेहतर हो सकते हैं क्योंकि यह ओवरराइड के लिए वर्चुअल विधियां प्रदान करता है। यदि आप उस मार्ग पर जाते हैं तो आपको सूची से बाहर विधियों को छाया करना होगा।

मैं के बारे में पता नहीं कर रहा हूँ किसी भी अंतर्निहित संग्रह है कि इस सुविधा प्रदान करती हैं, हालांकि मैं ठीक किया जा रहा है :) का स्वागत करता हूँ

Answer 3

ऐसा लगता है कि INotifyCollectionChanged इंटरफेस को अद्यतन करने के एक से अधिक आइटम जोड़ा गया था के लिए अनुमति देता है, तो मैं मुझे यकीन नहीं है कि ObservableCollection<T> में AddRange क्यों नहीं है। आप AddRange के लिए एक विस्तार विधि बना सकते हैं, लेकिन इससे जोड़े गए प्रत्येक आइटम के लिए एक ईवेंट का कारण बन जाएगा। बचाव के लिए

public class MyObservableCollection<T> : ObservableCollection<T> 
{ 
    // matching constructors ... 

    bool isInAddRange = false; 

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) 
    { 
     // intercept this when it gets called inside the AddRange method. 
     if (!isInAddRange) 
      base.OnCollectionChanged(e); 
    } 


    public void AddRange(IEnumerable<T> items) 
    { 
     isInAddRange = true; 
     foreach (T item in items) 
      Add(item); 
     isInAddRange = false; 

     var e = new NotifyCollectionChangedEventArgs(
      NotifyCollectionChangedAction.Add, 
      items.ToList()); 
     base.OnCollectionChanged(e); 
    } 
} 

Answer 4

एक्सटेंशन विधि यार: यदि यह स्वीकार्य नहीं है कि आप इस प्रकार ObservableCollection<T> से विरासत में सक्षम होना चाहिए!

/// <summary> 
    /// Adds all given items to the collection 
    /// </summary> 
    /// <param name="collection">The collection.</param> 
    /// <param name="toAdd">Objects to add.</param> 
    public static void AddAll<T>(this IList<T> collection, params T[] toAdd) 
    { 
     foreach (var o in toAdd) 
      collection.Add(o); 
    } 

Answer 5

इतना ही नहीं System.Collections.ObjectModel.Collection<T> एक अच्छा शर्त है, लेकिन मदद डॉक्स में वहाँ कैसे आदेश सूचना प्राप्त करने के लिए इसके विभिन्न संरक्षित तरीकों को ओवरराइड करने के an example है। (उदाहरण के लिए नीचे स्क्रॉल करें 2.)

Answer 6

वैसे यह विचार fryguybob के समान है - थोड़े अजीब है कि ऑब्जर्जेबल कोलेक्शन थोडा-पूरा किया गया है। इस बात के लिए घटना args भी जेनेरिक्स .. का उपयोग नहीं करते मुझे एक IList (कि इतने है .. कल :) परीक्षण स्निपेट इस प्रकार का उपयोग कर रही है ...

using System.Collections.Generic; 
using System.Collections.ObjectModel; 
using System.Collections.Specialized; 

namespace MyNamespace 
{ 
    public class ObservableCollectionWithBatchUpdates<T> : ObservableCollection<T> 
    { 
     public void AddRange(ICollection<T> obNewItems) 
     { 
      IList<T> obAddedItems = new List<T>(); 
      foreach (T obItem in obNewItems) 
      { 
       Items.Add(obItem); 
       obAddedItems.Add(obItem); 
      } 
      NotifyCollectionChangedEventArgs obEvtArgs = new NotifyCollectionChangedEventArgs(
       NotifyCollectionChangedAction.Add, 
       obAddedItems as System.Collections.IList); 
      base.OnCollectionChanged(obEvtArgs); 
     } 

    } 
} 

Answer 7

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

 
NotSupportedException 
    at System.Windows.Data.ListCollectionView.ValidateCollectionChangedEventArgs(NotifyCollectionChangedEventArgs e) 
    at System.Windows.Data.ListCollectionView.ProcessCollectionChanged(NotifyCollectionChangedEventArgs args) 
    at System.Collections.Specialized.NotifyCollectionChangedEventHandler.Invoke(Object sender, NotifyCollectionChangedEventArgs e) 
    at System.Collections.ObjectModel.ObservableCollection`1.OnCollectionChanged(NotifyCollectionChangedEventArgs e) 

कार्यान्वयन मैं के साथ चले गए हैं रीसेट घटना में है कि अधिक समान रूप से WPF ढांचे के आसपास कार्यान्वित किया जाता है का उपयोग करता है:

public void AddRange(IEnumerable<T> collection) 
    { 
     foreach (var i in collection) Items.Add(i); 
     OnPropertyChanged("Count"); 
     OnPropertyChanged("Item[]"); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 

Answer 8

में दोनों सी # और वीबी Observable collection with AddRange, RemoveRange and Replace range methods पर एक नजर डालें।

वीबी में: INotifyCollectionChanging कार्यान्वयन।

Answer 9

तेजी से आप इस्तेमाल कर सकते हैं जोड़ने के लिए:

((List<Person>)this.Items).AddRange(NewItems); 

Answer 10

मैं सवाल इस तरह की कई बार देखा है, और मुझे आश्चर्य है कि क्यों यहां तक ​​कि Microsoft ObservableCollection हर जगह बढ़ावा दे रहा है और कहाँ पहले से ही एक बेहतर संग्रह उपलब्ध है thats है ..

BindingList<T>

आप सूचनाएं बंद और थोक ओपेरा करने की अनुमति देता कौन सा tions और फिर अधिसूचनाओं को चालू करें।

Answer 11

एक अन्य समाधान है कि CollectionView पैटर्न के समान है:

public class DeferableObservableCollection<T> : ObservableCollection<T> 
{ 
    private int deferLevel; 

    private class DeferHelper<T> : IDisposable 
    { 
     private DeferableObservableCollection<T> owningCollection; 
     public DeferHelper(DeferableObservableCollection<T> owningCollection) 
     { 
      this.owningCollection = owningCollection; 
     } 

     public void Dispose() 
     { 
      owningCollection.EndDefer(); 
     } 
    } 

    private void EndDefer() 
    { 
     if (--deferLevel <= 0) 
     { 
      deferLevel = 0; 
      OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
     } 
    } 

    public IDisposable DeferNotifications() 
    { 
     deferLevel++; 
     return new DeferHelper<T>(this); 
    } 

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) 
    { 
     if (deferLevel == 0) // Not in a defer just send events as normally 
     { 
      base.OnCollectionChanged(e); 
     } // Else notify on EndDefer 
    } 
}