I want to know the difference between `ObservableCollection` and `BindingList` because I&#39;ve used both to notify for any add/delete change in Source, but I actually do not know when to prefer one over the other.

Why would I choose one of the following over the other?

    ObservableCollection&lt;Employee&gt; lstEmp = new ObservableCollection&lt;Employee&gt;();

or 

    BindingList&lt;Employee&gt; lstEmp = new BindingList&lt;Employee&gt;();

Difference between ObservableCollection and BindingList

What is the use of ObservableCollection  in .net?

What is the use of ObservableCollection in .net?

Does anyone know why this code doesn&#39;t work:

    public class CollectionViewModel : ViewModelBase {  
        public ObservableCollection&lt;EntityViewModel&gt; ContentList
        {
            get { return _contentList; }
            set 
            { 
                _contentList = value; 
                RaisePropertyChanged(&quot;ContentList&quot;); 
                //I want to be notified here when something changes..?
                //debugger doesn&#39;t stop here when IsRowChecked is toggled
            }
         }
    }

    public class EntityViewModel : ViewModelBase
    {

        private bool _isRowChecked;

        public bool IsRowChecked
        {
            get { return _isRowChecked; }
            set { _isRowChecked = value; RaisePropertyChanged(&quot;IsRowChecked&quot;); }
        }
    }

`ViewModelBase` containts everything for `RaisePropertyChanged` etc. and it&#39;s working for everything else except this problem..

ObservableCollection not noticing when Item in it changes (even with INotifyPropertyChanged)

I want to be able to add a range and get updated for the entire bulk.

I also want to be able to cancel the action before it&#39;s done (i.e. collection changing besides the &#39;changed&#39;).


----------
Related Q
[https://stackoverflow.com/questions/57020/which-net-collection-for-adding-multiple-objects-at-once-and-getting-notified][1]


  [1]: https://stackoverflow.com/questions/57020/which-net-collection-for-adding-multiple-objects-at-once-and-getting-notified

ObservableCollection Doesn&#39;t support AddRange method, so I get notified for each item added, besides what about INotifyCollectionChanging?

 I have a following class :

    [DataContract]
    public class Pair&lt;TKey, TValue&gt; : INotifyPropertyChanged, IDisposable
    {
        public Pair(TKey key, TValue value)
        {
            Key = key;
            Value = value;
        }

        #region Properties
        [DataMember]
        public TKey Key
        {
            get
            { return m_key; }
            set
            {
                m_key = value;
                OnPropertyChanged(&quot;Key&quot;);
            }
        }
        [DataMember]
        public TValue Value
        {
            get { return m_value; }
            set
            {
                m_value = value;
                OnPropertyChanged(&quot;Value&quot;);
            }
        }
        #endregion

        #region Fields
        private TKey m_key;
        private TValue m_value;
        #endregion

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string name)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(name));
            }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        { }

        #endregion
    }

Which I&#39;ve put in an ObservableCollection :

    ObservableCollection&lt;Pair&lt;ushort, string&gt;&gt; my_collection = 
        new ObservableCollection&lt;Pair&lt;ushort, string&gt;&gt;();

    my_collection.Add(new Pair(7, &quot;aaa&quot;));
    my_collection.Add(new Pair(3, &quot;xey&quot;));
    my_collection.Add(new Pair(6, &quot;fty&quot;));

Q : How do I sort it by key ?

How do I sort an observable collection?

I have something here that is really catching me off guard.

I have an ObservableCollection of T that is filled with items. I also have an event handler attached to the CollectionChanged event.

When you **Clear** the collection it causes an CollectionChanged event with e.Action set to NotifyCollectionChangedAction.Reset. Ok, that&#39;s normal. But what is weird is that neither e.OldItems or e.NewItems has anything in it. **I would expect e.OldItems to be filled with all items that were removed from the collection.**

Has anyone else seen this? And if so, how have they gotten around it?

Some background: I am using the CollectionChanged event to attach and detach from another event and thus if I don&#39;t get any items in e.OldItems ... I won&#39;t be able to detach from that event.

&lt;br&gt;

**CLARIFICATION:**
I do know that the documentation doesn&#39;t *outright* state that it has to behave this way. But for every other action, it is notifying me of what it has done. So, my assumption is that it would tell me ... in the case of Clear/Reset as well.

&lt;br&gt;

Below is the sample code if you wish to reproduce it yourself. First off the xaml:

    &lt;Window
        x:Class=&quot;ObservableCollection.Window1&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
        xmlns:x=&quot;http://schemas.microsoft.com/winfx/2006/xaml&quot;
        Title=&quot;Window1&quot;
        Height=&quot;300&quot;
        Width=&quot;300&quot;
    &gt;
        &lt;StackPanel&gt;
            &lt;Button x:Name=&quot;addButton&quot; Content=&quot;Add&quot; Width=&quot;100&quot; Height=&quot;25&quot; Margin=&quot;10&quot; Click=&quot;addButton_Click&quot;/&gt;
            &lt;Button x:Name=&quot;moveButton&quot; Content=&quot;Move&quot; Width=&quot;100&quot; Height=&quot;25&quot; Margin=&quot;10&quot; Click=&quot;moveButton_Click&quot;/&gt;
            &lt;Button x:Name=&quot;removeButton&quot; Content=&quot;Remove&quot; Width=&quot;100&quot; Height=&quot;25&quot; Margin=&quot;10&quot; Click=&quot;removeButton_Click&quot;/&gt;
            &lt;Button x:Name=&quot;replaceButton&quot; Content=&quot;Replace&quot; Width=&quot;100&quot; Height=&quot;25&quot; Margin=&quot;10&quot; Click=&quot;replaceButton_Click&quot;/&gt;
            &lt;Button x:Name=&quot;resetButton&quot; Content=&quot;Reset&quot; Width=&quot;100&quot; Height=&quot;25&quot; Margin=&quot;10&quot; Click=&quot;resetButton_Click&quot;/&gt;
        &lt;/StackPanel&gt;
    &lt;/Window&gt;


Next, the code behind:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;
    using System.Collections.ObjectModel;

    namespace ObservableCollection
    {
        /// &lt;summary&gt;
        /// Interaction logic for Window1.xaml
        /// &lt;/summary&gt;
        public partial class Window1 : Window
        {
            public Window1()
            {
                InitializeComponent();
                _integerObservableCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(_integerObservableCollection_CollectionChanged);
            }

            private void _integerObservableCollection_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
            {
                switch (e.Action)
                {
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                        break;
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Move:
                        break;
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                        break;
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Replace:
                        break;
                    case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
                        break;
                    default:
                        break;
                }
            }

            private void addButton_Click(object sender, RoutedEventArgs e)
            {
                _integerObservableCollection.Add(25);
            }

            private void moveButton_Click(object sender, RoutedEventArgs e)
            {
                _integerObservableCollection.Move(0, 19);
            }

            private void removeButton_Click(object sender, RoutedEventArgs e)
            {
                _integerObservableCollection.RemoveAt(0);
            }

            private void replaceButton_Click(object sender, RoutedEventArgs e)
            {
                _integerObservableCollection[0] = 50;
            }

            private void resetButton_Click(object sender, RoutedEventArgs e)
            {
                _integerObservableCollection.Clear();
            }

            private ObservableCollection&lt;int&gt; _integerObservableCollection = new ObservableCollection&lt;int&gt; { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
        }
    }


When Clearing an ObservableCollection, There are No Items in e.OldItems

I&#39;ve got an `ObservableCollection&lt;A&gt; a_collection;` The collection contains &#39;n&#39; items. Each item A looks like this:

    public class A : INotifyPropertyChanged
    {
 
        public ObservableCollection&lt;B&gt; b_subcollection;
        Thread m_worker;
    }

Basically, it&#39;s all wired up to a WPF listview + a details view control which shows the `b_subcollection` of the selected item in a separate listview (2-way bindings, updates on propertychanged etc.). 

The problem showed up for me when I started to implement threading. The entire idea was to have the whole `a_collection` use it&#39;s worker thread to &quot;do work&quot; and then update their respective `b_subcollections` and have the gui show the results in real time.

When I tried it , I got an exception saying that only the Dispatcher thread can modify an ObservableCollection, and work came to a halt.

Can anyone explain the problem, and how to get around it?


How do I update an ObservableCollection via a worker thread?

I am looking for Linq way (like RemoveAll method for List&lt;T&gt;) which can remove selected items from my ObservableCollection.

I am too new to create an extension method for myself. Is there any way I remove items from ObservableCollection passing a Lambda expression?

RemoveAll for ObservableCollections?

I have below `ObservableCollection&lt;string&gt;`. I need to **sort** this alphabetically.

    private ObservableCollection&lt;string&gt; _animals = new ObservableCollection&lt;string&gt;
    {
        &quot;Cat&quot;, &quot;Dog&quot;, &quot;Bear&quot;, &quot;Lion&quot;, &quot;Mouse&quot;,
        &quot;Horse&quot;, &quot;Rat&quot;, &quot;Elephant&quot;, &quot;Kangaroo&quot;, &quot;Lizard&quot;, 
        &quot;Snake&quot;, &quot;Frog&quot;, &quot;Fish&quot;, &quot;Butterfly&quot;, &quot;Human&quot;, 
        &quot;Cow&quot;, &quot;Bumble Bee&quot;
    };

I tried `_animals.OrderByDescending`. But I don&#39;t know how to use it correctly.

    _animals.OrderByDescending(a =&gt; a.&lt;what_is_here_?&gt;);

How can I do this?

Sort ObservableCollection&lt;string&gt; through C#

I&#39;ve seen lots of talk about this question but maybe I&#39;m just too much of a newbie to get it. If I have an observable collection that is a collection of &quot;PersonNames&quot; as in the msdn example ([http: //msdn.microsoft.com/en-us/library/ms748365.aspx][1]), I get updates to my View if a `PersonName` is added or removed, etc. I want to get an update to my View when I change a property in the `PersonName` as well. Like if I change the first name. I can implement `OnPropertyChanged` for each property and have this class derive from `INotifyPropertyChanged` and that seems to get called as expected. 

My question is, *how does the View get the updated data from the `ObservableCollection` as the property changed does not cause any event for the `ObservableCollection`?* 

This is probably something really simple but why I can&#39;t seem to find an example surprises me. Can anyone shed any light on this for me or have any pointers to examples I would greatly appreciate it. We have this scenario in multiple places in our current WPF app and are struggling with figuring it out.



  [1]: http://msdn.microsoft.com/en-us/library/ms748365.aspx

---

&quot;Generally, the code responsible for displaying the data adds a `PropertyChanged` event handler to each object currently displayed onscreen.&quot;

Could someone please give me an example of what this means? My View binds to my `ViewModel` which has a `ObservableCollection`. This collection is made up of a `RowViewModel` which has properties that support the `PropertiesChanged` event. But I can&#39;t figure out how to make the collection update itself so my view will be updated.



ObservableCollection and Item PropertyChanged

How does one convert an `ObservableCollection` to a `List` of the held objects?

Converting ObservableCollection to List?

I have `ObservableCollection&lt;T&gt;` collection, and I want to replace all elements with a new collection of elements, I could do:

    collection.Clear(); 

OR: 

    collection.ClearItems();

(BTW, what&#39;s the difference between these two methods?)

I could also use `foreach` to `collection.Add` one by one, but this will fire multiple times

Same when adding a collection of elements.

EDIT:

I found a good library here: [Enhanced ObservableCollection with ability to delay or disable notifications](http://www.codeproject.com/Articles/249311/Enhanced-ObservableCollection) but it seems that it does NOT support silverlight.

How to Avoid Firing ObservableCollection.CollectionChanged Multiple Times When Replacing All Elements Or Adding a Collection of Elements

I found on this link 

https://stackoverflow.com/questions/1427471/c-observablecollection-not-noticing-when-item-in-it-changes-even-with-inotify

some techniques to notify a Observablecollection that an item has changed. the TrulyObservableCollection in this link seems to be what i&#39;m looking for.


    public class TrulyObservableCollection&lt;T&gt; : ObservableCollection&lt;T&gt;
    where T : INotifyPropertyChanged
    {
        public TrulyObservableCollection()
        : base()
        {
            CollectionChanged += new NotifyCollectionChangedEventHandler(TrulyObservableCollection_CollectionChanged);
        }

        void TrulyObservableCollection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.NewItems != null)
            {
                foreach (Object item in e.NewItems)
                {
                    (item as INotifyPropertyChanged).PropertyChanged += new PropertyChangedEventHandler(item_PropertyChanged);
                }
            }
            if (e.OldItems != null)
            {
                foreach (Object item in e.OldItems)
                {
                    (item as INotifyPropertyChanged).PropertyChanged -= new PropertyChangedEventHandler(item_PropertyChanged);
                }
            }
        }

        void item_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            NotifyCollectionChangedEventArgs a = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
            OnCollectionChanged(a);
        }
    }

But when I try to use it, I don&#39;t get notifications on the collection. I&#39;m not sure how to correctly implement this in my C# Code:

XAML :

        &lt;DataGrid AutoGenerateColumns=&quot;False&quot; ItemsSource=&quot;{Binding MyItemsSource, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}&quot;&gt;
            &lt;DataGrid.Columns&gt;
                &lt;DataGridCheckBoxColumn Binding=&quot;{Binding MyProperty, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}&quot;/&gt;
            &lt;/DataGrid.Columns&gt;
        &lt;/DataGrid&gt;

ViewModel :

    public class MyViewModel : ViewModelBase
    {
        private TrulyObservableCollection&lt;MyType&gt; myItemsSource;
        public TrulyObservableCollection&lt;MyType&gt; MyItemsSource
        {
            get { return myItemsSource; }
            set 
            { 
                myItemsSource = value; 
                // Code to trig on item change...
                RaisePropertyChangedEvent(&quot;MyItemsSource&quot;);
            }
        }

        public MyViewModel()
        {
            MyItemsSource = new TrulyObservableCollection&lt;MyType&gt;()
            { 
                new MyType() { MyProperty = false },
                new MyType() { MyProperty = true },
                new MyType() { MyProperty = false }
            };
        }
    }

    public class MyType : ViewModelBase
    {
        private bool myProperty;
        public bool MyProperty
        {
            get { return myProperty; }
            set 
            {
                myProperty = value;
                RaisePropertyChangedEvent(&quot;MyProperty&quot;);
            }
        }
    }

    public class ViewModelBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void RaisePropertyChangedEvent(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChangedEventArgs e = new PropertyChangedEventArgs(propertyName);
                PropertyChanged(this, e);
            }
        }
    }


When i run the program, i have the 3 checkbox to false, true, false as in the property initialisation.
but when i change the state of one of the ckeckbox, the program go through item_PropertyChanged but never in MyItemsSource Property code.





Notify ObservableCollection when Item changes

I&#39;m using a an `ObservableCollection` with two `ICollectionView` for different filters.

One is for filtering messages by some type, and one is for counting checked messages.
As you can see message filter and message count works OK, but when I&#39;m un-checking the message disappear from the list (*the count is still working*).

BTW sorry for the long post, I wanted to include all relevant stuff.

**The XAML Code:**

    &lt;!-- Messages List --&gt;
    &lt;DockPanel Grid.Row=&quot;1&quot;
               Grid.Column=&quot;0&quot;
               Grid.ColumnSpan=&quot;3&quot;
               Height=&quot;500&quot;&gt;
      &lt;ListBox Name=&quot;listBoxZone&quot;
               ItemsSource=&quot;{Binding filteredMessageList}&quot;
               Background=&quot;Transparent&quot;
               BorderThickness=&quot;0&quot;&gt;
        &lt;ListBox.ItemTemplate&gt;
          &lt;DataTemplate&gt;
            &lt;CheckBox Name=&quot;CheckBoxZone&quot;
                      Content=&quot;{Binding text}&quot;
                      Tag=&quot;{Binding id}&quot;
                      Unchecked=&quot;CheckBoxZone_Unchecked&quot;
                      Foreground=&quot;WhiteSmoke&quot;
                      Margin=&quot;0,5,0,0&quot;
                      IsChecked=&quot;{Binding isChecked}&quot; /&gt;
          &lt;/DataTemplate&gt;
        &lt;/ListBox.ItemTemplate&gt;
      &lt;/ListBox&gt;
    &lt;/DockPanel&gt;
    &lt;Button Content=&quot;Test Add New&quot;
            Grid.Column=&quot;2&quot;
            Height=&quot;25&quot;
            HorizontalAlignment=&quot;Left&quot;
            Margin=&quot;34,2,0,0&quot;
            Click=&quot;button1_Click&quot; /&gt;
    &lt;Label Content=&quot;{Binding checkedMessageList.Count}&quot;
           Grid.Column=&quot;2&quot;
           Height=&quot;25&quot;
           Margin=&quot;147,2,373,0&quot;
           Width=&quot;20&quot;
           Foreground=&quot;white&quot; /&gt;

**Screenshot:**
![enter image description here][1]

**Code:**

    /* ViewModel Class */
    public class MainViewModel : INotifyPropertyChanged
    {

        // Constructor
        public MainViewModel()
        {
            #region filteredMessageList
            // connect the ObservableCollection to CollectionView
            _filteredMessageList = CollectionViewSource.GetDefaultView(messageList);
            // set filter 
            _filteredMessageList.Filter = delegate(object item)
            {
                MessageClass temp = item as MessageClass;

                if ( selectedFilter.Equals(AvailableFilters.All) )
                {
                    return true;
                }
                else
                {
                    return temp.filter.Equals(_selectedFilter);
                }
            };
            #endregion

            #region checkedMessageList
            // connect the ObservableCollection to CollectionView
            _checkedMessageList = CollectionViewSource.GetDefaultView(messageList);
            // set filter 
            _checkedMessageList.Filter = delegate(object item) { return (item as MessageClass).isChecked; };
            #endregion
        }

        // message List
        private ObservableCollection&lt;MessageClass&gt; _messageList =
                new ObservableCollection&lt;MessageClass&gt;();
        public ObservableCollection&lt;MessageClass&gt; messageList
        {
            get { return _messageList; }
            set { _messageList = value; }
        }

        // CollectionView (filtered messageList)
        private ICollectionView _filteredMessageList;
        public ICollectionView filteredMessageList
        {
            get { return _filteredMessageList; }
        }

        // CollectionView (filtered messageList)
        private ICollectionView _checkedMessageList;
        public ICollectionView checkedMessageList
        {
            get { return _checkedMessageList; }
        }

        // SelectedFilter property
        private AvailableFilters _selectedFilter = AvailableFilters.All; // Default is set to all
        public AvailableFilters selectedFilter
        {
            get { return _selectedFilter; }
            set
            {
                _selectedFilter = value;
                RaisePropertyChanged(&quot;selectedFilter&quot;);
                _filteredMessageList.Refresh(); // refresh list upon update
            }
        }

        // FilterList (Convert Enum To Collection)
        private List&lt;KeyValuePair&lt;string, AvailableFilters&gt;&gt; _AvailableFiltersList;
        public List&lt;KeyValuePair&lt;string, AvailableFilters&gt;&gt; AvailableFiltersList
        {
            get
            {
                /* Check if such list available, if not create for first use */
                if (_AvailableFiltersList == null)
                {
                    _AvailableFiltersList = new List&lt;KeyValuePair&lt;string, AvailableFilters&gt;&gt;();
                    foreach (AvailableFilters filter in Enum.GetValues(typeof(AvailableFilters)))
                    {
                        string Description;
                        FieldInfo fieldInfo = filter.GetType().GetField(filter.ToString());
                        DescriptionAttribute[] attributes =
                                    (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);

                        /* if not null get description */
                        if (attributes != null &amp;&amp; attributes.Length &gt; 0)
                        {
                            Description = attributes[0].Description;
                        }
                        else
                        {
                            Description = string.Empty;
                        }

                        /* add as new item to filterList */
                        KeyValuePair&lt;string, AvailableFilters&gt; TypeKeyValue =
                                    new KeyValuePair&lt;string, AvailableFilters&gt;(Description, filter);

                        _AvailableFiltersList.Add(TypeKeyValue);
                    }
                }
                return _AvailableFiltersList;
            }
        }

        #region Implement INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        public void RaisePropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
        #endregion
    }


**Code For un-check function**
        
    private void CheckBoxZone_Unchecked(object sender, RoutedEventArgs e)
    {
        CheckBox chkZone = (CheckBox)sender;
        ucSystemMessageVM.checkedMessageList.Refresh();
    }

  [1]: http://i.stack.imgur.com/cVYM6.gif

All Observablecollection Solutions on Gang of Coders

Total of 14 Observablecollection Solutions