class/WindowsBase/System.Collections.ObjectModel/ObservableCollection.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2007 Novell, Inc. (http://www.novell.com)
  21 //
  22 // Authors:
  23 //      Chris Toshok (toshok@novell.com)
  24 //      Brian O'Keefe (zer0keefie@gmail.com)
  25 //
  26
  27 #if NET_4_0
  28
  29 using System.Collections.ObjectModel;
  30 using System.Runtime.CompilerServices;
  31 [assembly:TypeForwardedTo (typeof (ObservableCollection<>))]
  32
  33 #else
  34
  35 using System.Collections.Generic;
  36 using System.Collections.Specialized;
  37 using System.ComponentModel;
  38
  39 namespace System.Collections.ObjectModel {
  40         [Serializable]
  41         public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged {
  42
  43                 private class Reentrant : IDisposable {
  44                         private int count = 0;
  45
  46                         public Reentrant()
  47                         {
  48                         }
  49
  50                         public void Enter()
  51                         {
  52                                 count++;
  53                         }
  54
  55                         public void Dispose()
  56                         {
  57                                 count--;
  58                         }
  59
  60                         public bool Busy
  61                         {
  62                                 get { return count > 0; }
  63                         }
  64                 }
  65
  66                 private Reentrant reentrant = new Reentrant ();
  67
  68                 public ObservableCollection()
  69                 {
  70                 }
  71
  72                 public ObservableCollection(IEnumerable<T> collection)
  73                 {
  74                         throw new NotImplementedException ();
  75                 }
  76
  77                 public ObservableCollection(List<T> list)
  78                         : base (list)
  79                 {
  80                 }
  81
  82                 public virtual event NotifyCollectionChangedEventHandler CollectionChanged;
  83                 protected virtual event PropertyChangedEventHandler PropertyChanged;
  84
  85                 event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged {
  86                         add { this.PropertyChanged += value; }
  87                         remove { this.PropertyChanged -= value; }
  88                 }
  89
  90                 protected IDisposable BlockReentrancy ()
  91                 {
  92                         reentrant.Enter ();
  93                         return reentrant;
  94                 }
  95
  96                 protected void CheckReentrancy ()
  97                 {
  98                         NotifyCollectionChangedEventHandler eh = CollectionChanged;
  99
 100                         // Only have a problem if we have more than one event listener.
 101                         if (reentrant.Busy && eh != null && eh.GetInvocationList ().Length > 1)
 102                                 throw new InvalidOperationException ("Cannot modify the collection while reentrancy is blocked.");
 103                 }
 104
 105                 protected override void ClearItems ()
 106                 {
 107                         CheckReentrancy ();
 108
 109                         base.ClearItems ();
 110
 111                         OnCollectionChanged (new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Reset));
 112                         OnPropertyChanged (new PropertyChangedEventArgs ("Count"));
 113                         OnPropertyChanged (new PropertyChangedEventArgs ("Item[]"));
 114                 }
 115
 116                 protected override void InsertItem (int index, T item)
 117                 {
 118                         CheckReentrancy ();
 119
 120                         base.InsertItem (index, item);
 121
 122                         OnCollectionChanged (new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Add, item, index));
 123                         OnPropertyChanged (new PropertyChangedEventArgs ("Count"));
 124                         OnPropertyChanged (new PropertyChangedEventArgs ("Item[]"));
 125                 }
 126
 127                 public void Move (int oldIndex, int newIndex)
 128                 {
 129                         MoveItem (oldIndex, newIndex);
 130                 }
 131
 132                 protected virtual void MoveItem (int oldIndex, int newIndex)
 133                 {
 134                         CheckReentrancy ();
 135
 136                         T item = Items [oldIndex];
 137                         base.RemoveItem (oldIndex);
 138                         base.InsertItem (newIndex, item);
 139
 140                         OnCollectionChanged (new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Move, item, newIndex, oldIndex));
 141                         OnPropertyChanged (new PropertyChangedEventArgs ("Item[]"));
 142                 }
 143
 144                 protected virtual void OnCollectionChanged (NotifyCollectionChangedEventArgs e)
 145                 {
 146                         NotifyCollectionChangedEventHandler eh = CollectionChanged;
 147
 148                         if (eh != null) {
 149                                 // Make sure that the invocation is done before the collection changes,
 150                                 // Otherwise there's a chance of data corruption.
 151                                 using (BlockReentrancy ()) {
 152                                         eh (this, e);
 153                                 }
 154                         }
 155                 }
 156
 157                 protected virtual void OnPropertyChanged (PropertyChangedEventArgs e)
 158                 {
 159                         PropertyChangedEventHandler eh = PropertyChanged;
 160
 161                         if (eh != null)
 162                                 eh (this, e);
 163                 }
 164
 165                 protected override void RemoveItem (int index)
 166                 {
 167                         CheckReentrancy ();
 168
 169                         T item = Items [index];
 170
 171                         base.RemoveItem (index);
 172
 173                         OnCollectionChanged (new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Remove, item, index));
 174                         OnPropertyChanged (new PropertyChangedEventArgs ("Count"));
 175                         OnPropertyChanged (new PropertyChangedEventArgs ("Item[]"));
 176                 }
 177
 178                 protected override void SetItem (int index, T item)
 179                 {
 180                         CheckReentrancy ();
 181
 182                         T oldItem = Items [index];
 183
 184                         base.SetItem (index, item);
 185
 186                         OnCollectionChanged (new NotifyCollectionChangedEventArgs (NotifyCollectionChangedAction.Replace, item, oldItem, index));
 187                         OnPropertyChanged (new PropertyChangedEventArgs ("Item[]"));
 188                 }
 189         }
 190 }
 191 #endif