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?

As a minor side note: Observables implement IEnumerable as well. They just have the added benefit that they can be set up to be monitored by the UI as well. — sircodesalot, Feb 12 '13 at 17:53
Closed? Respectfully disagree with that vote. This is perfectly within the scope of "I would like others to explain _______ to me" as noted in the FAQ, and identifies specific elements for which the OP is requesting explanation. There have been several good, detailed answers which I think demonstrate the "not constructive" closure is inappropriate. Voting to reopen. — David W, Feb 12 '13 at 18:38
Thank you @David W. I was a bit confused myself on why it was closed.. — JLott, Feb 12 '13 at 18:39
@JLott You're welcome. Don't know if it will help, but one has to try sometimes :) — David W, Feb 12 '13 at 18:40

Clemens · Accepted Answer · 2013-02-12T17:27:46.943

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

Hmmm this is actually really helpful.. I might mess around with it for a while. It might solve the problems that I have been having with the IEnumerable. Thanks!\ — JLott, Feb 12 '13 at 17:15

score 3 · Answer 2 · answered Feb 12 '13 at 17:09

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.

EtherDragon · Answer 3 · 2013-02-12T17:23:34.167

2

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.

edited Feb 12 '13 at 17:23

answered Feb 12 '13 at 17:10

EtherDragon

2,679
1
18
24

1

I like @Clemens example which shows in code the differences as far as data-binding is concerned. So, maybe all of your future additions to the project can benefit from `ObservableCollecion` – EtherDragon Feb 12 '13 at 17:12
I have not bounded them yet... I am having problems with that because I am having to use the value from another view, and the view I am working in cannot see that data. I heard that changing it to an observable collection could fix it, but I am still not entirely sure.. Here is a link to my previous question that led to this question... http://stackoverflow.com/questions/14836678/connect-data-in-two-classes-for-use-in-a-view/14836935#comment20791174_14836935 – JLott Feb 12 '13 at 17:13

score 1 · Answer 4 · answered Feb 12 '13 at 17:10

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.

Pros and Cons of using Observable Collection over IEnumerable

4 Answers4

Linked