Perché è ReadOnlyObservableCollection.CollectionChangedprotetto e non pubblico (come lo ObservableCollection.CollectionChangedè il corrispondente )?

A cosa serve l'implementazione di una raccolta INotifyCollectionChangedse non riesco ad accedere CollectionChangedall'evento?

Ecco la soluzione: eventi CollectionChanged su ReadOnlyObservableCollection

Devi eseguire il cast della raccolta su INotifyCollectionChanged .

Ho trovato un modo per te su come farlo:

ObservableCollection<string> obsCollection = new ObservableCollection<string>();
INotifyCollectionChanged collection = new ReadOnlyObservableCollection<string>(obsCollection);
collection.CollectionChanged += new NotifyCollectionChangedEventHandler(collection_CollectionChanged);

Devi solo fare riferimento alla tua raccolta in modo esplicito tramite l' interfaccia INotifyCollectionChanged .

So che questo post è vecchio, tuttavia, le persone dovrebbero dedicare del tempo per comprendere i modelli utilizzati in .NET prima di commentare. Una raccolta di sola lettura è un wrapper su una raccolta esistente che impedisce ai consumatori di modificarla direttamente, guarda ReadOnlyCollectione vedrai che è un wrapper su una IList<T>che può o non può essere modificabile. Le collezioni immutabili sono una questione diversa e sono coperte dalla nuova libreria delle collezioni immutabili

In altre parole, la sola lettura non è la stessa di immutabile !!!!

A parte questo, ReadOnlyObservableCollectiondovrebbe implicitamente implementare INotifyCollectionChanged.

Ci sono sicuramente buoni motivi per voler iscriversi alle notifiche di modifiche alla raccolta su ReadOnlyObservableCollection . Quindi, in alternativa al semplice cast della tua raccolta come INotifyCollectionChanged , se ti capita di creare una sottoclasse ReadOnlyObservableCollection , quanto segue fornisce un modo più sintatticamente conveniente per accedere all'evento a CollectionChanged :

    public class ReadOnlyObservableCollectionWithCollectionChangeNotifications<T> : ReadOnlyObservableCollection<T>
{
    public ReadOnlyObservableCollectionWithCollectionChangeNotifications(ObservableCollection<T> list)
        : base(list)
    {
    }

    event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged2
    {
        add { CollectionChanged += value; }
        remove { CollectionChanged -= value; }
    }
}

Questo ha funzionato bene per me prima.

Potresti votare per la voce di bug su Microsoft Connect che descrive questo problema: https://connect.microsoft.com/VisualStudio/feedback/details/641395/readonlyobservablecollection-t-collectionchanged-event-should-be-public

Aggiornare:

Il portale Connect è stato chiuso da Microsoft. Quindi il collegamento sopra non funziona più.

La mia libreria Win Application Framework (WAF) fornisce una soluzione: ReadOnlyObservableList classe:

public class ReadOnlyObservableList<T> 
        : ReadOnlyObservableCollection<T>, IReadOnlyObservableList<T>
{
    public ReadOnlyObservableList(ObservableCollection<T> list)
        : base(list)
    {
    }

    public new event NotifyCollectionChangedEventHandler CollectionChanged
    {
        add { base.CollectionChanged += value; }
        remove { base.CollectionChanged -= value; }
    }

    public new event PropertyChangedEventHandler PropertyChanged
    {
        add { base.PropertyChanged += value; }
        remove { base.PropertyChanged -= value; }
    }
}

Come già risposto, hai due opzioni: puoi eseguire il cast ReadOnlyObservableCollection<T>dell'interfaccia INotifyCollectionChangedper accedere CollectionChangedall'evento implementato in modo esplicito , oppure puoi creare la tua classe wrapper che lo fa una volta nel costruttore e aggancia semplicemente gli eventi del wrapper ReadOnlyObservableCollection<T>.

Alcuni approfondimenti aggiuntivi sul motivo per cui questo problema non è stato ancora risolto:

Come puoi vedere dal codice sorgente , ReadOnlyObservableCollection<T>è una classe pubblica, non sigillata (cioè ereditabile), in cui gli eventi sono contrassegnati protected virtual.

Cioè, potrebbero esserci programmi compilati con classi derivate da ReadOnlyObservableCollection<T>, con definizioni di eventi sovrascritte ma protectedvisibilità. Quei programmi conterrebbero codice non valido una volta che la visibilità dell'evento viene modificata publicnella classe base, poiché non è consentito limitare la visibilità di un evento nelle classi derivate.

Quindi, sfortunatamente, creare protected virtualeventi in un publicsecondo momento è un cambiamento binario, e quindi non sarà fatto senza un ottimo ragionamento, cosa che temo "devo lanciare l'oggetto una volta per collegare i gestori" semplicemente non lo è.

Fonte: commento GitHub di Nick Guererra, 19 agosto 2015

Questo è stato il successo su Google, quindi ho pensato di aggiungere la mia soluzione nel caso in cui altre persone lo cercassero.

Utilizzando le informazioni di cui sopra (sulla necessità di eseguire il cast su INotifyCollectionChanged ), ho creato due metodi di estensione per la registrazione e l' annullamento della registrazione.

La mia soluzione - Metodi di estensione

public static void RegisterCollectionChanged(this INotifyCollectionChanged collection, NotifyCollectionChangedEventHandler handler)
{
    collection.CollectionChanged += handler;
}

public static void UnregisterCollectionChanged(this INotifyCollectionChanged collection, NotifyCollectionChangedEventHandler handler)
{
    collection.CollectionChanged -= handler;
}

Esempio

IThing.cs

public interface IThing
{
    string Name { get; }
    ReadOnlyObservableCollection<int> Values { get; }
}

Utilizzo dei metodi di estensione

public void AddThing(IThing thing)
{
    //...
    thing.Values.RegisterCollectionChanged(this.HandleThingCollectionChanged);
}

public void RemoveThing(IThing thing)
{
    //...
    thing.Values.UnregisterCollectionChanged(this.HandleThingCollectionChanged);
}

Soluzione di OP

public void AddThing(IThing thing)
{
    //...
    INotifyCollectionChanged thingCollection = thing.Values;
    thingCollection.CollectionChanged += this.HandleThingCollectionChanged;
}

public void RemoveThing(IThing thing)
{
    //...
    INotifyCollectionChanged thingCollection = thing.Values;
    thingCollection.CollectionChanged -= this.HandleThingCollectionChanged;
}

Alternativa 2

public void AddThing(IThing thing)
{
    //...
    (thing.Values as INotifyCollectionChanged).CollectionChanged += this.HandleThingCollectionChanged;
}

public void RemoveThing(IThing thing)
{
    //...
    (thing.Values as INotifyCollectionChanged).CollectionChanged -= this.HandleThingCollectionChanged;
}

Soluzione

ReadOnlyObservableCollection.CollectionChanged non è esposto (per validi motivi delineati in altre risposte), quindi creiamo la nostra classe wrapper che lo esponga:

/// <summary>A wrapped <see cref="ReadOnlyObservableCollection{T}"/> that exposes the internal <see cref="CollectionChanged"/>"/>.</summary>
public class ObservableReadOnlyCollection<T> : ReadOnlyObservableCollection<T>
{
    public new NotifyCollectionChangedEventHandler CollectionChanged;

    public ObservableReadOnlyCollection(ObservableCollection<T> list) : base(list) { /* nada */ }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs args) => 
        CollectionChanged?.Invoke(this, args);
}

Spiegazione

Le persone hanno chiesto perché vorresti osservare le modifiche a una raccolta di sola lettura, quindi spiegherò una delle tante situazioni valide; quando la raccolta di sola lettura racchiude una raccolta interna privata che può cambiare.

Ecco uno di questi scenari:

Supponiamo di avere un servizio che consente di aggiungere e rimuovere elementi da una raccolta interna dall'esterno del servizio. Si supponga ora di voler esporre i valori della raccolta ma non si desidera che i consumatori manipolino direttamente la raccolta; quindi avvolgi la raccolta interna in un file ReadOnlyObservableCollection.

Si noti che per racchiudere la raccolta interna con ReadOnlyObservableCollectionla raccolta interna è costretto a derivare da ObservableCollectiondal costruttore di ReadOnlyObservableCollection.

Supponiamo ora di voler avvisare i consumatori del servizio quando la raccolta interna cambia (e quindi quando ReadOnlyObservableCollectioncambia la parte esposta ). Piuttosto che lanciare la tua implementazione, vuoi solo esporre il CollectionChangeddi ReadOnlyObservableCollection. Piuttosto che costringere il consumatore a fare un'ipotesi sull'implementazione del ReadOnlyObservableCollection, scambia semplicemente il ReadOnlyObservableCollectioncon questa consuetudine ObservableReadOnlyCollectione il gioco è fatto.

Si ObservableReadOnlyCollectionnasconde ReadOnlyObservableCollection.CollectionChangedcon i propri e passa semplicemente tutti gli eventi modificati della raccolta a qualsiasi gestore di eventi associato.