Механизм синхронизации наблюдаемого объекта

Ответ 1

Это похоже на многопоточную рассол. Очень сложно работать с рекурсией в этой цепочке цепочек событий, в то же время избегая взаимоблокировок. Возможно, вы захотите рассмотреть проблему вокруг проблемы.

Например, вы можете сделать добавление операнда асинхронным к началу события:

private readonly BlockingCollection<Operand> _additions
    = new BlockingCollection<Operand>();

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<byte>();

    // 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 или нет, эта стратегия означает, что вы можете безопасно добавлять больше операндов из наблюдаемого события без повторного ввода каких-либо блокировок.

Ответ 2

Я не уверен, что это точно такая же проблема, но при работе с относительно небольшими объемами данных (записи 2k-3k) я использовал приведенный ниже код, чтобы облегчить доступ к перекрестному потоку для чтения/записи для коллекций, привязанных к UI, Этот код изначально нашел здесь.

public class BaseObservableCollection<T> : ObservableCollection<T>
{
  // Constructors
  public BaseObservableCollection() : base() { }
  public BaseObservableCollection(IEnumerable<T> items) : base(items) { }
  public BaseObservableCollection(List<T> 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 thread
            dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, this, e);
          }
          else
          {
            // Execute handler as is
            handler(this, e);
          }
        }
      }
    }
  }
}

Я также использовал приведенный ниже код (который наследуется от приведенного выше кода) для поддержки создания события CollectionChanged, когда элементы внутри коллекции поднимают PropertyChanged.

public class BaseViewableCollection<T> : BaseObservableCollection<T>
  where T : INotifyPropertyChanged
{
  // Constructors
  public BaseViewableCollection() : base() { }
  public BaseViewableCollection(IEnumerable<T> items) : base(items) { }
  public BaseViewableCollection(List<T> 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);
  }
}

Ответ 3

Синхронизация коллекции кросс-потоков

Привязка привязки ListBox к ObservableCollection, когда данные изменяются, вы обновляете ListBox, потому что INotifyCollectionChanged реализован. Дефект dell'ObservableCollection заключается в том, что данные могут быть изменены только потоком, который его создал.

SynchronizedCollection не имеет проблемы с Multi-Thread, но не обновляет ListBox, потому что он не реализован INotifyCollectionChanged, даже если вы реализуете INotifyCollectionChanged, CollectionChanged (this, e) можно вызвать только из потока, который его создал.. поэтому он не работает.

Заключение

-Если вы хотите, чтобы список, содержащий автономный монопоток, использовал ObservableCollection

-Если вы хотите, чтобы список не был аутентифицирован, но многопоточным, используйте 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