如何通过工作线程更新 ObservableCollection？

Question

我有一个ObservableCollection<A> a_collection; 该集合包含“n”个项目。每个项目 A 如下所示：

public class A : INotifyPropertyChanged
{

    public ObservableCollection<B> b_subcollection;
    Thread m_worker;
}

基本上，它都连接到 WPF 列表视图 + 详细信息视图控件，该控件在单独的列表视图中显示所选项目的 b_subcollection（2 向绑定、属性更改的更新等）。

当我开始实现线程时，问题就出现了。整个想法是让整个 a_collection 使用它的工作线程“工作”，然后更新各自的 b_subcollections 并让 gui 实时显示结果。

当我尝试它时，我得到一个异常，说只有 Dispatcher 线程可以修改 ObservableCollection，并且工作停止了。

谁能解释一下这个问题，以及如何解决它？

Answer 1

.NET 4.5 的新选项

从 .NET 4.5 开始，有一个内置机制可以自动同步对集合的访问并将CollectionChanged 事件分派到 UI 线程。要启用此功能，您需要在您的 UI 线程中调用 BindingOperations.EnableCollectionSynchronization。

EnableCollectionSynchronization 做了两件事：

1. 记住调用它的线程并导致数据绑定管道在该线程上编组CollectionChanged 事件。
2. 在处理完编组事件之前获取对集合的锁定，以便运行 UI 线程的事件处理程序在从后台线程修改集合时不会尝试读取集合。

非常重要的是，这并不能解决所有问题：为了确保线程安全地访问本质上不是线程安全的集合您必须通过以下方式与框架合作当集合即将被修改时，从后台线程获取相同的锁。

因此正确操作所需的步骤是：

1。确定您将使用哪种锁定方式

这将确定必须使用EnableCollectionSynchronization 的哪个重载。大多数情况下，一个简单的lock 语句就足够了，所以this overload 是标准选择，但如果您使用一些花哨的同步机制，还有support for custom locks。

2。创建集合并启用同步

根据选择的锁定机制，在 UI 线程上调用适当的重载。如果使用标准的lock 语句，您需要提供锁定对象作为参数。如果使用自定义同步，您需要提供CollectionSynchronizationCallback 委托和上下文对象（可以是null）。调用时，此委托必须获取您的自定义锁，调用传递给它的 Action 并在返回之前释放锁。

3。通过在修改之前锁定集合进行合作

当您要自己修改集合时，您还必须使用相同的机制锁定集合；在简单场景中使用lock() 在传递给EnableCollectionSynchronization 的同一个锁对象上执行此操作，或者在自定义场景中使用相同的自定义同步机制。

Answer 2

从技术上讲，问题不在于您正在从后台线程更新 ObservableCollection。问题是，当您这样做时，集合会在导致更改的同一线程上引发其 CollectionChanged 事件 - 这意味着控件正在从后台线程更新。

为了在绑定了控件的同时从后台线程填充集合，您可能必须从头开始创建自己的集合类型才能解决此问题。不过，有一个更简单的选项可能对您有用。

将 Add 调用发布到 UI 线程。

public static void AddOnUI<T>(this ICollection<T> collection, T item) {
    Action<T> addMethod = collection.Add;
    Application.Current.Dispatcher.BeginInvoke( addMethod, item );
}

...

b_subcollection.AddOnUI(new B());

此方法将立即返回（在项目实际添加到集合之前）然后在 UI 线程上，项目将被添加到集合中，每个人都应该很高兴。

然而，现实情况是，由于所有跨线程活动，该解决方案可能会在重负载下陷入困境。更有效的解决方案是将一堆项目分批并定期将它们发布到 UI 线程，这样您就不会为每个项目跨线程调用。

BackgroundWorker 类实现了一种模式，允许您在后台操作期间通过其ReportProgress 方法报告进度。通过 ProgressChanged 事件在 UI 线程上报告进度。这可能是您的另一种选择。

Answer 3

在 .NET 4.0 中，您可以使用这些单行代码：

.Add

Application.Current.Dispatcher.BeginInvoke(new Action(() => this.MyObservableCollection.Add(myItem)));

.Remove

Application.Current.Dispatcher.BeginInvoke(new Func<bool>(() => this.MyObservableCollection.Remove(myItem)));

Answer 4

为后代收集同步代码。这使用简单的锁定机制来启用集合同步。请注意，您必须在 UI 线程上启用集合同步。

public class MainVm
{
    private ObservableCollection<MiniVm> _collectionOfObjects;
    private readonly object _collectionOfObjectsSync = new object();

    public MainVm()
    {

        _collectionOfObjects = new ObservableCollection<MiniVm>();
        // Collection Sync should be enabled from the UI thread. Rest of the collection access can be done on any thread
        Application.Current.Dispatcher.BeginInvoke(new Action(() => 
        { BindingOperations.EnableCollectionSynchronization(_collectionOfObjects, _collectionOfObjectsSync); }));
    }

    /// <summary>
    /// A different thread can access the collection through this method
    /// </summary>
    /// <param name="newMiniVm">The new mini vm to add to observable collection</param>
    private void AddMiniVm(MiniVm newMiniVm)
    {
        lock (_collectionOfObjectsSync)
        {
            _collectionOfObjects.Insert(0, newMiniVm);
        }
    }
}

Answer 5

我使用了 SynchronizationContext：

SynchronizationContext SyncContext { get; set; }

//在构造函数中：

SyncContext = SynchronizationContext.Current;

//在Background Worker或Event Handler中：

SyncContext.Post(o =>
{
    ObservableCollection.AddRange(myData);
}, null);

Answer 6

@Jon 回答不错，但缺少代码示例：

// UI thread
var myCollection = new ObservableCollection<string>();
var lockObject = new object();
BindingOperations.EnableCollectionSynchronization(myCollection, lockObject );

[..]

// Non UI thread
lock (lockObject) 
{
   myCollection.Add("Foo")
}

另请注意，CollectionChanged 事件处理程序仍会从非 UI 线程调用。