throttle reimplemented

Azaion.Common/Extensions/ThrottleExtensions.cs

@@ -1,22 +1,70 @@
-namespace Azaion.Common.Extensions;
+using System.Collections.Concurrent;
+
+namespace Azaion.Common.Extensions;
 
 public static class ThrottleExt
 {
-    private static readonly Dictionary<Delegate, DateTime> LastExecution = new();
-    private static readonly object Lock = new();
-
-    public static async Task Throttle(this Func<Task> func, TimeSpan interval, CancellationToken ct = default)
+    private class ThrottleState(Func<Task> action)
     {
-        ArgumentNullException.ThrowIfNull(func);
+        public Func<Task> Action { get; } = action ?? throw new ArgumentNullException(nameof(action));
+        public bool IsCoolingDown = false;
+        public bool CallScheduledDuringCooldown = false;
+        public Task CooldownTask = Task.CompletedTask;
+        public readonly object StateLock = new();
+    }
 
-        lock (Lock)
+    private static readonly ConcurrentDictionary<Guid, ThrottleState> ThrottlerStates = new();
+
+    public static void Throttle(Func<Task> action, Guid actionId, TimeSpan interval)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        if (actionId == Guid.Empty)
+            throw new ArgumentException("Throttle identifier cannot be empty.", nameof(actionId));
+        if (interval <= TimeSpan.Zero)
+            throw new ArgumentOutOfRangeException(nameof(interval), "Interval must be positive.");
+
+        var state = ThrottlerStates.GetOrAdd(actionId, new ThrottleState(action));
+
+        lock (state.StateLock)
         {
-            if (LastExecution.ContainsKey(func) && DateTime.UtcNow - LastExecution[func] < interval)
-                return;
-
-            func();
-            LastExecution[func] = DateTime.UtcNow;
+            if (!state.IsCoolingDown)
+            {
+                state.IsCoolingDown = true;
+                state.CooldownTask = ExecuteAndManageCooldownStaticAsync(actionId, interval, state);
+            }
+            else
+            {
+                state.CallScheduledDuringCooldown = true;
+            }
         }
     }
 
+    private static async Task ExecuteAndManageCooldownStaticAsync(Guid throttleId, TimeSpan interval, ThrottleState state)
+    {
+        try
+        {
+            await state.Action();
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[Throttled Action Error - ID: {throttleId}] {ex.GetType().Name}: {ex.Message}");
+        }
+        finally
+        {
+            await Task.Delay(interval);
+
+            lock (state.StateLock)
+            {
+                if (state.CallScheduledDuringCooldown)
+                {
+                    state.CallScheduledDuringCooldown = false;
+                    state.CooldownTask = ExecuteAndManageCooldownStaticAsync(throttleId, interval, state);
+                }
+                else
+                {
+                    state.IsCoolingDown = false;
+                }
+            }
+        }
+    }
 }