ThunderDesign
diff --git a/‎README.md‎
Lines changed: 1 addition & 0 deletions b/‎README.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎src/ThunderDesign.Net-PCL.Threading/Collections/DictionaryThreadSafe.cs‎
Lines changed: 32 additions & 33 deletions b/‎src/ThunderDesign.Net-PCL.Threading/Collections/DictionaryThreadSafe.cs‎
Lines changed: 32 additions & 33 deletions
@@ -2,5 +2,6 @@
 [![CI](https://github.com/ThunderDesign/ThunderDesign.Net-PCL.Threading/actions/workflows/CI.yml/badge.svg)](https://github.com/ThunderDesign/ThunderDesign.Net-PCL.Threading/actions/workflows/CI.yml)
 [![CD](https://github.com/ThunderDesign/ThunderDesign.Net-PCL.Threading/actions/workflows/CD.yml/badge.svg)](https://github.com/ThunderDesign/ThunderDesign.Net-PCL.Threading/actions/workflows/CD.yml)
 [![Nuget](https://img.shields.io/nuget/v/ThunderDesign.Net-PCL.Threading)](https://www.nuget.org/packages/ThunderDesign.Net-PCL.Threading)
+[![License](https://img.shields.io/github/license/ThunderDesign/ThunderDesign.Net-PCL.Threading)](https://github.com/ThunderDesign/ThunderDesign.Net-PCL.Threading/blob/main/LICENSE)
 
 Thread-Safe Objects
@@ -1,9 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.Serialization;
-using System.Text;
+using System.Threading;
 using ThunderDesign.Net.Threading.Interfaces;
-using ThunderDesign.Net.Threading.Threading;
 
 namespace ThunderDesign.Net.Threading.Collections
 {
@@ -23,14 +22,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa
         {
             get
             {
-                _ReaderWriterNotifyLock.EnterReadLock();
+                _ReaderWriterLockSlim.EnterReadLock();
                 try
                 {
                     return base.Comparer;
                 }
                 finally
                 {
-                    _ReaderWriterNotifyLock.ExitReadLock();
+                    _ReaderWriterLockSlim.ExitReadLock();
                 }
             }
         }
@@ -39,14 +38,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa
         {
             get
             {
-                _ReaderWriterNotifyLock.EnterReadLock();
+                _ReaderWriterLockSlim.EnterReadLock();
                 try
                 {
                     return base.Count;
                 }
                 finally
                 {
-                    _ReaderWriterNotifyLock.ExitReadLock();
+                    _ReaderWriterLockSlim.ExitReadLock();
                 }
             }
         }
@@ -55,14 +54,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa
         {
             get
             {
-                _ReaderWriterNotifyLock.EnterReadLock();
+                _ReaderWriterLockSlim.EnterReadLock();
                 try
                 {
                     return base.Keys;
                 }
                 finally
                 {
-                    _ReaderWriterNotifyLock.ExitReadLock();
+                    _ReaderWriterLockSlim.ExitReadLock();
                 }
             }
         }
@@ -71,14 +70,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa
         {
             get
             {
-                _ReaderWriterNotifyLock.EnterReadLock();
+                _ReaderWriterLockSlim.EnterReadLock();
                 try
                 {
                     return base.Values;
                 }
                 finally
                 {
-                    _ReaderWriterNotifyLock.ExitReadLock();
+                    _ReaderWriterLockSlim.ExitReadLock();
                 }
             }
         }
@@ -87,26 +86,26 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa
         {
             get
             {
-                _ReaderWriterNotifyLock.EnterReadLock();
+                _ReaderWriterLockSlim.EnterReadLock();
                 try
                 {
                     return base[key];
                 }
                 finally
                 {
-                    _ReaderWriterNotifyLock.ExitReadLock();
+                    _ReaderWriterLockSlim.ExitReadLock();
                 }
             }
             set
             {
-                _ReaderWriterNotifyLock.EnterWriteLock();
+                _ReaderWriterLockSlim.EnterWriteLock();
                 try
                 {
                     base[key] = value;
                 }
                 finally
                 {
-                    _ReaderWriterNotifyLock.ExitWriteLock();
+                    _ReaderWriterLockSlim.ExitWriteLock();
                 }
             }
         }
@@ -115,127 +114,127 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa
         #region methods
         public new virtual void Add(TKey key, TValue value)
         {
-            _ReaderWriterNotifyLock.EnterWriteLock();
+            _ReaderWriterLockSlim.EnterWriteLock();
             try
             {
                 base.Add(key, value);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitWriteLock();
+                _ReaderWriterLockSlim.ExitWriteLock();
             }
         }
 
         public new virtual void Clear()
         {
-            _ReaderWriterNotifyLock.EnterWriteLock();
+            _ReaderWriterLockSlim.EnterWriteLock();
             try
             {
                 base.Clear();
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitWriteLock();
+                _ReaderWriterLockSlim.ExitWriteLock();
             }
         }
 
         public new bool ContainsKey(TKey key)
         {
-            _ReaderWriterNotifyLock.EnterReadLock();
+            _ReaderWriterLockSlim.EnterReadLock();
             try
             {
                 return base.ContainsKey(key);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitReadLock();
+                _ReaderWriterLockSlim.ExitReadLock();
             }
         }
 
         public new bool ContainsValue(TValue value)
         {
-            _ReaderWriterNotifyLock.EnterReadLock();
+            _ReaderWriterLockSlim.EnterReadLock();
             try
             {
                 return base.ContainsValue(value);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitReadLock();
+                _ReaderWriterLockSlim.ExitReadLock();
             }
         }
 
         public new Enumerator GetEnumerator()
         {
-            _ReaderWriterNotifyLock.EnterReadLock();
+            _ReaderWriterLockSlim.EnterReadLock();
             try
             {
                 return base.GetEnumerator();
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitReadLock();
+                _ReaderWriterLockSlim.ExitReadLock();
             }
         }
 
         [System.Security.SecurityCritical]  // auto-generated_required
         public override void GetObjectData(SerializationInfo info, StreamingContext context)
         {
-            _ReaderWriterNotifyLock.EnterReadLock();
+            _ReaderWriterLockSlim.EnterReadLock();
             try
             {
                 base.GetObjectData(info, context);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitReadLock();
+                _ReaderWriterLockSlim.ExitReadLock();
             }
         }
 
         public override void OnDeserialization(Object sender)
         {
-            _ReaderWriterNotifyLock.EnterReadLock();
+            _ReaderWriterLockSlim.EnterReadLock();
             try
             {
                 base.OnDeserialization(sender);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitReadLock();
+                _ReaderWriterLockSlim.ExitReadLock();
             }
         }
 
         public new virtual bool Remove(TKey key)
         {
             bool result = false;
-            _ReaderWriterNotifyLock.EnterWriteLock();
+            _ReaderWriterLockSlim.EnterWriteLock();
             try
             {
                 result = base.Remove(key);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitWriteLock();
+                _ReaderWriterLockSlim.ExitWriteLock();
             }
             return result;
         }
 
         public new bool TryGetValue(TKey key, out TValue value)
         {
-            _ReaderWriterNotifyLock.EnterReadLock();
+            _ReaderWriterLockSlim.EnterReadLock();
             try
             {
                 return base.TryGetValue(key, out value);
             }
             finally
             {
-                _ReaderWriterNotifyLock.ExitReadLock();
+                _ReaderWriterLockSlim.ExitReadLock();
             }
         }
         #endregion
 
         #region variables
-        protected static readonly ReaderWriterNotifyLock _ReaderWriterNotifyLock = new ReaderWriterNotifyLock();
+        protected static readonly ReaderWriterLockSlim _ReaderWriterLockSlim = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
         #endregion
     }
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,8 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Runtime.Serialization;`
`4`		`-using System.Text;`
	`4`	`+using System.Threading;`
`5`	`5`	`using ThunderDesign.Net.Threading.Interfaces;`
`6`		`-using ThunderDesign.Net.Threading.Threading;`
`7`	`6`
`8`	`7`	`namespace ThunderDesign.Net.Threading.Collections`
`9`	`8`	`{`
`@@ -23,14 +22,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa`
`23`	`22`	`{`
`24`	`23`	`get`
`25`	`24`	`{`
`26`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`25`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`27`	`26`	`try`
`28`	`27`	`{`
`29`	`28`	`return base.Comparer;`
`30`	`29`	`}`
`31`	`30`	`finally`
`32`	`31`	`{`
`33`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`32`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`34`	`33`	`}`
`35`	`34`	`}`
`36`	`35`	`}`
`@@ -39,14 +38,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa`
`39`	`38`	`{`
`40`	`39`	`get`
`41`	`40`	`{`
`42`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`41`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`43`	`42`	`try`
`44`	`43`	`{`
`45`	`44`	`return base.Count;`
`46`	`45`	`}`
`47`	`46`	`finally`
`48`	`47`	`{`
`49`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`48`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`50`	`49`	`}`
`51`	`50`	`}`
`52`	`51`	`}`
`@@ -55,14 +54,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa`
`55`	`54`	`{`
`56`	`55`	`get`
`57`	`56`	`{`
`58`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`57`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`59`	`58`	`try`
`60`	`59`	`{`
`61`	`60`	`return base.Keys;`
`62`	`61`	`}`
`63`	`62`	`finally`
`64`	`63`	`{`
`65`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`64`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`66`	`65`	`}`
`67`	`66`	`}`
`68`	`67`	`}`
`@@ -71,14 +70,14 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa`
`71`	`70`	`{`
`72`	`71`	`get`
`73`	`72`	`{`
`74`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`73`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`75`	`74`	`try`
`76`	`75`	`{`
`77`	`76`	`return base.Values;`
`78`	`77`	`}`
`79`	`78`	`finally`
`80`	`79`	`{`
`81`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`80`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`82`	`81`	`}`
`83`	`82`	`}`
`84`	`83`	`}`
`@@ -87,26 +86,26 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa`
`87`	`86`	`{`
`88`	`87`	`get`
`89`	`88`	`{`
`90`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`89`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`91`	`90`	`try`
`92`	`91`	`{`
`93`	`92`	`return base[key];`
`94`	`93`	`}`
`95`	`94`	`finally`
`96`	`95`	`{`
`97`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`96`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`98`	`97`	`}`
`99`	`98`	`}`
`100`	`99`	`set`
`101`	`100`	`{`
`102`		`- _ReaderWriterNotifyLock.EnterWriteLock();`
	`101`	`+ _ReaderWriterLockSlim.EnterWriteLock();`
`103`	`102`	`try`
`104`	`103`	`{`
`105`	`104`	`base[key] = value;`
`106`	`105`	`}`
`107`	`106`	`finally`
`108`	`107`	`{`
`109`		`- _ReaderWriterNotifyLock.ExitWriteLock();`
	`108`	`+ _ReaderWriterLockSlim.ExitWriteLock();`
`110`	`109`	`}`
`111`	`110`	`}`
`112`	`111`	`}`
`@@ -115,127 +114,127 @@ public DictionaryThreadSafe(IDictionary<TKey, TValue> dictionary, IEqualityCompa`
`115`	`114`	`#region methods`
`116`	`115`	`public new virtual void Add(TKey key, TValue value)`
`117`	`116`	`{`
`118`		`- _ReaderWriterNotifyLock.EnterWriteLock();`
	`117`	`+ _ReaderWriterLockSlim.EnterWriteLock();`
`119`	`118`	`try`
`120`	`119`	`{`
`121`	`120`	`base.Add(key, value);`
`122`	`121`	`}`
`123`	`122`	`finally`
`124`	`123`	`{`
`125`		`- _ReaderWriterNotifyLock.ExitWriteLock();`
	`124`	`+ _ReaderWriterLockSlim.ExitWriteLock();`
`126`	`125`	`}`
`127`	`126`	`}`
`128`	`127`
`129`	`128`	`public new virtual void Clear()`
`130`	`129`	`{`
`131`		`- _ReaderWriterNotifyLock.EnterWriteLock();`
	`130`	`+ _ReaderWriterLockSlim.EnterWriteLock();`
`132`	`131`	`try`
`133`	`132`	`{`
`134`	`133`	`base.Clear();`
`135`	`134`	`}`
`136`	`135`	`finally`
`137`	`136`	`{`
`138`		`- _ReaderWriterNotifyLock.ExitWriteLock();`
	`137`	`+ _ReaderWriterLockSlim.ExitWriteLock();`
`139`	`138`	`}`
`140`	`139`	`}`
`141`	`140`
`142`	`141`	`public new bool ContainsKey(TKey key)`
`143`	`142`	`{`
`144`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`143`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`145`	`144`	`try`
`146`	`145`	`{`
`147`	`146`	`return base.ContainsKey(key);`
`148`	`147`	`}`
`149`	`148`	`finally`
`150`	`149`	`{`
`151`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`150`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`152`	`151`	`}`
`153`	`152`	`}`
`154`	`153`
`155`	`154`	`public new bool ContainsValue(TValue value)`
`156`	`155`	`{`
`157`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`156`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`158`	`157`	`try`
`159`	`158`	`{`
`160`	`159`	`return base.ContainsValue(value);`
`161`	`160`	`}`
`162`	`161`	`finally`
`163`	`162`	`{`
`164`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`163`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`165`	`164`	`}`
`166`	`165`	`}`
`167`	`166`
`168`	`167`	`public new Enumerator GetEnumerator()`
`169`	`168`	`{`
`170`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`169`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`171`	`170`	`try`
`172`	`171`	`{`
`173`	`172`	`return base.GetEnumerator();`
`174`	`173`	`}`
`175`	`174`	`finally`
`176`	`175`	`{`
`177`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`176`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`178`	`177`	`}`
`179`	`178`	`}`
`180`	`179`
`181`	`180`	`[System.Security.SecurityCritical] // auto-generated_required`
`182`	`181`	`public override void GetObjectData(SerializationInfo info, StreamingContext context)`
`183`	`182`	`{`
`184`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`183`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`185`	`184`	`try`
`186`	`185`	`{`
`187`	`186`	`base.GetObjectData(info, context);`
`188`	`187`	`}`
`189`	`188`	`finally`
`190`	`189`	`{`
`191`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`190`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`192`	`191`	`}`
`193`	`192`	`}`
`194`	`193`
`195`	`194`	`public override void OnDeserialization(Object sender)`
`196`	`195`	`{`
`197`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`196`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`198`	`197`	`try`
`199`	`198`	`{`
`200`	`199`	`base.OnDeserialization(sender);`
`201`	`200`	`}`
`202`	`201`	`finally`
`203`	`202`	`{`
`204`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`203`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`205`	`204`	`}`
`206`	`205`	`}`
`207`	`206`
`208`	`207`	`public new virtual bool Remove(TKey key)`
`209`	`208`	`{`
`210`	`209`	`bool result = false;`
`211`		`- _ReaderWriterNotifyLock.EnterWriteLock();`
	`210`	`+ _ReaderWriterLockSlim.EnterWriteLock();`
`212`	`211`	`try`
`213`	`212`	`{`
`214`	`213`	`result = base.Remove(key);`
`215`	`214`	`}`
`216`	`215`	`finally`
`217`	`216`	`{`
`218`		`- _ReaderWriterNotifyLock.ExitWriteLock();`
	`217`	`+ _ReaderWriterLockSlim.ExitWriteLock();`
`219`	`218`	`}`
`220`	`219`	`return result;`
`221`	`220`	`}`
`222`	`221`
`223`	`222`	`public new bool TryGetValue(TKey key, out TValue value)`
`224`	`223`	`{`
`225`		`- _ReaderWriterNotifyLock.EnterReadLock();`
	`224`	`+ _ReaderWriterLockSlim.EnterReadLock();`
`226`	`225`	`try`
`227`	`226`	`{`
`228`	`227`	`return base.TryGetValue(key, out value);`
`229`	`228`	`}`
`230`	`229`	`finally`
`231`	`230`	`{`
`232`		`- _ReaderWriterNotifyLock.ExitReadLock();`
	`231`	`+ _ReaderWriterLockSlim.ExitReadLock();`
`233`	`232`	`}`
`234`	`233`	`}`
`235`	`234`	`#endregion`
`236`	`235`
`237`	`236`	`#region variables`
`238`		`- protected static readonly ReaderWriterNotifyLock _ReaderWriterNotifyLock = new ReaderWriterNotifyLock();`
	`237`	`+ protected static readonly ReaderWriterLockSlim _ReaderWriterLockSlim = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);`
`239`	`238`
`240`	`239`	`#endregion`
`241`	`240`	`}`