WPF中ObservableCollection用Dispatcher仍抛NotSupportedException问题

异常信息 #

System.NotSupportedException: This type of CollectionView does not support changes to its SourceCollection from a thread different from the Dispatcher thread.
   at System.Windows.Data.CollectionView.OnCollectionChanged(Object sender, NotifyCollectionChangedEventArgs args)
   at System.Collections.ObjectModel.ObservableCollection`1.OnCollectionChanged(NotifyCollectionChangedEventArgs e)
   at System.Collections.ObjectModel.Collection`1.Insert(Int32 index, T item)
   at ClipKeeper.Source.MVVM.ViewModel.BaseViewModel.<>c__DisplayClass315_0.<ClipboardManager_OnNewClipboardItemHandler>b__0() in C:\dev\projects\c#\ClipKeeper\ClipKeeper\Source\MVVM\ViewModel\BaseViewModel.cs:line 943
   at System.Windows.Threading.Dispatcher.Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken, TimeSpan timeout)
   at System.Windows.Threading.Dispatcher.Invoke(Action callback)
   at ClipKeeper.Source.MVVM.ViewModel.BaseViewModel.ClipboardManager_OnNewClipboardItemHandler(ClipboardItem clipboardItem) in C:\dev\projects\c#\ClipKeeper\ClipKeeper\Source\MVVM\ViewModel\BaseViewModel.cs:line 941

环境代码片段 #

MainWindow.xaml.cs #

public partial class MainWindow : Window
{
    private BaseViewModel ViewModel;
}

BaseViewModel.cs #

public class BaseViewModel : INotifyPropertyChanged
{
    private ClipboardManager clipboardManager;

    public BaseViewModel()
    {
        clipboardManager.OnNewClipboardItemHandler += ClipboardManager_OnNewClipboardItemHandler;
    }

    public ObservableCollection<ClipboardItem> HistoryClipboards
    {
        get { return historyClipboards; }
        set
        {
            historyClipboards = value;
            NotifyPropertyChanged();
        }
    }

    public ClipboardManager ClipboardManager
    {
        get { return clipboardManager; }
        set
        {
            clipboardManager = value;
            NotifyPropertyChanged(nameof(ClipboardManager));
        }
    }

    private void ClipboardManager_OnNewClipboardItemHandler(ClipboardItem clipboardItem)
    {
        HistoryClipboards.Insert(0, clipboardItem);
    }
}

ClipboardManager.cs #

public class ClipboardManager
{
    private readonly SharpClipboard sharpClipboard;
    public event OnNewClipboardItemDelegate? OnNewClipboardItemHandler;

    private void SharpClipboard_ClipboardChanged(object? sender, ClipboardChangedEventArgs e)
    {
        var currentClipboardItem = new ClipboardItem(
            contentTypes: ContentTypes.Text,
            data: Helpers.GetObjectBytes(e.ContentType, text),
            title: e.SourceApplication.Title ?? "N/A",
            path: path,
            info: $"{text.Length:N0} characters",
            isEditable: true,
            isWhiteSpace: string.IsNullOrWhiteSpace(text));

        OnNewClipboardItemHandler?.Invoke(currentClipboardItem);
    }

    public ClipboardManager()
    {
        sharpClipboard = new SharpClipboard();
        sharpClipboard.ClipboardChanged += SharpClipboard_ClipboardChanged;
    }
}

问题详情 #

在ClipboardManager_OnNewClipboardItemHandler方法中向ObservableCollection添加新剪贴板项时，应用会抛出System.NotSupportedException。该问题为偶发，通常在运行数小时后出现，重启应用可暂时恢复，但一段时间后会再次触发。

已尝试的修复方案 #

最初尝试将插入逻辑包裹在Dispatcher调用中，确保在UI线程执行：

Application.Current.Dispatcher.Invoke(() =>
{
    HistoryClipboards.Insert(0, clipboardItem);
});

但该方案无法彻底解决问题，异常仍会复发。

后续补充尝试 #

添加了集合同步锁和启用WPF的集合同步机制：

private readonly object historyClipboardsLock = new();

historyClipboards = new ObservableCollection<ClipboardItem>();
BindingOperations.EnableCollectionSynchronization(HistoryClipboards, historyClipboardsLock);

添加项时使用锁：

lock (historyClipboardsLock)
{
    HistoryClipboards.Insert(0, clipboardItem);
}

但异常依然存在。

额外代码上下文 #

目前仅在搜索过滤逻辑中使用了Dispatcher：

public async void Execute(object? parameter)
{
    if (parameter is TextBox textBox)
    {
        ViewModel.ShowLoadingMessage();

        // 获取文本框中的搜索内容
        string searchText = textBox.Text;

        // 更新ViewModel属性以显示/隐藏提示文本
        ViewModel.ShowHintText = string.IsNullOrEmpty(searchText);

        // 异步执行过滤操作
        var filteredItems = await Task.Run(() =>
        {
            var itemSourceList = new CollectionViewSource() { Source = ViewModel.HistoryClipboards };
            ICollectionView collectionView = itemSourceList.View;

            // 定义过滤规则：匹配包含搜索文本的剪贴板项
            var filteredPredicate = new Predicate<object>(item => ((ClipboardItem)item).DataToText().Contains(searchText));
            collectionView.Filter = filteredPredicate;
            return collectionView;
        });

        ViewModel.HideLoadingMessage();
        Application.Current.Dispatcher.Invoke(() =>
        {
            ViewModel.BindFilter(filteredItems);
        });
    }
}

用户疑问 #

1. 为何使用Dispatcher仍会触发该异常？
2. 考虑到剪贴板事件处理线程与UI线程不同，有什么更优的安全更新ObservableCollection的方案？
3. 如何确保应用处理此类更新时不再触发System.NotSupportedException？

分析与解决方案 #

1. 为何Dispatcher方案仍失效？ #

• Dispatcher对象不可靠：Application.Current.Dispatcher在长时间运行的应用中可能意外失效（比如UI线程Dispatcher实例被回收），导致后续调用并未真正切换到UI线程。
• 集合视图的线程绑定冲突：搜索逻辑中在Task.Run后台线程创建的ICollectionView会绑定到该后台线程，后续集合变更时，视图会尝试在后台线程处理变更通知，即使集合本身是在UI线程更新的，也会触发异常。
• 同步机制混用：同时使用Dispatcher.Invoke和BindingOperations.EnableCollectionSynchronization会打乱WPF的内置同步逻辑，导致线程冲突。

2. 更优的跨线程更新方案 #

推荐二选一，不要混用：

方案一：正确使用BindingOperations.EnableCollectionSynchronization

确保仅初始化一次同步，所有集合操作都在锁内执行，不混合Dispatcher：

private readonly object _collectionLock = new object();
private ObservableCollection<ClipboardItem> _historyClipboards;

public BaseViewModel()
{
    _historyClipboards = new ObservableCollection<ClipboardItem>();
    // 仅执行一次：启用集合同步，绑定锁对象
    BindingOperations.EnableCollectionSynchronization(_historyClipboards, _collectionLock);
    clipboardManager.OnNewClipboardItemHandler += ClipboardManager_OnNewClipboardItemHandler;
}

private void ClipboardManager_OnNewClipboardItemHandler(ClipboardItem clipboardItem)
{
    lock (_collectionLock)
    {
        _historyClipboards.Insert(0, clipboardItem);
    }
}

方案二：捕获可靠的UI线程Dispatcher

在ViewModel初始化时（必须在UI线程）捕获Dispatcher实例，避免依赖Application.Current：

private readonly Dispatcher _uiDispatcher;
private ObservableCollection<ClipboardItem> _historyClipboards;

public BaseViewModel()
{
    // 捕获当前UI线程的Dispatcher（确保ViewModel在UI线程初始化）
    _uiDispatcher = Dispatcher.CurrentDispatcher;
    _historyClipboards = new ObservableCollection<ClipboardItem>();
    clipboardManager.OnNewClipboardItemHandler += ClipboardManager_OnNewClipboardItemHandler;
}

private void ClipboardManager_OnNewClipboardItemHandler(ClipboardItem clipboardItem)
{
    if (_uiDispatcher.CheckAccess())
    {
        _historyClipboards.Insert(0, clipboardItem);
    }
    else
    {
        _uiDispatcher.Invoke(() => _historyClipboards.Insert(0, clipboardItem));
    }
}

3. 彻底避免异常的措施 #

• 禁止在后台线程创建集合视图：ICollectionView必须在UI线程创建，修改搜索逻辑，仅在后台执行过滤计算，视图创建放在UI线程：

  public async void Execute(object? parameter)
  {
      if (parameter is TextBox textBox)
      {
          ViewModel.ShowLoadingMessage();
          string searchText = textBox.Text;
          ViewModel.ShowHintText = string.IsNullOrEmpty(searchText);
  
          // 仅在后台执行过滤逻辑，不创建视图
          var filteredItems = await Task.Run(() =>
          {
              return ViewModel.HistoryClipboards.Where(item => item.DataToText().Contains(searchText)).ToList();
          });
  
          ViewModel.HideLoadingMessage();
          // 在UI线程创建集合视图并绑定
          _uiDispatcher.Invoke(() =>
          {
              var itemSourceList = new CollectionViewSource() { Source = filteredItems };
              ViewModel.BindFilter(itemSourceList.View);
          });
      }
  }
  

• 单一同步机制：只选择BindingOperations.EnableCollectionSynchronization或Dispatcher其中一种，不要混用。
• 确认ViewModel初始化线程：必须在UI线程初始化ViewModel，否则捕获的Dispatcher或同步机制会失效。
• 剪贴板事件线程处理：直接在SharpClipboard的事件回调中切换到UI线程执行集合更新，避免线程不确定性。

内容的提问来源于stack exchange，提问作者Dana Yeger