After reading several tutorials, snippets (seems either source or almost 1:1 copy of @Xcalibur37's blog post) & of course their "originating" questions on SO, I'm not only still confused about cross-thread access, but also struggling to get my WPF application to correctly perform binding updates upon CollectionChanged - which works upon launch & delete, but not for inserting copies.
SO is all about code, so let's get straight to it - both collections first, then VM, "works" & "fails":
Synchronized ObservableCollection<T> class:
public class SynchronizedCollection<T> : ObservableCollection<T> where T : class
{
// AFAICT, event overriding is needed, yet my app behaves the same without it?!
public override event NotifyCollectionChangedEventHandler CollectionChanged;
public SynchronizedCollection()
{
// Implemented this in my base-ViewModel's ctor first, but
// a) read somewhere that it's supposed to be done here instead
// b) call in base-VM resulted in 1 invocation per collection, though for _all_ VM at once!
BindingOperations.CollectionRegistering += (sender, eventArgs) =>
{
if (eventArgs.Collection.Equals(this)) // R# suggested, Equals() is wiser than == here.
{
BindingOperations.EnableCollectionSynchronization(this, SynchronizationLock);
}
};
}
// Can't be static due to class type parameter, but readonly should do.
// Also, since EnableCollectionSynchronization() is called in ctor, 1 lock object per collection.
private object SynchronizationLock { get; } = new object();
protected override void InsertItem(int index, T item)
{
lock (SynchronizationLock)
{
base.InsertItem(index, item);
}
}
// Named InsertItems instead of AddRange for consistency.
public void InsertItems(IEnumerable<T> items)
{
var list = items as IList<T> ?? items.ToList();
int start = Count;
foreach (T item in list)
{
lock (SynchronizationLock)
{
Items.Add(item);
}
}
// Multi-insert, but notify only once after completion.
OnPropertyChanged(new PropertyChangedEventArgs(nameof(Count)));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, list, start));
}
// Code left out for brevity...
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs eventArgs)
{
lock (SynchronizationLock)
{
if (!(CollectionChanged is NotifyCollectionChangedEventHandler eventHandler))
{
return;
}
foreach (Delegate @delegate in eventHandler.GetInvocationList())
{
var handler = (NotifyCollectionChangedEventHandler)@delegate;
if (handler.Target is DispatcherObject current && !current.CheckAccess())
{
current.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, this, eventArgs);
}
else
{
handler(this, eventArgs);
}
}
}
}
}
INotifyPropertyChanged support for above's SynchronizedCollection items:
public class NotifySynchronizedCollection<T> : SynchronizedCollection<T>, INotifySynchronizedCollection
where T : class
{
public event CollectionItemPropertyChangedEventHandler CollectionItemPropertyChanged;
// Code left out for brevity...
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs eventArgs)
{
// Seems to me like lock() isn't needed here...
//lock (SynchronizationLock)
//{
switch (eventArgs.Action)
{
case NotifyCollectionChangedAction.Add:
RegisterItemPropertyChanged(eventArgs.NewItems);
break;
case NotifyCollectionChangedAction.Remove:
case NotifyCollectionChangedAction.Reset when !(eventArgs.OldItems is null):
UnregisterItemPropertyChanged(eventArgs.OldItems);
break;
case NotifyCollectionChangedAction.Move:
case NotifyCollectionChangedAction.Replace:
UnregisterItemPropertyChanged(eventArgs.OldItems);
RegisterItemPropertyChanged(eventArgs.NewItems);
break;
}
//}
}
private void OnItemPropertyChanged(object item, PropertyChangedEventArgs itemArgs) =>
CollectionItemPropertyChanged?.Invoke(this, item, itemArgs);
private void RegisterItemPropertyChanged(IEnumerable items)
{
foreach (INotifyPropertyChanged item in items)
{
if (item != null)
{
item.PropertyChanged += OnItemPropertyChanged;
}
}
}
private void UnregisterItemPropertyChanged(IEnumerable items)
{
foreach (INotifyPropertyChanged item in items)
{
if (item != null)
{
item.PropertyChanged -= OnItemPropertyChanged;
}
}
}
}
One of many ViewModels (uses AsyncAwaitBestPractices.MVVM's IAsyncCommand):
public class OrdersViewModel : BaseViewModel
{
// BindingOperations.EnableCollectionSynchronization was once in BaseViewModel's ctor (with
// mentioned side-effects at this question's intro) & even right in this VM's ctor - none of
// the tutorials I've found mentioned a solution for tedious EnableCollectionSynchronization
// calls for each collection, in each VM, hence I tried CollectionRegistering in base-VM...
// Code left out for brevity...
public OrdersViewModel(INavigationService navService, IOrderDataService dataService)
: base(navService)
{
DataService = dataService;
RegisterMessages();
}
// Code left out for brevity...
// Note: This works, except for the view which doesn't show the newly added item!
// However, another TextBlock-binding for Orders.Count _does_ update?!
// Using ConfigureAwait(true) inside instead didn't help either...
public IAsyncCommand<OrderModel> CopyCommand =>
_copy ?? (_copy = new AsyncRelayCommand<OrderModel>(
async original =>
{
if (!await ShowConfirmation("Copy this order?").ConfigureAwait(false))
{
return;
}
if (original.ProductId < 1)
{
throw new ArgumentOutOfRangeException(
nameof(original.ProductId),
original.ProductId,
@"Valid product missing.");
}
await AddOrder(
await DataService.CreateOrderCopy(original.Id).ConfigureAwait(false)
?? throw new ArgumentNullException(nameof(original.Id), $@"Copying failed."))
.ConfigureAwait(false);
},
original => original.Id > 0,
async exception => await ShowError("Copying", exception).ConfigureAwait(false)));
// Note: This works!
public IAsyncCommand<OrderModel> Delete =>
_delete ?? (_delete = new AsyncCommand<OrderModel>(
async deletable =>
{
bool isChild = deletable.ParentId > 0;
if (!await ShowConfirmation($"Delete this order?").ConfigureAwait(false))
{
return;
}
await DataService.DeleteOrder(deletable.Id).ConfigureAwait(false);
if (isChild)
{
await RefreshParent(Orders.Single(order => order.Id == deletable.ParentId))
.ConfigureAwait(false);
}
Orders.Remove(deletable);
await ShowInfo($"Order deleted.").ConfigureAwait(false);
},
deletable => (deletable.ParentId > 0)
|| (Orders.SingleOrDefault(order => order.Id == deletable.Id)
?.ChildrenCount < 1),
async exception => await ShowError("Deletion", exception).ConfigureAwait(false)));
private async Task AddOrder(int orderId)
{
// Note: Using ConfigureAwait(true) doesn't help either.
// But while
Orders.Add(await GetOrder(orderId, false).ConfigureAwait(false));
}
// Code left out for brevity...
private void RegisterMessages()
{
Default.Register<OrdersInitializeMessage>(this, async message =>
{
Orders.Clear();
Task<CustomerModel> customerTask = DataService.GetCustomer(message.CustomerId);
Task<List<OrderModel>> ordersTask = DataService.GetOrders(message.OrderId);
await Task.WhenAll(customerTask, ordersTask).ConfigureAwait(false);
Customer = await customerTask.ConfigureAwait(false) ?? Customer;
(await ordersTask.ConfigureAwait(false)).ForEach(Orders.Add); // NOTE: This works!
SelectedOrder =
Orders.Count == 1
? Orders[0]
: Orders.SingleOrDefault(order => order.Id == message.OrderId);
});
// Code left out for brevity...
}
}
Why do both the Delete command and Orders.Add() (inside RegisterMessages()) work, while the Copy command's Orders.Add() call doesn't?
The Delete command uses Orders.Remove(deletable); which in turn calls my overridden RemoveItem in SynchronizedCollection<T> which is implemented just like above's InsertItem)
