Index: /trunk/sources/HeuristicLab.Collections/3.3/IObservableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/IObservableCollection.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/IObservableCollection.cs	(revision 2620)
@@ -24,7 +24,8 @@
 using System.Linq;
 using System.Text;
+using System.ComponentModel;
 
 namespace HeuristicLab.Collections {
-  public interface IObservableCollection<T> : ICollection<T> {
+  public interface IObservableCollection<T> : ICollection<T>, INotifyPropertyChanged {
     event CollectionItemsChangedEventHandler<T> ItemsAdded;
     event CollectionItemsChangedEventHandler<T> ItemsRemoved;
Index: /trunk/sources/HeuristicLab.Collections/3.3/IObservableDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/IObservableDictionary.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/IObservableDictionary.cs	(revision 2620)
@@ -24,7 +24,8 @@
 using System.Linq;
 using System.Text;
+using System.ComponentModel;
 
 namespace HeuristicLab.Collections {
-  public interface IObservableDictionary<TKey, TValue> : IDictionary<TKey, TValue> {
+  public interface IObservableDictionary<TKey, TValue> : IDictionary<TKey, TValue>, INotifyPropertyChanged {
     event CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>> ItemsAdded;
     event CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>> ItemsRemoved;
Index: /trunk/sources/HeuristicLab.Collections/3.3/IObservableKeyedCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/IObservableKeyedCollection.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/IObservableKeyedCollection.cs	(revision 2620)
@@ -24,7 +24,8 @@
 using System.Linq;
 using System.Text;
+using System.ComponentModel;
 
 namespace HeuristicLab.Collections {
-  public interface IObservableKeyedCollection<TKey, TItem> : ICollection<TItem> {
+  public interface IObservableKeyedCollection<TKey, TItem> : ICollection<TItem>, INotifyPropertyChanged {
     TItem this[TKey key] { get; }
 
Index: /trunk/sources/HeuristicLab.Collections/3.3/IObservableList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/IObservableList.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/IObservableList.cs	(revision 2620)
@@ -24,7 +24,8 @@
 using System.Linq;
 using System.Text;
+using System.ComponentModel;
 
 namespace HeuristicLab.Collections {
-  public interface IObservableList<T> : IList<T> {
+  public interface IObservableList<T> : IList<T>, INotifyPropertyChanged {
     event CollectionItemsChangedEventHandler<IndexedItem<T>> ItemsAdded;
     event CollectionItemsChangedEventHandler<IndexedItem<T>> ItemsRemoved;
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs	(revision 2620)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
@@ -37,5 +38,10 @@
     public int Capacity {
       get { return list.Capacity; }
-      set { list.Capacity = value; }
+      set {
+        if (list.Capacity != value) {
+          list.Capacity = value;
+          OnPropertyChanged("Capacity");
+        }
+      }
     }
     public int Count {
@@ -82,14 +88,26 @@
     #region Manipulation
     public void Add(T item) {
+      int capacity = list.Capacity;
       list.Add(item);
+      if (list.Capacity != capacity)
+        OnPropertyChanged("Capacity");
+      OnPropertyChanged("Count");
       OnItemsAdded(new T[] { item });
     }
     public void AddRange(IEnumerable<T> collection) {
+      int capacity = list.Capacity;
+      int count = list.Count;
       list.AddRange(collection);
-      OnItemsAdded(collection);
+      if (list.Count != count) {
+        if (list.Capacity != capacity)
+          OnPropertyChanged("Capacity");
+        OnPropertyChanged("Count");
+        OnItemsAdded(collection);
+      }
     }
 
     public bool Remove(T item) {
       if (list.Remove(item)) {
+        OnPropertyChanged("Count");
         OnItemsRemoved(new T[] { item });
         return true;
@@ -104,18 +122,27 @@
           items.Add(item);
       }
-      if (items.Count > 0)
+      if (items.Count > 0) {
+        OnPropertyChanged("Count");
         OnItemsRemoved(items);
+      }
     }
     public int RemoveAll(Predicate<T> match) {
       List<T> items = list.FindAll(match);
-      int result = list.RemoveAll(match);
-      OnItemsRemoved(items);
+      int result = 0;
+      if (items.Count > 0) {
+        result = list.RemoveAll(match);
+        OnPropertyChanged("Count");
+        OnItemsRemoved(items);
+      }
       return result;
     }
 
     public void Clear() {
-      T[] items = list.ToArray();
-      list.Clear();
-      OnCollectionReset(new T[0], items);
+      if (list.Count > 0) {
+        T[] items = list.ToArray();
+        list.Clear();
+        OnPropertyChanged("Count");
+        OnCollectionReset(new T[0], items);
+      }
     }
     #endregion
@@ -156,5 +183,8 @@
     #region Helpers
     public void TrimExcess() {
+      int capacity = list.Capacity;
       list.TrimExcess();
+      if (list.Capacity != capacity)
+        OnPropertyChanged("Capacity");
     }
     #endregion
@@ -181,4 +211,11 @@
         CollectionReset(this, new CollectionItemsChangedEventArgs<T>(items, oldItems));
     }
+
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs	(revision 2620)
@@ -23,8 +23,8 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Runtime.Serialization;
 
 namespace HeuristicLab.Collections {
@@ -110,8 +110,16 @@
     public void Add(TKey key, TValue value) {
       dict.Add(key, value);
+      OnPropertyChanged("Item[]");
+      OnPropertyChanged("Keys");
+      OnPropertyChanged("Values");
+      OnPropertyChanged("Count");
       OnItemsAdded(new KeyValuePair<TKey, TValue>[] { new KeyValuePair<TKey, TValue>(key, value) });
     }
     void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) {
       ((ICollection<KeyValuePair<TKey, TValue>>)dict).Add(item);
+      OnPropertyChanged("Item[]");
+      OnPropertyChanged("Keys");
+      OnPropertyChanged("Values");
+      OnPropertyChanged("Count");
       OnItemsAdded(new KeyValuePair<TKey, TValue>[] { item });
     }
@@ -121,4 +129,8 @@
       if (dict.TryGetValue(key, out value)) {
         dict.Remove(key);
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Keys");
+        OnPropertyChanged("Values");
+        OnPropertyChanged("Count");
         OnItemsRemoved(new KeyValuePair<TKey, TValue>[] { new KeyValuePair<TKey, TValue>(key, value) });
         return true;
@@ -128,4 +140,8 @@
     bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) {
       if (((ICollection<KeyValuePair<TKey, TValue>>)dict).Remove(item)) {
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Keys");
+        OnPropertyChanged("Values");
+        OnPropertyChanged("Count");
         OnItemsRemoved(new KeyValuePair<TKey, TValue>[] { item });
         return true;
@@ -135,7 +151,13 @@
 
     public void Clear() {
-      KeyValuePair<TKey, TValue>[] items = dict.ToArray();
-      dict.Clear();
-      OnCollectionReset(new KeyValuePair<TKey, TValue>[0], items);
+      if (dict.Count > 0) {
+        KeyValuePair<TKey, TValue>[] items = dict.ToArray();
+        dict.Clear();
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Keys");
+        OnPropertyChanged("Values");
+        OnPropertyChanged("Count");
+        OnCollectionReset(new KeyValuePair<TKey, TValue>[0], items);
+      }
     }
     #endregion
@@ -190,4 +212,11 @@
         CollectionReset(this, new CollectionItemsChangedEventArgs<KeyValuePair<TKey, TValue>>(items, oldItems));
     }
+
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableKeyedCollectionBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableKeyedCollectionBase.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableKeyedCollectionBase.cs	(revision 2620)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
@@ -93,7 +94,8 @@
         }
       }
-      if (!oldKeyFound) throw new ArgumentException("item not found");
+      if (!oldKeyFound) throw new ArgumentException("Item not found");
       dict.Remove(oldKey);
       dict.Add(GetKeyForItem(item), item);
+      OnPropertyChanged("Item[]");
       OnItemsReplaced(new TItem[] { item }, new TItem[] { item });
     }
@@ -139,11 +141,20 @@
     public void Add(TItem item) {
       dict.Add(GetKeyForItem(item), item);
+      OnPropertyChanged("Item[]");
+      OnPropertyChanged("Count");
       OnItemsAdded(new TItem[] { item });
     }
     public void AddRange(IEnumerable<TItem> collection) {
       if (collection == null) throw new ArgumentNullException();
-      foreach (TItem item in collection)
+      bool empty = true;
+      foreach (TItem item in collection) {
         dict.Add(GetKeyForItem(item), item);
-      OnItemsAdded(collection);
+        empty = false;
+      }
+      if (!empty) {
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnItemsAdded(collection);
+      }
     }
 
@@ -152,4 +163,6 @@
       if (TryGetValue(key, out item)) {
         dict.Remove(key);
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
         OnItemsRemoved(new TItem[] { item });
         return true;
@@ -159,4 +172,6 @@
     public bool Remove(TItem item) {
       if (dict.Remove(GetKeyForItem(item))) {
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
         OnItemsRemoved(new TItem[] { item });
         return true;
@@ -171,6 +186,9 @@
           items.Add(item);
       }
-      if (items.Count > 0)
+      if (items.Count > 0) {
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
         OnItemsRemoved(items);
+      }
     }
     public int RemoveAll(Predicate<TItem> match) {
@@ -181,7 +199,11 @@
 
     public void Clear() {
-      TItem[] items = dict.Values.ToArray();
-      dict.Clear();
-      OnCollectionReset(new TItem[0], items);
+      if (dict.Count > 0) {
+        TItem[] items = dict.Values.ToArray();
+        dict.Clear();
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnCollectionReset(new TItem[0], items);
+      }
     }
     #endregion
@@ -257,4 +279,11 @@
         CollectionReset(this, new CollectionItemsChangedEventArgs<TItem>(items, oldItems));
     }
+
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs	(revision 2620)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
@@ -37,5 +38,10 @@
     public int Capacity {
       get { return list.Capacity; }
-      set { list.Capacity = value; }
+      set {
+        if (list.Capacity != value) {
+          list.Capacity = value;
+          OnPropertyChanged("Capacity");
+        }
+      }
     }
     public int Count {
@@ -52,6 +58,9 @@
       set {
         T item = list[index];
-        list[index] = value;
-        OnItemsReplaced(new IndexedItem<T>[] { new IndexedItem<T>(index, value) }, new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
+        if (!item.Equals(value)) {
+          list[index] = value;
+          OnItemsReplaced(new IndexedItem<T>[] { new IndexedItem<T>(index, value) }, new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
+          OnPropertyChanged("Item[]");
+        }
       }
     }
@@ -147,8 +156,14 @@
     #region Manipulation
     public void Add(T item) {
+      int capacity = list.Capacity;
       list.Add(item);
+      if (list.Capacity != capacity)
+        OnPropertyChanged("Capacity");
+      OnPropertyChanged("Item[]");
+      OnPropertyChanged("Count");
       OnItemsAdded(new IndexedItem<T>[] { new IndexedItem<T>(list.Count - 1, item) });
     }
     public void AddRange(IEnumerable<T> collection) {
+      int capacity = list.Capacity;
       int index = list.Count;
       list.AddRange(collection);
@@ -158,12 +173,24 @@
         index++;
       }
-      OnItemsAdded(items);
+      if (items.Count > 0) {
+        if (list.Capacity != capacity)
+          OnPropertyChanged("Capacity");
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnItemsAdded(items);
+      }
     }
 
     public void Insert(int index, T item) {
+      int capacity = list.Capacity;
       list.Insert(index, item);
+      if (list.Capacity != capacity)
+        OnPropertyChanged("Capacity");
+      OnPropertyChanged("Item[]");
+      OnPropertyChanged("Count");
       OnItemsAdded(new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
     }
     public void InsertRange(int index, IEnumerable<T> collection) {
+      int capacity = list.Capacity;
       list.InsertRange(index, collection);
       List<IndexedItem<T>> items = new List<IndexedItem<T>>();
@@ -172,5 +199,11 @@
         index++;
       }
-      OnItemsAdded(items);
+      if (items.Count > 0) {
+        if (list.Capacity != capacity)
+          OnPropertyChanged("Capacity");
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnItemsAdded(items);
+      }
     }
 
@@ -179,4 +212,6 @@
       if (index != -1) {
         list.RemoveAt(index);
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
         OnItemsRemoved(new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
         return true;
@@ -191,6 +226,11 @@
           items.Add(new IndexedItem<T>(i, list[i]));
       }
-      int result = list.RemoveAll(match);
-      OnItemsRemoved(items);
+      int result = 0;
+      if (items.Count > 0) {
+        result = list.RemoveAll(match);
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnItemsRemoved(items);
+      }
       return result;
     }
@@ -198,48 +238,76 @@
       T item = list[index];
       list.RemoveAt(index);
+      OnPropertyChanged("Item[]");
+      OnPropertyChanged("Count");
       OnItemsRemoved(new IndexedItem<T>[] { new IndexedItem<T>(index, item) });
     }
     public void RemoveRange(int index, int count) {
-      IndexedItem<T>[] items = GetIndexedItems(index, count);
-      list.RemoveRange(index, count);
-      OnItemsRemoved(items);
+      if (count > 0) {
+        IndexedItem<T>[] items = GetIndexedItems(index, count);
+        list.RemoveRange(index, count);
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnItemsRemoved(items);
+      }
     }
 
     public void Clear() {
-      IndexedItem<T>[] items = GetIndexedItems();
-      list.Clear();
-      OnCollectionReset(new IndexedItem<T>[0], items);
+      if (list.Count > 0) {
+        IndexedItem<T>[] items = GetIndexedItems();
+        list.Clear();
+        OnPropertyChanged("Item[]");
+        OnPropertyChanged("Count");
+        OnCollectionReset(new IndexedItem<T>[0], items);
+      }
     }
 
     public void Reverse() {
-      IndexedItem<T>[] oldItems = GetIndexedItems();
-      list.Reverse();
-      OnItemsMoved(GetIndexedItems(), oldItems);
+      if (list.Count > 1) {
+        IndexedItem<T>[] oldItems = GetIndexedItems();
+        list.Reverse();
+        OnPropertyChanged("Item[]");
+        OnItemsMoved(GetIndexedItems(), oldItems);
+      }
     }
     public void Reverse(int index, int count) {
-      IndexedItem<T>[] oldItems = GetIndexedItems(index, count);
-      list.Reverse(index, count);
-      OnItemsMoved(GetIndexedItems(index, count), oldItems);
+      if (count > 1) {
+        IndexedItem<T>[] oldItems = GetIndexedItems(index, count);
+        list.Reverse(index, count);
+        OnPropertyChanged("Item[]");
+        OnItemsMoved(GetIndexedItems(index, count), oldItems);
+      }
     }
 
     public void Sort() {
-      IndexedItem<T>[] oldItems = GetIndexedItems();
-      list.Sort();
-      OnItemsMoved(GetIndexedItems(), oldItems);
+      if (list.Count > 1) {
+        IndexedItem<T>[] oldItems = GetIndexedItems();
+        list.Sort();
+        OnPropertyChanged("Item[]");
+        OnItemsMoved(GetIndexedItems(), oldItems);
+      }
     }
     public void Sort(Comparison<T> comparison) {
-      IndexedItem<T>[] oldItems = GetIndexedItems();
-      list.Sort(comparison);
-      OnItemsMoved(GetIndexedItems(), oldItems);
+      if (list.Count > 1) {
+        IndexedItem<T>[] oldItems = GetIndexedItems();
+        list.Sort(comparison);
+        OnPropertyChanged("Item[]");
+        OnItemsMoved(GetIndexedItems(), oldItems);
+      }
     }
     public void Sort(IComparer<T> comparer) {
-      IndexedItem<T>[] oldItems = GetIndexedItems();
-      list.Sort(comparer);
-      OnItemsMoved(GetIndexedItems(), oldItems);
+      if (list.Count > 1) {
+        IndexedItem<T>[] oldItems = GetIndexedItems();
+        list.Sort(comparer);
+        OnPropertyChanged("Item[]");
+        OnItemsMoved(GetIndexedItems(), oldItems);
+      }
     }
     public void Sort(int index, int count, IComparer<T> comparer) {
-      IndexedItem<T>[] oldItems = GetIndexedItems(index, count);
-      list.Sort(index, count, comparer);
-      OnItemsMoved(GetIndexedItems(index, count), oldItems);
+      if (list.Count > 1) {
+        IndexedItem<T>[] oldItems = GetIndexedItems(index, count);
+        list.Sort(index, count, comparer);
+        OnPropertyChanged("Item[]");
+        OnItemsMoved(GetIndexedItems(index, count), oldItems);
+      }
     }
     #endregion
@@ -283,5 +351,8 @@
     #region Helpers
     public void TrimExcess() {
+      int capacity = list.Capacity;
       list.TrimExcess();
+      if (list.Capacity != capacity)
+        OnPropertyChanged("Capacity");
     }
     #endregion
@@ -321,4 +392,11 @@
       if (CollectionReset != null)
         CollectionReset(this, new CollectionItemsChangedEventArgs<IndexedItem<T>>(items, oldItems));
+    }
+
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     }
     #endregion
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableCollection.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableCollection.cs	(revision 2620)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
@@ -50,4 +51,5 @@
       collection.ItemsRemoved += new CollectionItemsChangedEventHandler<T>(collection_ItemsRemoved);
       collection.CollectionReset += new CollectionItemsChangedEventHandler<T>(collection_CollectionReset);
+      collection.PropertyChanged += new PropertyChangedEventHandler(collection_PropertyChanged);
     }
     #endregion
@@ -110,4 +112,11 @@
     }
 
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
+
     private void collection_ItemsAdded(object sender, CollectionItemsChangedEventArgs<T> e) {
       OnItemsAdded(e.Items);
@@ -119,4 +128,8 @@
       OnCollectionReset(e.Items, e.OldItems);
     }
+    private void collection_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      if (e.PropertyName.Equals("Count"))
+        OnPropertyChanged(e.PropertyName);
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableDictionary.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableDictionary.cs	(revision 2620)
@@ -23,8 +23,8 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Runtime.Serialization;
 
 namespace HeuristicLab.Collections {
@@ -65,4 +65,5 @@
       dict.ItemsReplaced += new CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>>(dict_ItemsReplaced);
       dict.CollectionReset += new CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>>(dict_CollectionReset);
+      dict.PropertyChanged += new PropertyChangedEventHandler(dict_PropertyChanged);
     }
     #endregion
@@ -145,4 +146,11 @@
     }
 
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
+
     private void dict_ItemsAdded(object sender, CollectionItemsChangedEventArgs<KeyValuePair<TKey, TValue>> e) {
       OnItemsAdded(e.Items);
@@ -157,4 +165,8 @@
       OnCollectionReset(e.Items, e.OldItems);
     }
+    private void dict_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      if (e.PropertyName.Equals("Item[]") || e.PropertyName.Equals("Keys") || e.PropertyName.Equals("Values") || e.PropertyName.Equals("Count"))
+        OnPropertyChanged(e.PropertyName);
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableKeyedCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableKeyedCollection.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableKeyedCollection.cs	(revision 2620)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
@@ -57,4 +58,5 @@
       collection.ItemsReplaced += new CollectionItemsChangedEventHandler<TItem>(collection_ItemsReplaced);
       collection.CollectionReset += new CollectionItemsChangedEventHandler<TItem>(collection_CollectionReset);
+      collection.PropertyChanged += new PropertyChangedEventHandler(collection_PropertyChanged);
     }
     #endregion
@@ -131,4 +133,11 @@
     }
 
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
+
     private void collection_ItemsAdded(object sender, CollectionItemsChangedEventArgs<TItem> e) {
       OnItemsAdded(e.Items);
@@ -143,4 +152,8 @@
       OnCollectionReset(e.Items, e.OldItems);
     }
+    private void collection_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      if (e.PropertyName.Equals("Item[]") || e.PropertyName.Equals("Count"))
+        OnPropertyChanged(e.PropertyName);
+    }
     #endregion
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableList.cs	(revision 2619)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableList.cs	(revision 2620)
@@ -24,4 +24,5 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
@@ -60,4 +61,5 @@
       list.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_ItemsMoved);
       list.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_CollectionReset);
+      list.PropertyChanged += new PropertyChangedEventHandler(list_PropertyChanged);
     }
     #endregion
@@ -145,4 +147,11 @@
     }
 
+    [field: NonSerialized]
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      if (PropertyChanged != null)
+        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+    }
+
     private void list_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<T>> e) {
       OnItemsAdded(e.Items);
@@ -160,4 +169,8 @@
       OnCollectionReset(e.Items, e.OldItems);
     }
+    private void list_PropertyChanged(object sender, PropertyChangedEventArgs e) {
+      if (e.PropertyName.Equals("Item[]") || e.PropertyName.Equals("Count"))
+        OnPropertyChanged(e.PropertyName);
+    }
     #endregion
   }
