From cba62295a30eb723be769a03c9b2b22ecb25ed7d Mon Sep 17 00:00:00 2001
From: "o.nadymov" <o.nadymov@spoleto.ru>
Date: Tue, 27 Feb 2024 17:15:24 +0300
Subject: [PATCH] Separate locks for different objects (sync + async)

---
 src/Spoleto.Common/Locks/AsyncLock.cs        |  32 ++++++
 src/Spoleto.Common/Locks/ObjectAsyncLocks.cs | 109 +++++++++++++++++++
 src/Spoleto.Common/Locks/ObjectLocks.cs      |  80 ++++++++++++++
 3 files changed, 221 insertions(+)
 create mode 100644 src/Spoleto.Common/Locks/AsyncLock.cs
 create mode 100644 src/Spoleto.Common/Locks/ObjectAsyncLocks.cs
 create mode 100644 src/Spoleto.Common/Locks/ObjectLocks.cs

diff --git a/src/Spoleto.Common/Locks/AsyncLock.cs b/src/Spoleto.Common/Locks/AsyncLock.cs
new file mode 100644
index 0000000..7429745
--- /dev/null
+++ b/src/Spoleto.Common/Locks/AsyncLock.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Spoleto.Common.Locks
+{
+    /// <summary>
+    /// The special lock for async body.
+    /// </summary>
+    public class AsyncLock : IDisposable
+    {
+        private readonly SemaphoreSlim _semaphoreSlim = new(1, 1);
+
+        /// <summary>
+        /// Creates the lock.
+        /// </summary>
+        /// <returns></returns>
+        public async Task<AsyncLock> LockAsync()
+        {
+            await _semaphoreSlim.WaitAsync().ConfigureAwait(false);
+            return this;
+        }
+
+        /// <summary>
+        /// Releases the lock.
+        /// </summary>
+        public void Dispose()
+        {
+            _semaphoreSlim.Release();
+        }
+    }
+}
diff --git a/src/Spoleto.Common/Locks/ObjectAsyncLocks.cs b/src/Spoleto.Common/Locks/ObjectAsyncLocks.cs
new file mode 100644
index 0000000..c34e5c7
--- /dev/null
+++ b/src/Spoleto.Common/Locks/ObjectAsyncLocks.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Spoleto.Common.Locks
+{
+    /// <summary>
+    /// The static class for separate async locks for objects.
+    /// </summary>
+    /// <remarks>
+    /// Example:
+    /// var lockObject = ObjectAsyncLocks.GetObjectLock(lockObjetKey);<br/>
+    /// using (await lockObject.LockAsync())<br/>
+    /// {<br/>
+    ///     try<br/>
+    ///     {<br/>
+    ///        // code<br/>
+    ///     }<br/>
+    ///     finally<br/>
+    ///     {<br/>
+    ///        ObjectAsyncLocks.ReleaseObjectLock(lockObjetKey);<br/>
+    ///     }<br/>
+    /// }<br/>
+    /// </remarks>
+    public static class ObjectAsyncLocks
+    {
+        /// <summary>
+        /// The class of async locks with deep.
+        /// </summary>
+        public class AsyncIntLock : IDisposable
+        {
+            /// <summary>
+            /// The async lock object.
+            /// </summary>
+            private readonly AsyncLock _asyncLock;
+
+            /// <summary>
+            /// Default constructor.
+            /// </summary>
+            public AsyncIntLock()
+            {
+                _asyncLock = new AsyncLock();
+            }
+
+            /// <summary>
+            /// Locks deep.
+            /// </summary>
+            public int Deep { get; set; }
+
+            /// <summary>
+            /// Releases the lock.
+            /// </summary>
+            public void Dispose() => _asyncLock.Dispose();
+
+            /// <summary>
+            /// Creates the lock.
+            /// </summary>
+            public async Task<AsyncIntLock> LockAsync()
+            {
+                await _asyncLock.LockAsync().ConfigureAwait(false);
+                return this;
+            }
+
+            /// <summary>
+            /// Return text representation.
+            /// </summary>
+            /// <returns></returns>
+            public override string ToString() => $"Deep = {Deep}";
+        }
+
+
+        private static readonly Dictionary<string, AsyncIntLock> ObjectLocksDic = new();
+        private static readonly object CacheLock = new();
+
+        /// <summary>
+        /// Returns lock for object.
+        /// </summary>
+        public static AsyncIntLock GetObjectLock(string key)
+        {
+            lock (CacheLock)
+            {
+                if (!ObjectLocksDic.TryGetValue(key, out var cachedItem))
+                {
+                    cachedItem = new AsyncIntLock();
+                    ObjectLocksDic.Add(key, cachedItem);
+                }
+
+                cachedItem.Deep++;
+                return cachedItem;
+            }
+        }
+
+        /// <summary>
+        /// Release object.
+        /// </summary>
+        public static void ReleaseObjectLock(string key)
+        {
+            lock (CacheLock)
+            {
+                if (ObjectLocksDic.TryGetValue(key, out var cachedItem))
+                {
+                    cachedItem.Deep--;
+                    if (cachedItem.Deep == 0)
+                        ObjectLocksDic.Remove(key);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Spoleto.Common/Locks/ObjectLocks.cs b/src/Spoleto.Common/Locks/ObjectLocks.cs
new file mode 100644
index 0000000..c8b67df
--- /dev/null
+++ b/src/Spoleto.Common/Locks/ObjectLocks.cs
@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+
+namespace Spoleto.Common.Locks
+{
+    /// <summary>
+    /// The static class for separate locks for objects.
+    /// </summary>
+    /// <remarks>
+    /// Example:
+    /// object lockObj = ObjectLocks.GetObjectLock(lockObjetKey);<br/>
+    /// lock (lockObj)
+    /// {<br/>
+    ///     try<br/>
+    ///     {<br/>
+    ///        // code<br/>
+    ///     }<br/>
+    ///     finally<br/>
+    ///     {<br/>
+    ///        ObjectLocks.ReleaseObjectLock(lockObjetKey);<br/>
+    ///     }<br/>
+    /// }<br/>
+    /// </remarks>
+    public static class ObjectLocks
+    {
+        /// <summary>
+        /// The class of locks with deep.
+        /// </summary>
+        private class IntLock
+        {
+            /// <summary>
+            /// Locks deep.
+            /// </summary>
+            public int Deep { get; set; }
+
+            /// <summary>
+            /// Return text representation.
+            /// </summary>
+            /// <returns></returns>
+            public override string ToString() => $"Deep = {Deep}";
+        }
+
+
+        private static readonly Dictionary<string, IntLock> ObjectLocksDic = new Dictionary<string, IntLock>();
+        private static readonly object CacheLock = new object();
+
+        /// <summary>
+        /// Returns lock for object.
+        /// </summary>
+        public static object GetObjectLock(string key)
+        {
+            lock (CacheLock)
+            {
+                if (!ObjectLocksDic.TryGetValue(key, out var cachedItem))
+                {
+                    cachedItem = new IntLock();
+                    ObjectLocksDic.Add(key, cachedItem);
+                }
+
+                cachedItem.Deep++;
+                return cachedItem;
+            }
+        }
+
+        /// <summary>
+        /// Release object.
+        /// </summary>
+        public static void ReleaseObjectLock(string key)
+        {
+            lock (CacheLock)
+            {
+                if (ObjectLocksDic.TryGetValue(key, out var cachedItem))
+                {
+                    cachedItem.Deep--;
+                    if (cachedItem.Deep == 0)
+                        ObjectLocksDic.Remove(key);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file