为什么 ReadOnlyObservableCollection.CollectionChanged 不公开？

Question

为什么ReadOnlyObservableCollection.CollectionChanged 是受保护的而不是公开的（就像对应的ObservableCollection.CollectionChanged 一样）？

如果我无法访问CollectionChanged 事件，那么实现INotifyCollectionChanged 的集合有什么用？

Answer 1

这里是解决方案：CollectionChanged events on ReadOnlyObservableCollection

您必须将集合投射为INotifyCollectionChanged。

Answer 2

我已经为你找到了如何做到这一点的方法：

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

您只需要通过 INotifyCollectionChanged 接口显式引用您的集合。

Answer 3

我知道这篇文章已经过时了，但是，人们在发表评论之前应该花点时间了解 .NET 中使用的模式。只读集合是现有集合的包装器，可防止消费者直接修改它，查看ReadOnlyCollection，您会看到它是IList<T> 的包装器，它可能是可变的，也可能不是可变的。不可变集合是另一回事，新的 immutable collections library 涵盖了这一点

也就是说，只读不等于不可变！！！

除此之外，ReadOnlyObservableCollection 应该隐式实现 INotifyCollectionChanged。

Answer 4

想要订阅 ReadOnlyObservableCollection 上的集合更改通知绝对有充分的理由。因此，作为仅将您的集合转换为 INotifyCollectionChanged 的替代方法，如果您恰好是 ReadOnlyObservableCollection 的子类，那么以下提供了一种在语法上更方便的方式来访问 >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; }
    }
}

这对我以前很有效。

Answer 5

您可以为 Microsoft Connect 上描述此问题的错误条目投票：https://connect.microsoft.com/VisualStudio/feedback/details/641395/readonlyobservablecollection-t-collectionchanged-event-should-be-public

更新：

Microsoft 已关闭 Connect 门户。所以上面的链接不再起作用了。

我的 Win Application Framework (WAF) 库提供了一个解决方案：ReadOnlyObservableListclass：

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

Answer 6

正如已经回答的那样，您有两个选择：您可以将ReadOnlyObservableCollection<T> 转换为接口INotifyCollectionChanged 以访问显式实现的CollectionChanged 事件，或者您可以创建自己的包装类，在构造函数，只是连接包装的 ReadOnlyObservableCollection<T> 的事件。

关于为什么此问题尚未解决的一些其他见解：

从the source code 可以看出，ReadOnlyObservableCollection<T> 是一个公共的非密封（即可继承）类，其中的事件标记为protected virtual。

也就是说，可能存在具有派生自ReadOnlyObservableCollection<T> 的类的已编译程序，具有被覆盖的事件定义但protected 可见性。一旦事件的可见性在基类中更改为public，这些程序将包含无效代码，因为不允许在派生类中限制事件的可见性。

所以不幸的是，稍后制作protected virtual 事件public 是一个二进制破坏性更改，因此如果没有很好的理由就不会这样做，我担心“我必须强制转换对象一次才能附加处理程序" 根本不是。

来源：GitHub comment by Nick Guerrera, August 19th, 2015

Answer 7

这是谷歌上的热门，所以我想我会添加我的解决方案，以防其他人查找。

使用上面的信息（关于需要强制转换为INotifyCollectionChanged），我做了两个扩展方法来注册和注销。

我的解决方案 - 扩展方法

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

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

例子

IThing.cs

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

使用扩展方法

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

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

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

备选方案 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;
}

Answer 8

解决方案

ReadOnlyObservableCollection.CollectionChanged 没有公开（出于其他答案中列出的正当理由），所以让我们创建自己的包装类来公开它：

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

说明

人们问你为什么要观察只读集合的​​变化，所以我将解释许多有效情况之一；当只读集合包装了一个可以更改的私有内部集合时。

这是一个这样的场景：

假设您有一项服务，允许从服务外部向内部集合添加和删除项目。现在假设您想公开集合的值，但不希望消费者直接操作集合；所以你将内部集合包装在 ReadOnlyObservableCollection 中。

请注意，为了用ReadOnlyObservableCollection 包装内部集合，ReadOnlyObservableCollection 的构造函数强制内部集合从ObservableCollection 派生。

现在假设您想在内部集合更改时通知服务的使用者（因此当暴露的ReadOnlyObservableCollection 更改时）。而不是滚动您自己的实现，您只想公开ReadOnlyObservableCollection 的CollectionChanged。与其强迫消费者对ReadOnlyObservableCollection 的实现做出假设，您只需将ReadOnlyObservableCollection 与此自定义ObservableReadOnlyCollection 交换，就完成了。

ObservableReadOnlyCollection 将 ReadOnlyObservableCollection.CollectionChanged 隐藏起来，并简单地将所有集合更改的事件传递给任何附加的事件处理程序。