这听起来像是multithreading的泡菜。 在这种事件链模式中使用递归是非常具有挑战性的，同时仍然避免死锁。 您可能想要考虑完全围绕问题进行设计。

例如，您可以使操作数的添加与事件的引发异步：

 private readonly BlockingCollection _additions = new BlockingCollection(); public void AddNewOperand(Operand operand) { _additions.Add(operand); } 

然后在后台线程中进行实际添加：

 private void ProcessAdditions() { foreach(var operand in _additions.GetConsumingEnumerable()) { _container.Lock.EnterWriteLock(); _container.Operands.Add(operand); _container.Lock.ExitWriteLock(); } } public void Initialize() { var pump = new Thread(ProcessAdditions) { Name = "Operand Additions Pump" }; pump.Start(); } 

这种分离牺牲了一些一致性 – 在add方法实际上不知道添加实际发生的时间之后运行的代码，这可能是您的代码的问题。 如果是这样，可以重写这个以订阅观察并使用Task在添加完成时发出信号：

 public Task AddNewOperandAsync(Operand operand) { var tcs = new TaskCompletionSource(); // Compose an event handler for the completion of this task NotifyCollectionChangedEventHandler onChanged = null; onChanged = (sender, e) => { // Is this the event for the operand we have added? if (e.NewItems.Contains(operand)) { // Complete the task. tcs.SetCompleted(0); // Remove the event-handler. _container.Operands.CollectionChanged -= onChanged; } } // Hook in the handler. _container.Operands.CollectionChanged += onChanged; // Perform the addition. _additions.Add(operand); // Return the task to be awaited. return tcs.Task; } 

事件处理程序逻辑在后台线程上引发添加消息，因此不可能阻塞前台线程。 如果等待窗口的消息泵上的添加，同步上下文足够智能，也可以在消息泵线程上安排继续。

无论您是否沿着Task路线前进，此策略意味着您可以安全地从可观察事件中添加更多操作数，而无需重新输入任何锁定。

我不确定这是否完全相同，但在处理相对少量的数据（2k-3k条目）时，我使用下面的代码来促进对绑定到UI的集合的跨线程读/写访问。 此代码最初在此处找到。

 public class BaseObservableCollection : ObservableCollection { // Constructors public BaseObservableCollection() : base() { } public BaseObservableCollection(IEnumerable items) : base(items) { } public BaseObservableCollection(List items) : base(items) { } // Evnet public override event NotifyCollectionChangedEventHandler CollectionChanged; // Event Handler protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { // Be nice - use BlockReentrancy like MSDN said using (BlockReentrancy()) { if (CollectionChanged != null) { // Walk thru invocation list foreach (NotifyCollectionChangedEventHandler handler in CollectionChanged.GetInvocationList()) { DispatcherObject dispatcherObject = handler.Target as DispatcherObject; // If the subscriber is a DispatcherObject and different thread if (dispatcherObject != null && dispatcherObject.CheckAccess() == false) { // Invoke handler in the target dispatcher's thread dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, this, e); } else { // Execute handler as is handler(this, e); } } } } } } 

我还使用下面的代码（inheritance自上面的代码）来支持在CollectionChanged中的项引发PropertyChanged时引发CollectionChanged事件。

 public class BaseViewableCollection : BaseObservableCollection where T : INotifyPropertyChanged { // Constructors public BaseViewableCollection() : base() { } public BaseViewableCollection(IEnumerable items) : base(items) { } public BaseViewableCollection(List items) : base(items) { } // Event Handlers private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e) { var arg = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, sender, sender); base.OnCollectionChanged(arg); } protected override void ClearItems() { foreach (T item in Items) { if (item != null) { item.PropertyChanged -= ItemPropertyChanged; } } base.ClearItems(); } protected override void InsertItem(int index, T item) { if (item != null) { item.PropertyChanged += ItemPropertyChanged; } base.InsertItem(index, item); } protected override void RemoveItem(int index) { if (Items[index] != null) { Items[index].PropertyChanged -= ItemPropertyChanged; } base.RemoveItem(index); } protected override void SetItem(int index, T item) { if (item != null) { item.PropertyChanged += ItemPropertyChanged; } base.SetItem(index, item); } } 

跨线程集合同步

将ListBox绑定放到ObservableCollection中 ，当数据发生更改时，更新ListBox，因为实现了INotifyCollectionChanged。 缺陷dell’ObservableCollection是数据只能由创建它的线程更改。

SynchronizedCollection没有multithreading的问题，但是没有更新ListBox，因为它没有实现INotifyCollectionChanged，即使你实现了INotifyCollectionChanged，CollectionChanged（this，e）也只能从创建它的线程中调用..所以它不起作用。

结论

– 如果你想要一个自动更新的单线程列表使用ObservableCollection

– 如果您想要一个未自动更新但multithreading的列表，请使用SynchronizedCollection

– 如果需要两者，请以这种方式使用Framework 4.5 ，BindingOperations.EnableCollectionSynchronization和ObservableCollection（）：

 / / Creates the lock object somewhere private static object _lock = new object () ; ... / / Enable the cross acces to this collection elsewhere BindingOperations.EnableCollectionSynchronization ( _persons , _lock ) 

完整示例 http：//10rem.net/blog/2012/01/20/wpf-45-cross-thread-collection-synchronization-redux

上述就是C#学习教程：可观察对象的同步机制分享的全部内容，如果对大家有所用处且需要了解更多关于C#学习教程，希望大家多多关注—计算机技术网(www.ctvol.com)!