跨线程调用NotifyCollectionChangedAction.Reset异常及多UI线程绑定问题

咱们先拆解你遇到的核心问题，一步步来解决：

为什么Reset操作会抛出异常？ #

你提到常规Add/Remove操作正常，但NotifyCollectionChangedAction.Reset会触发跨线程异常，根源在于：

• BindingOperations.EnableCollectionSynchronization的作用是同步集合的修改操作（比如Clear/Add），避免多线程修改时的线程安全问题，但它不会自动把CollectionChanged通知调度到UI线程。
• WPF的CollectionView强制要求所有CollectionChanged通知必须在绑定的UI线程触发，否则就会抛出跨线程异常。你的SuppressNotifications(false)是在后台线程调用的，直接触发base.OnCollectionChanged(Reset)时，通知是在后台线程发出的，这就违反了WPF的线程规则。

而Add/Remove看似正常，是因为这些单个修改的通知可能被CollectionView做了兼容处理，但Reset是全量刷新操作，线程校验会更严格，所以问题直接暴露了出来。

单UI线程场景的修复方案 #

修改你的自定义集合，把所有通知都调度到UI线程执行。这里推荐在集合构造时就捕获UI线程的Dispatcher（因为构造通常在UI线程完成），避免后续获取错误的Dispatcher：

public class ObservableDataCollection<T> : ObservableCollection<T> {
    private bool _suppressNotification = false;
    private object _lock = new object();
    private readonly Dispatcher _uiDispatcher;

    public ObservableDataCollection(IEnumerable<T> collection) : base(collection) {
        _uiDispatcher = Dispatcher.CurrentDispatcher;
        BindingOperations.EnableCollectionSynchronization(Items, _lock);
    }

    public ObservableDataCollection() {
        _uiDispatcher = Dispatcher.CurrentDispatcher;
        BindingOperations.EnableCollectionSynchronization(Items, _lock);
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) {
        if (!_suppressNotification) {
            // 统一调度到构造时的UI线程
            if (_uiDispatcher.CheckAccess()) {
                base.OnCollectionChanged(e);
            } else {
                _uiDispatcher.Invoke(() => base.OnCollectionChanged(e));
            }
        }
    }

    protected override void OnPropertyChanged(PropertyChangedEventArgs e) {
        if (!_suppressNotification) {
            if (_uiDispatcher.CheckAccess()) {
                base.OnPropertyChanged(e);
            } else {
                _uiDispatcher.Invoke(() => base.OnPropertyChanged(e));
            }
        }
    }

    public void SuppressNotifications(bool suppressNotification) {
        _suppressNotification = suppressNotification;
        if (!_suppressNotification) {
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
    }

    public object SyncLock => _lock;
}

这样不管是单个修改还是批量Reset，所有通知都会被正确调度到UI线程，彻底解决跨线程异常。

多UI线程场景的处理方案 #

如果你的集合需要绑定到多个UI线程（比如多个窗口运行在不同的UI线程），上面的单Dispatcher方案就不适用了——每个UI线程的CollectionView都需要在自己的线程上接收通知。

解决思路是：

1. 当集合在某个UI线程上被绑定时，注册该线程的Dispatcher。
2. 触发通知时，遍历所有注册的Dispatcher，分别在对应线程上调度通知。

修改后的集合类示例：

public class ObservableDataCollection<T> : ObservableCollection<T> {
    private bool _suppressNotification = false;
    private object _lock = new object();
    private readonly HashSet<Dispatcher> _registeredDispatchers = new HashSet<Dispatcher>();

    public ObservableDataCollection(IEnumerable<T> collection) : base(collection) {
        BindingOperations.EnableCollectionSynchronization(Items, _lock);
        // 注册构造时的UI线程Dispatcher
        RegisterDispatcher(Dispatcher.CurrentDispatcher);
    }

    public ObservableDataCollection() {
        BindingOperations.EnableCollectionSynchronization(Items, _lock);
        RegisterDispatcher(Dispatcher.CurrentDispatcher);
    }

    // 供外部UI线程注册自己的Dispatcher
    public void RegisterDispatcher(Dispatcher dispatcher) {
        lock (_lock) {
            if (dispatcher != null && !_registeredDispatchers.Contains(dispatcher)) {
                _registeredDispatchers.Add(dispatcher);
                // 监听Dispatcher关闭事件，避免内存泄漏
                dispatcher.ShutdownStarted += (s, e) => {
                    lock (_lock) {
                        _registeredDispatchers.Remove(dispatcher);
                    }
                };
            }
        }
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) {
        if (!_suppressNotification) {
            List<Dispatcher> dispatchers;
            lock (_lock) {
                dispatchers = _registeredDispatchers.ToList();
            }

            foreach (var dispatcher in dispatchers) {
                if (dispatcher.CheckAccess()) {
                    base.OnCollectionChanged(e);
                } else {
                    dispatcher.Invoke(() => base.OnCollectionChanged(e));
                }
            }
        }
    }

    protected override void OnPropertyChanged(PropertyChangedEventArgs e) {
        if (!_suppressNotification) {
            List<Dispatcher> dispatchers;
            lock (_lock) {
                dispatchers = _registeredDispatchers.ToList();
            }

            foreach (var dispatcher in dispatchers) {
                if (dispatcher.CheckAccess()) {
                    base.OnPropertyChanged(e);
                } else {
                    dispatcher.Invoke(() => base.OnPropertyChanged(e));
                }
            }
        }
    }

    public void SuppressNotifications(bool suppressNotification) {
        _suppressNotification = suppressNotification;
        if (!_suppressNotification) {
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
    }

    public object SyncLock => _lock;
}

使用时，每个UI线程在绑定集合前，需要调用RegisterDispatcher注册自己的Dispatcher：

// UI线程1（窗口A的线程）
var collection = new ObservableDataCollection<MyItem>();
collection.RegisterDispatcher(Dispatcher.CurrentDispatcher);
// 绑定到窗口A的UI元素

// UI线程2（窗口B的线程）
collection.RegisterDispatcher(Dispatcher.CurrentDispatcher);
// 绑定到窗口B的UI元素

这样每个UI线程的CollectionView都会在自己的线程上收到通知，避免跨线程异常。

额外注意事项 #

• 每个UI线程都需要调用一次BindingOperations.EnableCollectionSynchronization，确保该线程上的集合访问是同步的。
• 批量修改时，一定要先调用SuppressNotifications(true)，避免频繁触发通知影响性能。

内容的提问来源于stack exchange，提问作者Michael T