Warum ist ReadOnlyObservableCollection.CollectionChanged nicht öffentlich?

Warum ist ReadOnlyObservableCollection.CollectionChangedgeschützt und nicht öffentlich (wie das entsprechende ObservableCollection.CollectionChangedist)?

Was nützt eine implementierte Sammlung, INotifyCollectionChangedwenn ich nicht auf das CollectionChangedEreignis zugreifen kann ?

Hier ist die Lösung: CollectionChanged-Ereignisse in ReadOnlyObservableCollection

Sie müssen werfen , die Sammlung zu INotifyCollectionChanged .

Ich habe einen Weg für Sie gefunden, wie das geht:

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

Sie müssen nur explizit über die INotifyCollectionChanged- Schnittstelle auf Ihre Sammlung verweisen .

Ich weiß, dass dieser Beitrag alt ist, aber die Leute sollten sich Zeit nehmen, um die in .NET verwendeten Muster zu verstehen, bevor sie Kommentare abgeben. Eine schreibgeschützte Sammlung ist ein Wrapper für eine vorhandene Sammlung, der verhindert, dass Verbraucher sie direkt ändern. Sehen ReadOnlyCollectionSie sich an, und Sie werden sehen, dass es sich um einen Wrapper handelt, IList<T>der möglicherweise veränderbar ist oder nicht. Unveränderliche Sammlungen sind eine andere Sache und werden von der neuen Bibliothek unveränderlicher Sammlungen abgedeckt

Mit anderen Worten, schreibgeschützt ist nicht dasselbe wie unveränderlich !!!!

Davon abgesehen ReadOnlyObservableCollectionsollte implizit umgesetzt werden INotifyCollectionChanged.

Es gibt definitiv gute Gründe, Benachrichtigungen über geänderte Sammlungen in einer ReadOnlyObservableCollection abonnieren zu wollen . So, als Alternative zu lediglich Ihrer Sammlung als Casting INotifyCollectionChanged , wenn Sie geschehen , werden Subklassen ReadOnlyObservableCollection , dann bietet die folgenden eine syntaktisch bequeme Möglichkeit , die einen Zugriff auf Collection Ereignis:

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

Das hat bei mir schon mal gut geklappt.

Sie können für den Fehlereintrag in Microsoft Connect stimmen, der dieses Problem beschreibt: https://connect.microsoft.com/VisualStudio/feedback/details/641395/readonlyobservablecollection-t-collectionchanged-event-should-be-public

Aktualisieren:

Das Connect-Portal wurde von Microsoft heruntergefahren. Der obige Link funktioniert also nicht mehr.

Meine WAF-Bibliothek (Win Application Framework) bietet eine Lösung: ReadOnlyObservableList- Klasse:

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

Wie bereits beantwortet, haben Sie zwei Möglichkeiten: Sie können entweder ReadOnlyObservableCollection<T>die Schnittstelle in die Schnittstelle umwandeln, INotifyCollectionChangedum auf das explizit implementierte CollectionChangedEreignis zuzugreifen , oder Sie können eine eigene Wrapper-Klasse erstellen, die dies einmal im Konstruktor ausführt und nur die Ereignisse des Wraps verknüpft ReadOnlyObservableCollection<T>.

Einige zusätzliche Einblicke, warum dieses Problem noch nicht behoben wurde:

Wie Sie dem Quellcode entnehmen können , ReadOnlyObservableCollection<T>handelt es sich um eine öffentliche, nicht versiegelte (dh vererbbare) Klasse, in der die Ereignisse markiert sind protected virtual.

Das heißt, es gibt möglicherweise kompilierte Programme mit Klassen, von denen abgeleitet wurde ReadOnlyObservableCollection<T>, mit überschriebenen Ereignisdefinitionen, aber protectedSichtbarkeit. Diese Programme würden ungültigen Code enthalten, sobald die publicSichtbarkeit des Ereignisses in der Basisklasse geändert wird , da die Sichtbarkeit eines Ereignisses in abgeleiteten Klassen nicht eingeschränkt werden darf.

Leider ist das spätere Erstellen von protected virtualEreignissen publiceine binäre Änderung, und daher wird dies nicht ohne sehr gute Argumentation geschehen, was ich befürchte, "Ich muss das Objekt einmal umsetzen, um Handler anzuhängen", einfach nicht.

Quelle: GitHub-Kommentar von Nick Guererra, 19. August 2015

Dies war der Top-Hit bei Google, also dachte ich mir, ich würde meine Lösung hinzufügen, falls andere Leute dies nachschlagen.

Unter Verwendung der obigen Informationen (über die Notwendigkeit, in INotifyCollectionChanged umzuwandeln ) habe ich zwei Erweiterungsmethoden zum Registrieren und Aufheben der Registrierung erstellt.

Meine Lösung - Erweiterungsmethoden

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

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

Beispiel

IThing.cs

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

Verwenden der Erweiterungsmethoden

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

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

OPs Lösung

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

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