是否有一个线程安全观察的集合在.NET 4？ [英] Is there a Threadsafe Observable collection in .NET 4?
问题描述
平台： WPF，.NET 4.0，C＃4.0
问题：在Mainwindow.xaml我有绑定到一个客户集合这是目前一个ObservableCollection℃的列表框;客户>。
Problem: In the Mainwindow.xaml i have a ListBox bound to a Customer collection which is currently an ObservableCollection< Customer >.
的ObservableCollection＆LT;客户＆GT; C =新的ObservableCollection＆LT;客户＆GT;（）;
此集合可以通过多种渠道进行更新，如文件系统，web服务等。
This collection can be updated via multiple sources, like FileSystem, WebService etc.
要允许客户并行加载我创建了一个辅助类
To allow parallel loading of Customers I have created a helper class
公共类的CustomerManager（REF ObsevableCollection＆LT;客户＆GT;卡斯特）
在内部生成一个新的任务（从并行扩展库）为每一个客户源，并增加了一个新的客户实例给客户的集合对象（由参传递给它的构造函数）。
that internally spawns a new Task (from Parallel extensions library) for each customer Source and adds a new Customer instance to the customer collection object (passed by ref to its ctor).
的问题是，的ObservableCollection＆所述; T>（或集合为此事）不能从电话不是UI线程等使用，并遇到了异常：
The problem is that ObservableCollection< T> (or any collection for that matter) cannot be used from calls other than the UI thread and an exception is encountered:
NotSupportedException异常 - 这种类型的CollectionView不支持从一个线程的调度线程不同改变其SourceCollection
"NotSupportedException – This type of CollectionView does not support changes to its SourceCollection from a thread different from the Dispatcher thread."
我尝试使用
System.Collections.Concurrent.ConcurrentBag＆LT;客户＆GT;
集合，但它亘古不变的实现INotifyCollectionChanged接口。因此，我的WPF UI将不会自动更新。
collection but it doesnot implement INotifyCollectionChanged interface. Hence my WPF UI won't get updated automatically.
那么，有没有同时实现性能/集更改通知集合类，并允许从其他非UI线程调用？
按我最初的冰/谷歌上搜索，有没有提供开箱即用的。
By my initial bing/googling, there is none provided out of the box.
编辑：我创建了自己的集合，它继承的 ConcurrentBag＆LT;客户> 的同时也实现了的 INotifyCollectionChanged 的接口。但让我吃惊，甚至调用它在不同的任务后，WPF UI挂起，直到任务完成。 不应该并行地执行，不会阻塞UI线程的任务
I created my own collection that inherits from ConcurrentBag< Customer > and also implements the INotifyCollectionChanged interface. But to my surprise even after invoking it in separate tasks, the WPF UI hangs until the task is completed. Aren't the tasks supposed to be executed in parallel and not block the UI thread?
感谢您的任何建议，事先。
Thanks for any suggestions, in advance.
推荐答案
有两种可能的方法。第一是从一个并发收集继承并添加INotifyCollectionChanged功能，第二个是从实现INotifyCollectionChanged集合继承和增加并发支持。我认为这是更容易，更安全添加INotifyCollectionChanged支持并发集合。我的建议如下。
There are two possible approaches. The first would be to inherit from a concurrent collection and add INotifyCollectionChanged functionality, and the second would be to inherit from a collection that implements INotifyCollectionChanged and add concurrency support. I think it is far easier and safer to add INotifyCollectionChanged support to a concurrent collection. My suggestion is below.
看起来很长，但大多数方法只是调用内部并发收集，如同来电者直接使用它。那添加或删除集合中注入一个调用引发对在施工中提供的调度通知事件私有方法的方法的极少数，因此允许类是线程安全的，但确保通知提出在同一线程上的所有时间。
It looks long but most of the methods just call the internal concurrent collection as if the caller were using it directly. The handful of methods that add or remove from the collection inject a call to a private method that raises the notification event on the dispatcher provided at construction, thus allowing the class to be thread safe but ensuring the notifications are raised on the same thread all the time.
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Windows.Threading;
namespace Collections
{
/// <summary>
/// Concurrent collection that emits change notifications on a dispatcher thread
/// </summary>
/// <typeparam name="T">The type of objects in the collection</typeparam>
[SerializableAttribute]
[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
public class ObservableConcurrentBag<T> : IProducerConsumerCollection<T>,
IEnumerable<T>, ICollection, IEnumerable
{
/// <summary>
/// The dispatcher on which event notifications will be raised
/// </summary>
private readonly Dispatcher dispatcher;
/// <summary>
/// The internal concurrent bag used for the 'heavy lifting' of the collection implementation
/// </summary>
private readonly ConcurrentBag<T> internalBag;
/// <summary>
/// Initializes a new instance of the ConcurrentBag<T> class that will raise <see cref="INotifyCollectionChanged"/> events
/// on the specified dispatcher
/// </summary>
public ObservableConcurrentBag(Dispatcher dispatcher)
{
this.dispatcher = dispatcher;
this.internalBag = new ConcurrentBag<T>();
}
/// <summary>
/// Initializes a new instance of the ConcurrentBag<T> class that contains elements copied from the specified collection
/// that will raise <see cref="INotifyCollectionChanged"/> events on the specified dispatcher
/// </summary>
public ObservableConcurrentBag(Dispatcher dispatcher, IEnumerable<T> collection)
{
this.dispatcher = dispatcher;
this.internalBag = new ConcurrentBag<T>(collection);
}
/// <summary>
/// Occurs when the collection changes
/// </summary>
public event NotifyCollectionChangedEventHandler CollectionChanged;
/// <summary>
/// Raises the <see cref="CollectionChanged"/> event on the <see cref="dispatcher"/>
/// </summary>
private void RaiseCollectionChangedEventOnDispatcher(NotifyCollectionChangedEventArgs e)
{
this.dispatcher.BeginInvoke(new Action<NotifyCollectionChangedEventArgs>(this.RaiseCollectionChangedEvent), e);
}
/// <summary>
/// Raises the <see cref="CollectionChanged"/> event
/// </summary>
/// <remarks>
/// This method must only be raised on the dispatcher - use <see cref="RaiseCollectionChangedEventOnDispatcher" />
/// to do this.
/// </remarks>
private void RaiseCollectionChangedEvent(NotifyCollectionChangedEventArgs e)
{
this.CollectionChanged(this, e);
}
#region Members that pass through to the internal concurrent bag but also raise change notifications
bool IProducerConsumerCollection<T>.TryAdd(T item)
{
bool result = ((IProducerConsumerCollection<T>)this.internalBag).TryAdd(item);
if (result)
{
this.RaiseCollectionChangedEventOnDispatcher(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
return result;
}
public void Add(T item)
{
this.internalBag.Add(item);
this.RaiseCollectionChangedEventOnDispatcher(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
public bool TryTake(out T item)
{
bool result = this.TryTake(out item);
if (result)
{
this.RaiseCollectionChangedEventOnDispatcher(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
}
return result;
}
#endregion
#region Members that pass through directly to the internal concurrent bag
public int Count
{
get
{
return this.internalBag.Count;
}
}
public bool IsEmpty
{
get
{
return this.internalBag.IsEmpty;
}
}
bool ICollection.IsSynchronized
{
get
{
return ((ICollection)this.internalBag).IsSynchronized;
}
}
object ICollection.SyncRoot
{
get
{
return ((ICollection)this.internalBag).SyncRoot;
}
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return ((IEnumerable<T>)this.internalBag).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable)this.internalBag).GetEnumerator();
}
public T[] ToArray()
{
return this.internalBag.ToArray();
}
void IProducerConsumerCollection<T>.CopyTo(T[] array, int index)
{
((IProducerConsumerCollection<T>)this.internalBag).CopyTo(array, index);
}
void ICollection.CopyTo(Array array, int index)
{
((ICollection)this.internalBag).CopyTo(array, index);
}
#endregion
}
}
这篇关于是否有一个线程安全观察的集合在.NET 4？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
