Question

I have a backend Dictionary that is used for synchronization (ie. to both a filestore and a webservice).

Off the top of this I need to generate lists/enumerables for the WPF frontend to consume. What is the difference between either hooking an enumerable up to the dictionary, and calling PropertyChanged when it is updated to using an ObservableCollection and having it automatically called its CollectionChanged.

Synchronizing occurs in the background automatically, and some elements may be removed, others may be updated. I want to propagate this information to the WPF frontend and user smoothly. (ie. if one item is removed, the whole display shouldn’t have to be reinitialized). I also want to add animation when items are added and removed (ie. fade in and out) – is this possible if I replace the whole list or will it cause every single item to fade in again?

So should I:

1) use an observable collection and write some fancy synchronization logic between the dictionary and the collection?

2) use linq extension methods to convert the dictionary to an enumerable and simply call propertychanged on the enumerable whenever it changes?

3) synchronize between a dictionary and a list, by replacing the list whenever it is updated?

Also, how would any of these work with sorting and filtering operations that are performed just for the UI? (ie. if I need to filter some elements out of the dictionary based upon user selection, should I use a similar method as the one you have recommended?)

Answer 1

If you “replace” any IEnumerable<T> when you get a change, the entire list will be refreshed in the UI.

In order to avoid that, you’ll need to implement INotifyCollectionChanged, and provide a collection which implements this. Instead of replacing the collection, you handle the elements, which in turn fires the appropriate events.

ObservableCollection<T> handles this for you. Personally, if you need to keep this in a dictionary, but want to synchronize it to a list, you may want to consider making a custom collection, possibly based around SortedDictionary. A standard Dictionary has no sense of ordering, which means that there’d be no way to implement INotifyCollectionChanged appropriately.