Evénement CollectionChanged

Question

ObservableCollection fournit l'événement CollectionChanged lorsque nous ajoutons, supprimons ou mettons à jour l'élément de la collection, mais déclenche l'événement pour le changement d'élément individuel, par exemple, chaque fois que j'ajoute le nouvel élément à la collection qu'il soulève la collection.

Maintenant, ce que je veux, c'est élever l'événement après avoir terminé toutes les modifications de la collection, par exemple, je dois ajouter 2 éléments, supprimer un élément et mettre à jour 2 éléments. L'événement CollectionChanged devrait seulement se déclencher après l'achèvement de tous ces ajouts, suppressions et mises à jour.

Ou, supposons que j'ai une nouvelle collection avec toutes les modifications, maintenant, je veux augmenter le CollectionChanged quand je cède la nouvelle collection, par exemple:

ObservableCollection<string> mainCollection; //assume it has some items 
mainCollection = updatedCollection; // at this point I want to raise the event. 

S'il vous plaît fournir à vos suggestions précieuses.

Cordialement,

Bhavik

Answer 1

On dirait que vous préférez être en train de regarder l'affectation à la variable mainCollection plutôt que les événements qui déclenchent de la classe ObservableCollection. Quelque chose comme ceci:

 private ObservableCollection<MyItemType> _mainCollection; 
     public ObservableCollection<MyItemType> MainCollection 
     { 
      get 
      { 
       return _mainCollection; 
      } 
      set 
      { 
       _mainCollection = value; 
       TriggerMyEvent(); // do whatever you like here 
      } 
     } 

Answer 2

Il ne fonctionne pas la façon dont vous écrit, la cause est que vous êtes abonné à l'événement d'objet mainCollection puis le remplacer par tout autre objet juste referencng par le même nom de variable . Vous avez besoin de ne pas affecter la collecte, mais d'ajouter tous les éléments de collection mis à jour à la collection principale

EDIT: AddRange pour ObservableCollection:

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

namespace System.Collections.ObjectModel 
{ 

/// <summary> 
/// Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed. 
/// </summary> 
/// <typeparam name="T"></typeparam> 
public class ObservableCollection<T> : System.Collections.ObjectModel.ObservableCollection<T> 
{ 

    /// <summary> 
    /// Adds the elements of the specified collection to the end of the ObservableCollection(Of T). 
    /// </summary> 
    public void AddRange(IEnumerable<T> collection) 
    { 
     foreach (var i in collection) Items.Add(i); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add), collection.ToList()); 
    } 

    /// <summary> 
    /// Removes the first occurence of each item in the specified collection from ObservableCollection(Of T). 
    /// </summary> 
    public void RemoveRange(IEnumerable<T> collection) 
    { 
     foreach (var i in collection) Items.Remove(i); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove), collection.ToList()); 
    } 

    /// <summary> 
    /// Clears the current collection and replaces it with the specified item. 
    /// </summary> 
    public void Replace(T item) 
    { 
     ReplaceRange(new T[] { item }); 
    } 
    /// <summary> 
    /// Clears the current collection and replaces it with the specified collection. 
    /// </summary> 
    public void ReplaceRange(IEnumerable<T> collection) 
    { 
     List<T> old = new List<T>(Items); 
     Items.Clear(); 
     foreach (var i in collection) Items.Add(i); 
     OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace)); 
    } 

    /// <summary> 
    /// Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class. 
    /// </summary> 
    public ObservableCollection() 
     : base() { } 

    /// <summary> 
    /// Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class that contains elements copied from the specified collection. 
    /// </summary> 
    /// <param name="collection">collection: The collection from which the elements are copied.</param> 
    /// <exception cref="System.ArgumentNullException">The collection parameter cannot be null.</exception> 
    public ObservableCollection(IEnumerable<T> collection) 
     : base(collection) { } 
} 
} 

Extrait de this question

Answer 3

standard ObservableCollection<T> ne prend pas en charge ce scénario. Vous pouvez créer une classe implémentant l'interface INotifyCollectionChanged avec la logique dont vous avez besoin, par exemple, avec une méthode unique pour remplacer tous les éléments par une autre collection.

Cela peut ne pas être bon pour l'interface utilisateur, par exemple, si un élément lié à la collection a été sélectionné ou concentré, cet état sera perdu si vous ré-initialisez complètement la collection. Cela dépend de votre scénario.