Pros and Cons of using Observable Collection over IEnumerable

Question

I am trying to decide if I want to switch all of my IEnumerable collections over to Observable Collections. I cannot find a good explanation of this. What are the Pros and Cons of the Observable Collection in understandable terms?

Answer 1

You may decide to have IEnumerable<Something> as type of some property, but use ObservableCollection<Something> as the actual value.

If you have a property like this:

private IEnumerable<Something> collectionOfSomething;
public IEnumerable<Something> CollectionOfSomething
{
    get { return collectionOfSomething; }
    set
    {
        collectionOfSomething = value;
        NotifyPropertyChanged("CollectionOfSomething");
    }
}

Now you may simply assign to that property like

someViewModelObject.CollectionOfSomething = new ObservableCollection<Something>();

---

When you assign or bind to a collection property (for example ItemsControl.ItemsSource ), the target object usually checks whether the actual property value implements INotifyCollectionChanged (what ObservableCollection does) and attaches a CollectionChanged handler to get notified about changes in the source collection.

If you later decide to have some other, smarter implementation of INotifyCollectionChanged you do not need to change all your property types. Just replace the assignment(s) by something like this

someViewModelObject.CollectionOfSomething = new MyVerySmartCollection<Something>();

Answer 2

I'd probably frame the answer to your question this way: Does your application need to be notified when your collections change content? If so, then such a change is possibly warranted. My understanding is that the overarching feature of Observable collections is that they provide a mechanism for notifications when the collection changes, whereas IEnumerable provides only a single-iteration enumerator.

I hope that helps.

Answer 3

The largest benefit to using ObservableCollection is it implements INotifyCollectionChanged and INotifyPropertyChanged, automatically, which makes it simpler to data-bind. I would say that it's better to use ObservableCollection when you are first setting up your data-bindings.

But now that you have already coded up (and data-bound?) a bunch of IEnumerables, there isn't any savings to be had, at this point.

Another thing to consider is that ObservableCollection<T> is an IEnumerable (Inherited from Collection<T> ). Since IEnumerable is an interface, it is implemented by many classes List<T> is one such class - ObservableCollection<T> is another.

Answer 4

The entire point of Observable collections is that they implement the following interfaces

 INotifyCollectionChanged, INotifyPropertyChanged 

This makes it very easy to alert the UI/ViewModel of changes and update accordingly. If you didn't use ObservableCollection you would be required to implement the updates to the collection/properties yourself manually.