wasSharp

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 44  →  ?path2? @ 40
/Collections/Specialized/ConcurrentHashSet.cs
@@ -9,6 +9,7 @@
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Linq;
 
namespace wasSharp.Collections.Specialized
{
@@ -20,10 +21,11 @@
}
}
 
public class ConcurrentHashSet<T> : IDisposable, ISet<T>
public class ConcurrentHashSet<T> : IDisposable, ICollection<T>, IEnumerable<T>, ISet<T>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly HashSet<T> _hashSet;
private readonly HashSet<T> _hashSet = null;
private IEnumerable<string> enumerable;
 
public ConcurrentHashSet()
{
@@ -182,11 +184,7 @@
_lock.EnterReadLock();
try
{
using (var enumerator = _hashSet.GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
return _hashSet.GetEnumerator();
}
finally
{
@@ -199,11 +197,7 @@
_lock.EnterReadLock();
try
{
using (var enumerator = _hashSet.GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
return _hashSet.GetEnumerator();
}
finally
{
@@ -211,7 +205,13 @@
}
}
 
public bool IsReadOnly => ((ICollection<T>)_hashSet).IsReadOnly;
public bool IsReadOnly
{
get
{
return ((ICollection<T>)_hashSet).IsReadOnly;
}
}
 
#endregion Implementation of ICollection<T>
 
@@ -225,9 +225,12 @@
 
protected virtual void Dispose(bool disposing)
{
if (!disposing) return;
_lock?.Dispose();
_hashSet.Clear();
if (disposing)
{
if (_lock != null)
_lock.Dispose();
_hashSet.Clear();
}
}
 
~ConcurrentHashSet()
/Collections/Specialized/ConcurrentList.cs
@@ -21,13 +21,13 @@
public class ConcurrentList<T> : IList<T>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly List<T> _list;
private readonly List<T> _list = null;
 
public ConcurrentList(IEnumerable<T> v)
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list = new List<T>();
foreach (var i in v)
{
@@ -42,9 +42,9 @@
 
public ConcurrentList()
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list = new List<T>();
}
finally
@@ -58,15 +58,9 @@
get
{
_lock.EnterReadLock();
try
{
return _list.Count;
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
var c = _list.Count;
_lock.ExitReadLock();
return c;
}
}
 
@@ -74,9 +68,9 @@
{
get
{
_lock.EnterReadLock();
try
{
_lock.EnterReadLock();
return ((IList<T>)_list).IsReadOnly;
}
finally
@@ -90,9 +84,9 @@
{
get
{
_lock.EnterReadLock();
try
{
_lock.EnterReadLock();
return _list[index];
}
finally
@@ -103,9 +97,9 @@
 
set
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list[index] = value;
}
finally
@@ -117,9 +111,9 @@
 
public int IndexOf(T item)
{
_lock.EnterReadLock();
try
{
_lock.EnterReadLock();
return _list.IndexOf(item);
}
finally
@@ -130,9 +124,9 @@
 
public void Insert(int index, T item)
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list.Insert(index, item);
}
finally
@@ -143,9 +137,9 @@
 
public void RemoveAt(int index)
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list.RemoveAt(index);
}
finally
@@ -156,9 +150,9 @@
 
public void Add(T item)
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list.Add(item);
}
finally
@@ -169,9 +163,9 @@
 
public void Clear()
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
_list.Clear();
}
finally
@@ -182,9 +176,9 @@
 
public bool Contains(T item)
{
_lock.EnterReadLock();
try
{
_lock.EnterReadLock();
return _list.Contains(item);
}
finally
@@ -195,9 +189,9 @@
 
public void CopyTo(T[] array, int arrayIndex)
{
_lock.EnterReadLock();
try
{
_lock.EnterReadLock();
_list.CopyTo(array, arrayIndex);
}
finally
@@ -208,9 +202,9 @@
 
public bool Remove(T item)
{
_lock.EnterWriteLock();
try
{
_lock.EnterWriteLock();
return _list.Remove(item);
}
finally
@@ -221,14 +215,10 @@
 
public IEnumerator<T> GetEnumerator()
{
_lock.EnterReadLock();
try
{
using (var enumerator = _list.GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
_lock.EnterReadLock();
return ((IList<T>)_list).GetEnumerator();
}
finally
{
@@ -238,14 +228,10 @@
 
IEnumerator IEnumerable.GetEnumerator()
{
_lock.EnterReadLock();
try
{
using (var enumerator = _list.GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
_lock.EnterReadLock();
return ((IList<T>)_list).GetEnumerator();
}
finally
{
/Collections/Specialized/MultiKeyDictionary.cs
@@ -13,40 +13,30 @@
{
public class MultiKeyDictionary<K1, K2, V> : Dictionary<K1, Dictionary<K2, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2]
{
get
{
_lock.EnterReadLock();
try
SyncRoot.EnterReadLock();
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2))
{
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2))
{
return default(V);
}
return base[key1][key2];
SyncRoot.ExitReadLock();
return default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
var v = base[key1][key2];
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new Dictionary<K2, V>();
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new Dictionary<K2, V>();
 
this[key1][key2] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
this[key1][key2] = value;
SyncRoot.ExitWriteLock();
}
}
 
@@ -54,280 +44,189 @@
{
get
{
_lock.EnterReadLock();
try
{
return base.Values.SelectMany(baseDict => baseDict.Keys, (baseDict, baseKey) => baseDict[baseKey]);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = base.Values.SelectMany(baseDict => baseDict.Keys, (baseDict, baseKey) => baseDict[baseKey]);
SyncRoot.ExitReadLock();
return v;
}
}
 
public void Add(K1 key1, K2 key2, V value)
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new Dictionary<K2, V>();
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new Dictionary<K2, V>();
 
this[key1][key2] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
this[key1][key2] = value;
SyncRoot.ExitWriteLock();
}
 
public void Remove(K1 key1, K2 key2)
{
_lock.EnterWriteLock();
try
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2))
{
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2))
{
return;
}
this[key1].Remove(key2);
Remove(key1);
SyncRoot.ExitWriteLock();
return;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
this[key1].Remove(key2);
Remove(key1);
SyncRoot.ExitWriteLock();
}
 
public bool ContainsKey(K1 key1, K2 key2)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2);
SyncRoot.ExitReadLock();
return c;
}
 
public bool TryGetValue(K1 key1, K2 key2, out V value)
{
_lock.EnterReadLock();
try
SyncRoot.EnterReadLock();
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2))
{
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2))
{
value = default(V);
return false;
}
value = base[key1][key2];
return true;
SyncRoot.ExitReadLock();
value = default(V);
return false;
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
value = base[key1][key2];
SyncRoot.ExitReadLock();
return true;
}
}
 
public class MultiKeyDictionary<K1, K2, K3, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, V>();
 
this[key1][key2, key3] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, V>();
this[key1][key2, key3] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3);
SyncRoot.ExitReadLock();
return c;
}
 
public void Add(K1 key1, K2 key2, K3 key3, V value)
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, V>();
this[key1][key2, key3] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, V>();
this[key1][key2, key3] = value;
SyncRoot.ExitWriteLock();
}
 
public void Remove(K1 key1, K2 key2, K3 key3)
{
_lock.EnterWriteLock();
try
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2, key3))
{
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2, key3))
{
return;
}
this[key1][key2].Remove(key3);
this[key1].Remove(key2);
Remove(key1);
SyncRoot.ExitWriteLock();
return;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
this[key1][key2].Remove(key3);
this[key1].Remove(key2);
Remove(key1);
SyncRoot.ExitWriteLock();
}
 
public bool TryGetValue(K1 key1, K2 key2, K3 key3, out V value)
{
_lock.EnterReadLock();
try
SyncRoot.EnterReadLock();
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2, key3))
{
if (!ContainsKey(key1) || !this[key1].ContainsKey(key2, key3))
{
value = default(V);
return false;
}
value = base[key1][key2, key3];
return true;
SyncRoot.ExitReadLock();
value = default(V);
return false;
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
value = base[key1][key2, key3];
SyncRoot.ExitReadLock();
return true;
}
}
 
public class MultiKeyDictionary<K1, K2, K3, K4, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, K4, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3, key4] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, V>();
this[key1][key2, key3, key4] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, V>();
this[key1][key2, key3, key4] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4);
SyncRoot.ExitReadLock();
return c;
}
}
 
public class MultiKeyDictionary<K1, K2, K3, K4, K5, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3, key4, key5] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4, key5] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, V>();
this[key1][key2, key3, key4, key5] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, V>();
this[key1][key2, key3, key4, key5] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5);
SyncRoot.ExitReadLock();
return c;
}
}
 
@@ -334,49 +233,33 @@
public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, V> :
Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, V>();
this[key1][key2, key3, key4, key5, key6] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, V>();
this[key1][key2, key3, key4, key5, key6] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6);
SyncRoot.ExitReadLock();
return c;
}
}
 
@@ -383,49 +266,33 @@
public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, V> :
Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>();
this[key1][key2, key3, key4, key5, key6, key7] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>();
this[key1][key2, key3, key4, key5, key6, key7] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7);
SyncRoot.ExitReadLock();
return c;
}
}
 
@@ -432,49 +299,33 @@
public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, V> :
Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8);
SyncRoot.ExitReadLock();
return c;
}
}
 
@@ -481,49 +332,33 @@
public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, V> :
Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9] : default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8, key9] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8, key9] = value;
SyncRoot.ExitWriteLock();
}
}
 
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9);
SyncRoot.ExitReadLock();
return c;
}
}
 
@@ -530,37 +365,24 @@
public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, V> :
Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, K10 key10]
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1)
? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10]
: default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] : default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] = value;
SyncRoot.ExitWriteLock();
}
}
 
@@ -567,16 +389,11 @@
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9,
K10 key10)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) &&
this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) &&
this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10);
SyncRoot.ExitReadLock();
return c;
}
}
 
@@ -583,7 +400,7 @@
public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V> :
Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
public V this[
K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, K10 key10, K11 key11]
@@ -590,31 +407,20 @@
{
get
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1)
? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11]
: default(V);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = ContainsKey(key1)
? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11]
: default(V);
SyncRoot.ExitReadLock();
return v;
}
set
{
_lock.EnterWriteLock();
try
{
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
if (!ContainsKey(key1))
this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>();
this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11] = value;
SyncRoot.ExitWriteLock();
}
}
 
@@ -621,16 +427,11 @@
public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9,
K10 key10, K11 key11)
{
_lock.EnterReadLock();
try
{
return ContainsKey(key1) &&
this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10, key11);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ContainsKey(key1) &&
this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10, key11);
SyncRoot.ExitReadLock();
return c;
}
}
}
/Collections/Specialized/ObservableDictionary.cs
@@ -21,7 +21,7 @@
/// <typeparam name="V">the value type</typeparam>
public class ObservableDictionary<K, V> : IDictionary<K, V>, INotifyCollectionChanged
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly Dictionary<K, V> store = new Dictionary<K, V>();
 
public bool IsVirgin { get; private set; } = true;
@@ -30,28 +30,17 @@
{
get
{
_lock.EnterReadLock();
try
{
return store[key];
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = store[key];
SyncRoot.ExitReadLock();
return v;
}
 
set
{
_lock.EnterWriteLock();
try
{
store[key] = value;
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store[key] = value;
SyncRoot.ExitWriteLock();
}
}
 
@@ -63,15 +52,10 @@
{
get
{
_lock.EnterReadLock();
try
{
return store.Keys;
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = store.Keys;
SyncRoot.ExitReadLock();
return v;
}
}
 
@@ -79,29 +63,18 @@
{
get
{
_lock.EnterReadLock();
try
{
return store.Values;
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var v = store.Values;
SyncRoot.ExitReadLock();
return v;
}
}
 
public void Add(KeyValuePair<K, V> item)
{
_lock.EnterWriteLock();
try
{
((IDictionary<K, V>) store).Add(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
((IDictionary<K, V>)store).Add(item);
SyncRoot.ExitWriteLock();
IsVirgin = false;
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
@@ -108,15 +81,9 @@
 
public void Add(K key, V value)
{
_lock.EnterWriteLock();
try
{
store.Add(key, value);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.Add(key, value);
SyncRoot.ExitWriteLock();
IsVirgin = false;
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add,
new KeyValuePair<K, V>(key, value)));
@@ -124,15 +91,9 @@
 
public void Clear()
{
_lock.EnterWriteLock();
try
{
store.Clear();
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.Clear();
SyncRoot.ExitWriteLock();
if (!IsVirgin)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
IsVirgin = false;
@@ -140,72 +101,40 @@
 
public bool Contains(KeyValuePair<K, V> item)
{
_lock.EnterReadLock();
try
{
return ((IDictionary<K, V>) store).Contains(item);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = ((IDictionary<K, V>)store).Contains(item);
SyncRoot.ExitReadLock();
return c;
}
 
public bool ContainsKey(K key)
{
_lock.EnterReadLock();
try
{
return store.ContainsKey(key);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = store.ContainsKey(key);
SyncRoot.ExitReadLock();
return c;
}
 
public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex)
{
_lock.EnterReadLock();
try
{
((IDictionary<K, V>) store).CopyTo(array, arrayIndex);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
((IDictionary<K, V>)store).CopyTo(array, arrayIndex);
SyncRoot.ExitReadLock();
}
 
public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
{
_lock.EnterReadLock();
try
{
using (var enumerator = ((IDictionary<K, V>)store).GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var enumerator = ((IDictionary<K, V>)store).GetEnumerator();
SyncRoot.ExitReadLock();
return enumerator;
}
 
public bool Remove(KeyValuePair<K, V> item)
{
_lock.EnterWriteLock();
bool removed;
try
{
removed = ((IDictionary<K, V>) store).Remove(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
var removed = ((IDictionary<K, V>)store).Remove(item);
SyncRoot.ExitWriteLock();
IsVirgin = false;
if (removed)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
@@ -215,19 +144,12 @@
public bool Remove(K key)
{
KeyValuePair<K, V> item;
_lock.EnterWriteLock();
bool removed;
try
{
if (store.ContainsKey(key))
item = new KeyValuePair<K, V>(key, store[key]);
SyncRoot.EnterWriteLock();
if (store.ContainsKey(key))
item = new KeyValuePair<K, V>(key, store[key]);
 
removed = store.Remove(key);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
var removed = store.Remove(key);
SyncRoot.ExitWriteLock();
IsVirgin = false;
if (removed)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
@@ -236,32 +158,18 @@
 
public bool TryGetValue(K key, out V value)
{
_lock.EnterReadLock();
try
{
return store.TryGetValue(key, out value);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var c = store.TryGetValue(key, out value);
SyncRoot.ExitReadLock();
return c;
}
 
IEnumerator IEnumerable.GetEnumerator()
{
_lock.EnterReadLock();
try
{
using (var enumerator = ((IDictionary<K, V>)store).GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var enumerator = ((IDictionary<K, V>)store).GetEnumerator();
SyncRoot.ExitReadLock();
return enumerator;
}
 
public event NotifyCollectionChangedEventHandler CollectionChanged;
/Collections/Specialized/ObservableHashSet.cs
@@ -22,20 +22,14 @@
/// <typeparam name="T">the object type</typeparam>
public class ObservableHashSet<T> : ICollection<T>, INotifyCollectionChanged, IEnumerable<T>
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly ReaderWriterLockSlim SyncRoot = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly HashSet<T> store = new HashSet<T>();
 
public ObservableHashSet(HashSet<T> set)
{
_lock.EnterWriteLock();
try
{
UnionWith(set);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
UnionWith(set);
SyncRoot.ExitWriteLock();
}
 
public ObservableHashSet()
@@ -44,41 +38,23 @@
 
public ObservableHashSet(T item)
{
_lock.EnterWriteLock();
try
{
Add(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
Add(item);
SyncRoot.ExitWriteLock();
}
 
public ObservableHashSet(ObservableHashSet<T> other)
{
_lock.EnterWriteLock();
try
{
UnionWith(other);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
UnionWith(other);
SyncRoot.ExitWriteLock();
}
 
public ObservableHashSet(IEnumerable<T> list)
{
_lock.EnterWriteLock();
try
{
UnionWith(list);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
UnionWith(list);
SyncRoot.ExitWriteLock();
}
 
public bool IsVirgin { get; private set; } = true;
@@ -85,49 +61,25 @@
 
public IEnumerator<T> GetEnumerator()
{
_lock.EnterReadLock();
try
{
using (var enumerator = store.GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var enumerator = store.GetEnumerator();
SyncRoot.ExitReadLock();
return enumerator;
}
 
IEnumerator IEnumerable.GetEnumerator()
{
_lock.EnterReadLock();
try
{
using (var enumerator = store.GetEnumerator())
{
while (enumerator.MoveNext())
yield return enumerator.Current;
}
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var enumerator = GetEnumerator();
SyncRoot.ExitReadLock();
return enumerator;
}
 
public void Add(T item)
{
_lock.EnterWriteLock();
try
{
store.Add(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.Add(item);
SyncRoot.ExitWriteLock();
IsVirgin = false;
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
}
@@ -134,15 +86,9 @@
 
public void Clear()
{
_lock.EnterWriteLock();
try
{
store.Clear();
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.Clear();
SyncRoot.ExitWriteLock();
if (!IsVirgin)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
IsVirgin = false;
@@ -150,42 +96,24 @@
 
public bool Contains(T item)
{
_lock.EnterReadLock();
try
{
return store.Contains(item);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
var contains = store.Contains(item);
SyncRoot.ExitReadLock();
return contains;
}
 
public void CopyTo(T[] array, int arrayIndex)
{
_lock.EnterReadLock();
try
{
store.CopyTo(array, arrayIndex);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
SyncRoot.EnterReadLock();
store.CopyTo(array, arrayIndex);
SyncRoot.ExitReadLock();
}
 
public bool Remove(T item)
{
_lock.EnterWriteLock();
bool removed;
try
{
removed = store.Remove(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
var removed = store.Remove(item);
SyncRoot.ExitWriteLock();
IsVirgin = false;
if (removed)
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
@@ -201,15 +129,9 @@
public void UnionWith(IEnumerable<T> list)
{
var added = new List<T>(list.Except(store));
_lock.EnterWriteLock();
try
{
store.UnionWith(added);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.UnionWith(added);
SyncRoot.ExitWriteLock();
if (!IsVirgin && added.Any())
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, added));
IsVirgin = false;
@@ -223,15 +145,9 @@
public void ExceptWith(IEnumerable<T> list)
{
var removed = new List<T>(list.Intersect(store));
_lock.EnterWriteLock();
try
{
store.ExceptWith(removed);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.ExceptWith(removed);
SyncRoot.ExitWriteLock();
if (!IsVirgin && removed.Any())
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove,
removed));
@@ -241,15 +157,9 @@
public void RemoveWhere(Func<T, bool> func)
{
var removed = new List<T>(store.Where(func));
_lock.EnterWriteLock();
try
{
store.ExceptWith(removed);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
store.ExceptWith(removed);
SyncRoot.ExitWriteLock();
if (!IsVirgin && removed.Any())
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove,
removed));
@@ -258,15 +168,10 @@
 
public IEnumerable<T> AsEnumerable()
{
_lock.EnterWriteLock();
try
{
return store.AsEnumerable();
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
SyncRoot.EnterWriteLock();
var enumerable = store.AsEnumerable();
SyncRoot.ExitWriteLock();
return enumerable;
}
}
}