静态可观察集合事件未触发

Question

我有以下staticObservableCollection使用linq进行更新。为什么事件不触发？

public static class myViewModel
{
private static ObservableCollection<ObjA> CollectionA = new ObservableCollection<ObjA>();
private static ObservableCollection<ObjB> CollectionB = new ObservableCollection<ObjB>();
static myViewModel()
{
CollectionA.CollectionChanged += new NotifyCollectionChangedEventHandler(myHandler);
CollectionA = new ObservableCollection(CollectionB.Select(abc=> new ObjA(abc, True));
}
private static void myHandler(object sender, NotifyCollectionChangedEventArgs e)
{  
//To do
throw new NotImplementedException();
}
private static void updateCollection()
{
foreach (var x in CollectionA)
{
CollectionA.field=5;
}
}
}

Answer 1

第一步：给CollectionA一个事件处理程序。

CollectionA.CollectionChanged += new NotifyCollectionChangedEventHandler(myHandler);

第二步：放弃CollectionA并将其替换为没有处理程序的其他集合。

CollectionA = new ObservableCollection(CollectionB.Select(abc=> new ObjA(abc, true));

看看你在那里做了什么？

CollectionA返回对集合对象的引用。您不会向该集合对象添加项。您要将该集合对象替换为其他集合对象。

改为将项添加到现有集合：

CollectionA.CollectionChanged += new NotifyCollectionChangedEventHandler(myHandler);
foreach (var x in CollectionB.Select(abc=> new ObjA(abc, true)))
{
CollectionA.Add(x);
}

如果确实要一次性替换所有集合，则需要将处理程序添加到新集合中：

CollectionA = new ObservableCollection(CollectionB.Select(abc=> new ObjA(abc, true));
CollectionA.CollectionChanged += myHandler;

如果myHandler具有正确的参数和返回类型，则不需要new NotifyCollectionChangedEventHandler。

处理此类事情的常用方法是将CollectionA创建添加处理程序本身的属性：

private static ObservableCollection<ObjA> _collectionA;
public static ObservableCollection<ObjA> CollectionA {
get { return _collectionA; }
set {
if (_collectionA != value)
{
//  Remove handler from old collection, if any
if (_collectionA != null)
{
_collectionA.CollectionChanged -= myHandler;
}
_collectionA = value;
if (_collectionA != null)
{
_collectionA.CollectionChanged += myHandler;
//  Whatever myHandler does on new items, you probably want to do 
//  that here for each item in the new collection. 
}
}
}
}
static myViewModel()
{
//  Now, whenever you replace CollectionA, the setter will add the changed 
//  handler automatically and you don't have to think about it. 
CollectionA = new ObservableCollection(CollectionB.Select(abc=> new(abc, True));
}

更新

现在，我们用这些物品做什么？也许我们想知道它们的属性何时发生变化。ObservableCollection不会为我们这样做，但我们可以自己连接起来。

考虑以更方便的可重用方式重构此代码的方法很有趣。

private static ObservableCollection<ObjA> _collectionA;
public static ObservableCollection<ObjA> CollectionA
{
get { return _collectionA; }
set
{
if (_collectionA != value)
{
//  Remove handler from old collection, if any
if (_collectionA != null)
{
_collectionA.CollectionChanged -= myHandler;
}
//  1. Remove property changed handlers from old collection items (if old collection not null) 
//  2. Add property changed to new collection items (if new collection not null) 
AddAndRemovePropertyChangedHandlers(_collectionA, value, ObjA_PropertyChanged);
_collectionA = value;
if (_collectionA != null)
{
_collectionA.CollectionChanged += myHandler;
}
}
}
}
//  NotifyCollectionChangedEventArgs gives us non-generic IList rather than IEnumerable
//  but all we're doing is foreach, so make it as general as possible. 
protected static void AddAndRemovePropertyChangedHandlers(
System.Collections.IEnumerable oldItems, 
System.Collections.IEnumerable newItems, 
PropertyChangedEventHandler handler)
{
if (oldItems != null)
{
//  Some items may not implement INotifyPropertyChanged. 
foreach (INotifyPropertyChanged oldItem in oldItems.Cast<Object>()
.Where(item => item is INotifyPropertyChanged))
{
oldItem.PropertyChanged -= handler;
}
}
if (newItems != null)
{
foreach (INotifyPropertyChanged newItem in newItems.Cast<Object>()
.Where(item => item is INotifyPropertyChanged))
{
newItem.PropertyChanged += handler;
}
}
}
private static void ObjA_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
}
private static void myHandler(object sender, 
System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
//  If e.Action is Reset, you don't get the items that were removed. Oh well. 
AddAndRemovePropertyChangedHandlers(e.OldItems, e.NewItems, ObjA_PropertyChanged);
}