Osservare ProprietàChanged su elementi di una raccolta

Question

Sto provando a collegarmi a un evento sugli oggetti INotifyPropertyChanged in una raccolta.

Ogni risposta che io abbia mai visto a questa domanda ha detto di gestire la cosa nel modo seguente:

void NotifyingItems_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) 
{ 
    if(e.NewItems != null) 
    { 
     foreach(INotifyPropertyChanged item in e.NewItems) 
     { 
      item.PropertyChanged += new PropertyChangedEventHandler(CollectionItemChanged); 
     } 
    } 
    if(e.OldItems != null) 
    { 
     foreach(ValidationMessageCollection item in e.OldItems) 
     { 
      item.PropertyChanged -= CollectionItemChanged; 
     } 
    } 
} 

Il mio problema è che questo non riesce del tutto ogni volta che uno sviluppatore chiama Clear() sulla raccolta NotifyingItems. Quando ciò accade, questo gestore di eventi viene chiamato con e.Action == Reset e entrambi e.NewItems e e.OldItems uguale a null (Mi aspetto che quest'ultimo contenga tutti gli elementi).

Il problema è che quegli oggetti non vanno via e non vengono distrutti, non sono più presumibilmente monitorati dalla classe corrente, ma poiché non ho mai avuto la possibilità di rimuovere il loro PropertyChangedEventHandler - mantengono chiamare il mio gestore CollectionItemChanged anche dopo che sono stati cancellati dal mio elenco NotifyingItems. In che modo una tale situazione dovrebbe essere gestita con questo modello "ben consolidato"?

Answer 1

ultimo scoperto

ho trovato una soluzione che permette all'utente di sfruttare sia l'efficienza di aggiungere o rimuovere molti elementi alla volta mentre solo sparare un evento - e soddisfare le esigenze di UIElements per ottenere l'argomento Action.Reset args mentre tutti gli altri utenti vorrebbero un elenco di elementi aggiunti e rimossi.

Questa soluzione implica l'override dell'evento CollectionChanged. Quando andiamo a sparare a questo evento, possiamo effettivamente osservare l'obiettivo di ciascun gestore registrato e determinarne il tipo. Dal momento che solo le classi ICollectionView richiedono gli argomenti NotifyCollectionChangedAction.Reset quando cambiano più di un elemento, possiamo selezionarli e dare a tutti gli altri argomenti di evento corretti che contengono l'elenco completo di elementi rimossi o aggiunti. Di seguito è l'implementazione.

public class BaseObservableCollection<T> : ObservableCollection<T> 
{ 
    //Flag used to prevent OnCollectionChanged from firing during a bulk operation like Add(IEnumerable<T>) and Clear() 
    private bool _SuppressCollectionChanged = false; 

    /// Overridden so that we may manually call registered handlers and differentiate between those that do and don't require Action.Reset args. 
    public override event NotifyCollectionChangedEventHandler CollectionChanged; 

    public BaseObservableCollection() : base(){} 
    public BaseObservableCollection(IEnumerable<T> data) : base(data){} 

    #region Event Handlers 
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) 
    { 
     if(!_SuppressCollectionChanged) 
     { 
      base.OnCollectionChanged(e); 
      if(CollectionChanged != null) 
       CollectionChanged.Invoke(this, e); 
     } 
    } 

    //CollectionViews raise an error when they are passed a NotifyCollectionChangedEventArgs that indicates more than 
    //one element has been added or removed. They prefer to receive a "Action=Reset" notification, but this is not suitable 
    //for applications in code, so we actually check the type we're notifying on and pass a customized event args. 
    protected virtual void OnCollectionChangedMultiItem(NotifyCollectionChangedEventArgs e) 
    { 
     NotifyCollectionChangedEventHandler handlers = this.CollectionChanged; 
     if(handlers != null) 
      foreach(NotifyCollectionChangedEventHandler handler in handlers.GetInvocationList()) 
       handler(this, !(handler.Target is ICollectionView) ? e : new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 
    #endregion 

    #region Extended Collection Methods 
    protected override void ClearItems() 
    { 
     if(this.Count == 0) return; 

     List<T> removed = new List<T>(this); 
     _SuppressCollectionChanged = true; 
     base.ClearItems(); 
     _SuppressCollectionChanged = false; 
     OnCollectionChangedMultiItem(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed)); 
    } 

    public void Add(IEnumerable<T> toAdd) 
    { 
     if(this == toAdd) 
      throw new Exception("Invalid operation. This would result in iterating over a collection as it is being modified."); 

     _SuppressCollectionChanged = true; 
     foreach(T item in toAdd) 
      Add(item); 
     _SuppressCollectionChanged = false; 
     OnCollectionChangedMultiItem(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<T>(toAdd))); 
    } 

    public void Remove(IEnumerable<T> toRemove) 
    { 
     if(this == toRemove) 
      throw new Exception("Invalid operation. This would result in iterating over a collection as it is being modified."); 

     _SuppressCollectionChanged = true; 
     foreach(T item in toRemove) 
      Remove(item); 
     _SuppressCollectionChanged = false; 
     OnCollectionChangedMultiItem(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, new List<T>(toRemove))); 
    } 
    #endregion 
} 

Grazie a tutti per i loro suggerimenti e collegamenti. Non sarei mai arrivato a questo punto senza vedere tutte le soluzioni incrementalmente migliori che altre persone hanno avuto.

Answer 2

Forse un'occhiata a this answer

Non suggerisce di utilizzare .Clear() e l'attuazione di un metodo .RemoveAll() estensione che rimuovere gli elementi one-by-one

public static void RemoveAll(this IList list) 
{ 
    while (list.Count > 0) 
    { 
     list.RemoveAt(list.Count - 1); 
    } 
} 

Se questo non funziona per voi , ci sono altre buone soluzioni pubblicate nel link pure.

Answer 3

Il ripristino non fornisce gli elementi modificati. Avresti bisogno di mantenere una raccolta separata per cancellare gli eventi se continuavi a usare Cancella.

Una soluzione più semplice e più efficiente in termini di memoria sarebbe quella di creare una funzione chiara e rimuovere ogni elemento anziché chiamare la raccolta.

void ClearCollection() 
    { 
     while(collection.Count > 0) 
     { 
      // Could handle the event here... 
      // collection[0].PropertyChanged -= CollectionItemChanged; 
      collection.RemoveAt(collection.Count -1); 
     } 
    } 

Answer 4

Ho risolto questo problema facendo il mio sottoclasse di ObservableCollection<T> che sostituisce il metodo ClearItems. Prima di chiamare l'implementazione di base, genera un evento CollectionChanging che ho definito sulla mia classe.

CollectionChanging si accendono prima che la raccolta venga effettivamente cancellata e quindi si ha la possibilità di iscriversi all'evento e annullare l'iscrizione agli eventi.

Esempio:

public event NotifyCollectionChangedEventHandler CollectionChanging; 

protected override void ClearItems() 
{ 
    if (this.Items.Count > 0) 
    { 
     this.OnCollectionChanging(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); 
    } 

    base.ClearItems(); 
} 

protected virtual void OnCollectionChanging(NotifyCollectionChangedEventArgs eventArgs) 
{ 
    if (this.CollectionChanging != null) 
    { 
     this.CollectionChanging(this, eventArgs); 
    } 
} 

Answer 5

Edit: questa soluzione non funziona

This solution dalla questione legata alla Rachel sembra essere brillante:

Se sostituisco il mio NotifyingItems ObservableCollection con una classe ereditante che sovrascrive la Collection sovrascrivibile.Metodo ClearItems(), allora posso intercettare i NotifyCollectionChangedEventArgs e sostituirlo con un Rimuovi invece di un'operazione di ripristino, e passare l'elenco degli elementi rimossi:

//Makes sure on a clear, the list of removed items is actually included. 
protected override void ClearItems() 
{ 
    if(this.Count == 0) return; 

    List<T> removed = new List<T>(this); 
    base.ClearItems(); 
    base.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed)); 
} 

protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) 
{ 
    //If the action is a reset (from calling base.Clear()) our overriding Clear() will call OnCollectionChanged, but properly. 
    if(e.Action != NotifyCollectionChangedAction.Reset) 
     base.OnCollectionChanged(e); 
} 

brillante, e nulla deve essere cambiato ovunque tranne nel mio propria classe.

---

* Edit *

ho amato questa soluzione, ma non funziona ... Non ti è permesso di sollevare un NotifyCollectionChangedEventArgs che ha più di un elemento modificato a meno che l'azione sia "Ripristina". Si ottiene la seguente eccezione di runtime: Range actions are not supported. Non so perché debba essere così dannatamente pignolo su questo, ma ora non ci resta altra scelta che rimuovere ogni elemento uno alla volta ... licenziando un nuovo evento CollectionChanged per ognuno. Che dannata seccatura.

soluzione