wasSharp – Diff between revs 44 and 54

Subversion Repositories:

?pathlinks?

Rev 44 – Details – Blame – Last modification – View Log

 ï»¿///////////////////////////////////////////////////////////////////////////
 //  Copyright (C) Wizardry and Steamworks 2016 - License: GNU GPLv3      //
 //  Please see: http://www.gnu.org/licenses/gpl.html for legal details,  //
 //  rights of fair usage, the disclaimer and warranty conditions.        //
 ///////////////////////////////////////////////////////////////////////////
+/// From https://gist.github.com/kzu/cfe3cb6e4fe3efea6d24
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Dynamic;
+using System.Linq;
-using System.Collections.Specialized;
+using System.Text;
-using System.Threading;
+using System.Threading.Tasks;
-namespace wasSharp.Collections.Specialized
-{
-    ///////////////////////////////////////////////////////////////////////////
-    //    Copyright (C) 2016 Wizardry and Steamworks - License: GNU GPLv3    //
+namespace wasSharp.Collections.Specialized
-    ///////////////////////////////////////////////////////////////////////////
+{
     /// <summary>
-    ///     An implementation of an observable Dictionary.
+    /// Provides a dictionary for use with data binding.
     /// </summary>
+    /// <typeparam name="TKey">Specifies the type of the keys in this collection.</typeparam>
-    /// <typeparam name="K">the key type</typeparam>
+    /// <typeparam name="TValue">Specifies the type of the values in this collection.</typeparam>
+    [DebuggerDisplay("Count={Count}")]
+    public class ObservableDictionary<TKey, TValue> :
-    /// <typeparam name="V">the value type</typeparam>
+        ICollection<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue>,
-    public class ObservableDictionary<K, V> : IDictionary<K, V>, INotifyCollectionChanged
-    {
+        INotifyCollectionChanged, INotifyPropertyChanged
+    {
-        private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+        readonly IDictionary<TKey, TValue> dictionary;
-        private readonly Dictionary<K, V> store = new Dictionary<K, V>();
-        public bool IsVirgin { get; private set; } = true;
-        public V this[K key]
-        {
-            get
-            {
-                _lock.EnterReadLock();
-                try
-                {
-                    return store[key];
+        /// <summary>Event raised when the collection changes.</summary>
-                }
-                finally
-                {
+        public event NotifyCollectionChangedEventHandler CollectionChanged = (sender, args) => { };
-                    if (_lock.IsReadLockHeld) _lock.ExitReadLock();
-                }
-            }
+        /// <summary>Event raised when a property on the collection changes.</summary>
-            set
+        public event PropertyChangedEventHandler PropertyChanged = (sender, args) => { };
-            {
-                _lock.EnterWriteLock();
-                try
+        /// <summary>
-                {
-                    store[key] = value;
         /// Initializes an instance of the class.
-                finally
-                {
-                    if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
-                }
-            }
-        }
-        public int Count => store.Count;
+        /// </summary>
-        public bool IsReadOnly => false;
+        public ObservableDictionary()
+            : this(new Dictionary<TKey, TValue>())
-        public ICollection<K> Keys
+        {
-        {
+        }
-            get
-            {
                 _lock.EnterReadLock();
-                try
+        /// <summary>
-                {
-                    return store.Keys;
         /// Initializes an instance of the class using another dictionary as
-                finally
+        /// the key/value store.
         /// </summary>
-                    if (_lock.IsReadLockHeld) _lock.ExitReadLock();
-                }
-            }
-        }
-        public ICollection<V> Values
+        public ObservableDictionary(IDictionary<TKey, TValue> dictionary)
-        {
-            get
-            {
-                _lock.EnterReadLock();
-                try
-                {
                     return store.Values;
-                }
+            this.dictionary = dictionary;
-                finally
-                {
-                    if (_lock.IsReadLockHeld) _lock.ExitReadLock();
+        }
-            }
-        }
+        void AddWithNotification(KeyValuePair<TKey, TValue> item)
+        {
-        public void Add(KeyValuePair<K, V> item)
+            AddWithNotification(item.Key, item.Value);
-        {
+        }
-            _lock.EnterWriteLock();
-            try
-            {
+        void AddWithNotification(TKey key, TValue value)
                 ((IDictionary<K, V>) store).Add(item);
-            }
+            dictionary.Add(key, value);
-            finally
-            {
-                if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
-            IsVirgin = false;
+            CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add,
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
-        }
+                new KeyValuePair<TKey, TValue>(key, value)));
             PropertyChanged(this, new PropertyChangedEventArgs("Count"));
+            PropertyChanged(this, new PropertyChangedEventArgs("Keys"));
-        public void Add(K key, V value)
+            PropertyChanged(this, new PropertyChangedEventArgs("Values"));
+        }
+        bool RemoveWithNotification(TKey key)
+        {
+            TValue value;
             if (dictionary.TryGetValue(key, out value) && dictionary.Remove(key))
+            {
-            _lock.EnterWriteLock();
+                CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove,
-            try
-            {
-                store.Add(key, value);
+                    new KeyValuePair<TKey, TValue>(key, value)));
                 PropertyChanged(this, new PropertyChangedEventArgs("Count"));
-            finally
+                PropertyChanged(this, new PropertyChangedEventArgs("Keys"));
-            {
-                if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
-            }
-            IsVirgin = false;
+                PropertyChanged(this, new PropertyChangedEventArgs("Values"));
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add,
-                new KeyValuePair<K, V>(key, value)));
-        }
+                return true;
-        public void Clear()
-        {
+            }
-            _lock.EnterWriteLock();
-            try
+            return false;
+        }
-                store.Clear();
         public void Clear()
-            finally
+        {
-            {
+            dictionary.Clear();
                 if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
+            CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            PropertyChanged(this, new PropertyChangedEventArgs("Count"));
+            PropertyChanged(this, new PropertyChangedEventArgs("Keys"));
+            PropertyChanged(this, new PropertyChangedEventArgs("Values"));
-            }
+        }
-            if (!IsVirgin)
+        void UpdateWithNotification(TKey key, TValue value)
-                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+        {
-            IsVirgin = false;
+            TValue existing;
-        }
+            if (dictionary.TryGetValue(key, out existing))
+            {
-        public bool Contains(KeyValuePair<K, V> item)
+                dictionary[key] = value;
-        {
-            _lock.EnterReadLock();
-            try
+                CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace,
-            {
+                    new KeyValuePair<TKey, TValue>(key, value),
+                    new KeyValuePair<TKey, TValue>(key, existing)));
-                return ((IDictionary<K, V>) store).Contains(item);
+                PropertyChanged(this, new PropertyChangedEventArgs("Values"));
             }
-            finally
+            else
+            {
+                AddWithNotification(key, value);
+            }
-            {
+        }
+        /// <summary>
+        /// Allows derived classes to raise custom property changed events.
+        /// </summary>
+        protected void RaisePropertyChanged(PropertyChangedEventArgs args)
                 if (_lock.IsReadLockHeld) _lock.ExitReadLock();
-            }
+            PropertyChanged(this, args);
-        }
+        }
-        public bool ContainsKey(K key)
+        #region IDictionary<TKey,TValue> Members
-        {
+        /// <summary>
-            _lock.EnterReadLock();
+        /// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2" />.
+        /// </summary>
-            try
+        /// <param name="key">The object to use as the key of the element to add.</param>
+        /// <param name="value">The object to use as the value of the element to add.</param>
         public void Add(TKey key, TValue value)
-                return store.ContainsKey(key);
+        {
             AddWithNotification(key, value);
+        }
-            finally
+        /// <summary>
+        /// Determines whether the <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element with the specified key.
+        /// </summary>
+        /// <param name="key">The key to locate in the <see cref="T:System.Collections.Generic.IDictionary`2" />.</param>
         /// <returns>
-                if (_lock.IsReadLockHeld) _lock.ExitReadLock();
+        /// true if the <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element with the key; otherwise, false.
-            }
         /// </returns>
+        public bool ContainsKey(TKey key)
+        {
-        public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex)
+            return dictionary.ContainsKey(key);
-        {
+        }
-            _lock.EnterReadLock();
+        /// <summary>
-            try
+        /// Gets an <see cref="T:System.Collections.Generic.ICollection`1" /> containing the keys of the <see cref="T:System.Collections.Generic.IDictionary`2" />.
-            {
+        /// </summary>
-                ((IDictionary<K, V>) store).CopyTo(array, arrayIndex);
+        /// <returns>An <see cref="T:System.Collections.Generic.ICollection`1" /> containing the keys of the object that implements <see cref="T:System.Collections.Generic.IDictionary`2" />.</returns>
-            }
+        public ICollection<TKey> Keys
-            finally
+        {
+            get { return dictionary.Keys; }
+        }
+        /// <summary>
+        /// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2" />.
-                if (_lock.IsReadLockHeld) _lock.ExitReadLock();
+        /// </summary>
-            }
+        /// <param name="key">The key of the element to remove.</param>
+        /// <returns>
+        /// true if the element is successfully removed; otherwise, false.  This method also returns false if <paramref name="key" /> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2" />.
+        /// </returns>
         public bool Remove(TKey key)
+        {
-        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
             return RemoveWithNotification(key);
-            _lock.EnterReadLock();
-            try
+        }
-            {
-                using (var enumerator = ((IDictionary<K, V>)store).GetEnumerator())
+        /// <summary>
+        /// Gets the value associated with the specified key.
-                {
+        /// </summary>
-                    while (enumerator.MoveNext())
+        /// <param name="key">The key whose value to get.</param>
-                        yield return enumerator.Current;
+        /// <param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value" /> parameter. This parameter is passed uninitialized.</param>
         /// <returns>
+        /// true if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2" /> contains an element with the specified key; otherwise, false.
-            }
+        /// </returns>
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            return dictionary.TryGetValue(key, out value);
+        }
-            finally
+        /// <summary>
-            {
-                if (_lock.IsReadLockHeld) _lock.ExitReadLock();
-            }
+        /// Gets an <see cref="T:System.Collections.Generic.ICollection`1" /> containing the values in the <see cref="T:System.Collections.Generic.IDictionary`2" />.
-        }
-        public bool Remove(KeyValuePair<K, V> item)
+        /// </summary>
         /// <returns>An <see cref="T:System.Collections.Generic.ICollection`1" /> containing the values in the object that implements <see cref="T:System.Collections.Generic.IDictionary`2" />.</returns>
-            _lock.EnterWriteLock();
-            bool removed;
-            try
-            {
-                removed = ((IDictionary<K, V>) store).Remove(item);
-            }
+        public ICollection<TValue> Values
-            finally
-            {
-                if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
-            }
-            IsVirgin = false;
-            if (removed)
-                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
-            return removed;
+        {
-        }
-        public bool Remove(K key)
-        {
-            KeyValuePair<K, V> item;
-            _lock.EnterWriteLock();
-            bool removed;
+            get { return dictionary.Values; }
             try
-            {
-                if (store.ContainsKey(key))
-                    item = new KeyValuePair<K, V>(key, store[key]);
-                removed = store.Remove(key);
-            }
-            finally
-            {
-                if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
         /// <summary>
-            IsVirgin = false;
+        /// Gets or sets the element with the specified key.
-            if (removed)
-                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
-            return removed;
-        }
-        public bool TryGetValue(K key, out V value)
+        /// </summary>
-        {
+        /// <param name="key">The key.</param>
+        /// <returns></returns>
+        public TValue this[TKey key]
-            _lock.EnterReadLock();
+        {
-            try
+            get { return dictionary[key]; }
+            set { UpdateWithNotification(key, value); }
+        }
+        #endregion
-                return store.TryGetValue(key, out value);
+        #region ICollection<KeyValuePair<TKey,TValue>> Members
         void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
-            finally
+        {
-            {
-                if (_lock.IsReadLockHeld) _lock.ExitReadLock();
+            AddWithNotification(item);
-            }
+        }
+        void ICollection<KeyValuePair<TKey, TValue>>.Clear()
+        {
+            dictionary.Clear();
+            CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            PropertyChanged(this, new PropertyChangedEventArgs("Count"));
+            PropertyChanged(this, new PropertyChangedEventArgs("Keys"));
+            PropertyChanged(this, new PropertyChangedEventArgs("Values"));
+        }
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) =>
+            dictionary.Contains(item);
+        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            dictionary.CopyTo(array, arrayIndex);
+        }
+        int ICollection<KeyValuePair<TKey, TValue>>.Count =>
-        }
+           dictionary.Count();
-        IEnumerator IEnumerable.GetEnumerator()
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly =>
             dictionary.IsReadOnly;
-            _lock.EnterReadLock();
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) =>
-            try
+            RemoveWithNotification(item.Key);