एक पर्यवेक्षण योग्यता में मूल्यों की एक श्रृंखला को कुशलतापूर्वक

Question

मेरे पास ObservableCollection आइटम है जो मेरे दृश्य में सूची नियंत्रण से जुड़ा हुआ है।

मेरे पास ऐसी स्थिति है जहां मुझे संग्रह की शुरुआत में मूल्यों का एक हिस्सा जोड़ने की आवश्यकता है। Collection<T>.Insert दस्तावेज प्रत्येक डालने को ओ (एन) ऑपरेशन के रूप में निर्दिष्ट करता है, और प्रत्येक सम्मिलन भी CollectionChanged अधिसूचना उत्पन्न करता है।

इसलिए मैं आदर्श रूप से एक ही कदम में वस्तुओं की पूरी श्रृंखला डालना पसंद करता हूं, जिसका मतलब है अंतर्निहित सूची का केवल एक शफल, और उम्मीद है कि एक CollectionChanged अधिसूचना (संभवतः एक "रीसेट")।

Collection<T> ऐसा करने के लिए किसी भी विधि का खुलासा नहीं करता है। List<T> में InsertRange() है, लेकिन IList<T>, Collection<T> इसकी Items संपत्ति के माध्यम से खुलासा नहीं करता है।

क्या ऐसा करने के लिए कोई रास्ता है?

Answer 1

ऑब्जर्जेबल कोलेक्शन एक सुरक्षित Items संपत्ति का खुलासा करता है जो अधिसूचना अर्थशास्त्र के बिना अंतर्निहित संग्रह है। इसका मतलब है आप एक संग्रह का निर्माण कर सकते इनहेरिट ObservableCollection से करता है कि आप क्या चाहते हैं:

class RangeEnabledObservableCollection<T> : ObservableCollection<T> 
{ 
    public void InsertRange(IEnumerable<T> items) 
    { 
     this.CheckReentrancy(); 
     foreach(var item in items) 
      this.Items.Add(item); 
     this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 
} 

उपयोग:

void Main() 
{ 
    var collection = new RangeEnabledObservableCollection<int>(); 
    collection.CollectionChanged += (s,e) => Console.WriteLine("Collection changed"); 
    collection.InsertRange(Enumerable.Range(0,100)); 
    Console.WriteLine("Collection contains {0} items.", collection.Count); 
} 

Answer 2

ऊपर जवाब उपयोगी बनाने के लिए डब्ल्यू/प्रतिबिंब का उपयोग कर एक नया आधार वर्ग पाने ओ, यहाँ है एक उदाहरण:

public static void InsertRange<T>(this ObservableCollection<T> collection, IEnumerable<T> items) 
{ 
    var enumerable = items as List<T> ?? items.ToList(); 
    if (collection == null || items == null || !enumerable.Any()) 
    { 
    return; 
    } 

    Type type = collection.GetType(); 

    type.InvokeMember("CheckReentrancy", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, collection, null); 
    var itemsProp = type.BaseType.GetProperty("Items", BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.Instance); 
    var privateItems = itemsProp.GetValue(collection) as IList<T>; 
    foreach (var item in enumerable) 
    { 
    privateItems.Add(item); 
    } 

    type.InvokeMember("OnPropertyChanged", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, 
    collection, new object[] { new PropertyChangedEventArgs("Count") }); 

    type.InvokeMember("OnPropertyChanged", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, 
    collection, new object[] { new PropertyChangedEventArgs("Item[]") }); 

    type.InvokeMember("OnCollectionChanged", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, 
    collection, new object[]{ new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)}); 
} 

Answer 3

उदाहरण: वांछित चरणों 0,10,20,30,40,50,60,70,80,90,100 -> मिनट = 0, अधिकतम = 100, कदम = 11

static int min = 0; 
    static int max = 100; 
    static int steps = 11; 

    private ObservableCollection<string> restartDelayTimeList = new ObservableCollection<string> (
     Enumerable.Range(0, steps).Select(l1 => (min + (max - min) * ((double)l1/(steps - 1))).ToString()) 
    ); 

Answer 4

यह answer मुझे एक डेटा ग्रिड में नई प्रविष्टियां नहीं दिखा था। यह मेरे लिए काम करता है OnCollectionChanged:

public class SilentObservableCollection<T> : ObservableCollection<T> 
{ 
    public void AddRange(IEnumerable<T> enumerable) 
    { 
     CheckReentrancy(); 

     int startIndex = Count; 

     foreach (var item in enumerable) 
      Items.Add(item); 

     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<T>(enumerable), startIndex)); 
     OnPropertyChanged(new PropertyChangedEventArgs("Count")); 
     OnPropertyChanged(new PropertyChangedEventArgs("Item[]")); 
    } 
}