¿Por qué está ReadOnlyObservableCollection.CollectionChangedprotegido y no es público (como lo ObservableCollection.CollectionChangedes el correspondiente )?

¿De qué sirve implementar una colección INotifyCollectionChangedsi no puedo acceder al CollectionChangedevento?

Aquí está la solución: eventos CollectionChanged en ReadOnlyObservableCollection

Tienes que convertir la colección a INotifyCollectionChanged .

Encontré una manera para ti de cómo hacer esto:

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

Solo necesita consultar su colección explícitamente mediante la interfaz INotifyCollectionChanged .

Sé que esta publicación es antigua, sin embargo, las personas deberían tomarse su tiempo para comprender los patrones utilizados en .NET antes de comentar. Una colección de solo lectura es una envoltura de una colección existente que evita que los consumidores la modifiquen directamente, mire ReadOnlyCollectiony verá que es una envoltura de una colección que IList<T>puede ser mutable o no. Las colecciones inmutables son un asunto diferente y están cubiertas por la nueva biblioteca de colecciones inmutables

En otras palabras, solo lectura no es lo mismo que inmutable.

Aparte de eso, ReadOnlyObservableCollectiondebería implementar implícitamente INotifyCollectionChanged.

Definitivamente hay buenas razones para querer suscribirse a las notificaciones de cambios de colección en ReadOnlyObservableCollection . Entonces, como una alternativa a simplemente convertir su colección como INotifyCollectionChanged , si está subclasificando ReadOnlyObservableCollection , entonces lo siguiente proporciona una forma más conveniente sintácticamente para acceder al evento 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; }
    }
}

Esto me ha funcionado bien antes.

Puede votar por la entrada de error en Microsoft Connect que describe este problema: https://connect.microsoft.com/VisualStudio/feedback/details/641395/readonlyobservablecollection-t-collectionchanged-event-should-be-public

Actualizar:

Microsoft ha cerrado el portal Connect. Entonces el enlace de arriba ya no funciona.

Mi biblioteca Win Application Framework (WAF) proporciona una solución: clase ReadOnlyObservableList :

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; }
    }
}

Como ya se respondió, tiene dos opciones: puede enviar el ReadOnlyObservableCollection<T>a la interfaz INotifyCollectionChangedpara acceder al CollectionChangedevento implementado explícitamente , o puede crear su propia clase contenedora que hace eso una vez en el constructor y simplemente conecta los eventos del empaquetado ReadOnlyObservableCollection<T>.

Algunas ideas adicionales sobre por qué este problema aún no se ha solucionado:

Como puede ver en el código fuente , ReadOnlyObservableCollection<T>es una clase pública, no sellada (es decir, heredable), donde se marcan los eventos protected virtual.

Es decir, puede haber programas compilados con clases derivadas ReadOnlyObservableCollection<T>, con definiciones de eventos anuladas pero protectedvisibilidad. Esos programas contendrían código inválido una vez que la visibilidad del evento se cambie apublic la visibilidad del evento en la clase base, porque no se permite restringir la visibilidad de un evento en clases derivadas.

Entonces, desafortunadamente, hacer protected virtualeventos publicmás adelante es un cambio de ruptura binaria y, por lo tanto, no se hará sin un muy buen razonamiento, que me temo "Tengo que lanzar el objeto una vez para adjuntar controladores" simplemente no lo es.

Fuente: Comentario de GitHub por Nick Guererra, 19 de agosto de 2015

Este fue el mayor éxito en Google, así que pensé en agregar mi solución en caso de que otras personas busquen esto.

Usando la información anterior (sobre la necesidad de transmitir a INotifyCollectionChanged ), hice dos métodos de extensión para registrar y cancelar el registro.

Mi solución : métodos de extensión

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

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

Ejemplo

IThing.cs

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

Usando los métodos de extensión

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

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

Solución de 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;
}

Solución

ReadOnlyObservableCollection.CollectionChanged no está expuesto (por razones válidas descritas en otras respuestas), así que hagamos nuestra propia clase contenedora que lo exponga:

/// <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);
}

Explicación

La gente ha preguntado por qué querría observar cambios en una colección de solo lectura, así que explicaré una de las muchas situaciones válidas; cuando la colección de solo lectura envuelve una colección interna privada que puede cambiar.

Aquí hay uno de esos escenarios:

Suponga que tiene un servicio que permite agregar y eliminar elementos a una colección interna desde fuera del servicio. Ahora suponga que desea exponer los valores de la colección pero no quiere que los consumidores manipulen la colección directamente; por lo que envuelve la colección interna en un ReadOnlyObservableCollection.

Tenga en cuenta que para envolver la colección interna con ReadOnlyObservableCollectionla colección interna se ve obligado a derivar de ObservableCollectionpor el constructor de ReadOnlyObservableCollection.

Ahora suponga que desea notificar a los consumidores del servicio cuando cambia la colección interna (y, por lo tanto, cuando ReadOnlyObservableCollectioncambia la expuesta ). En lugar de lanzar su propia implementación, solo desea exponer CollectionChangedel ReadOnlyObservableCollection. En lugar de obligar al consumidor a hacer una suposición sobre la implementación del ReadOnlyObservableCollection, simplemente intercambia el ReadOnlyObservableCollectioncon este personalizadoObservableReadOnlyCollection y listo.

Se ObservableReadOnlyCollectionoculta ReadOnlyObservableCollection.CollectionChangedcon los suyos y simplemente pasa todos los eventos modificados de la colección a cualquier controlador de eventos adjunto.