Add test and fix behavior for when switching Debounce mode from Trailing to Leading for a DispatcherQueueTimer

Author: michael-hawker

components/Extensions/src/Dispatcher/DispatcherQueueTimerExtensions.cs

@@ -17,6 +17,7 @@ namespace CommunityToolkit.WinUI;
 /// </summary>
 public static class DispatcherQueueTimerExtensions
 {
+    // TODO: We should use a WeakReference here...
     private static ConcurrentDictionary<DispatcherQueueTimer, Action> _debounceInstances = new ConcurrentDictionary<DispatcherQueueTimer, Action>();
 
     /// <summary>
@@ -52,8 +53,20 @@ public static void Debounce(this DispatcherQueueTimer timer, Action action, Time
         timer.Tick -= Timer_Tick;
         timer.Interval = interval;
 
+        // Ensure we haven't been misconfigured and won't execute more times than we expect.
+        timer.IsRepeating = false;
+
         if (immediate)
         {
+            // If we have a _debounceInstance queued, then we were running in trailing mode,
+            // so if we now have the immediate flag, we should ignore this timer, and run immediately.
+            if (_debounceInstances.ContainsKey(timer))
+            {
+                timeout = false;
+
+                _debounceInstances.Remove(timer, out var _);
+            }
+
             // If we're in immediate mode then we only execute if the timer wasn't running beforehand
             if (!timeout)
             {

components/Extensions/tests/DispatcherQueueTimerExtensionTests.cs

@@ -167,6 +167,59 @@ public async Task DispatcherQueueTimer_Debounce_Immediate_Interrupt()
         Assert.AreEqual(1, triggeredCount, "Expected 2nd request to be ignored.");
     }
 
+    /// <summary>
+    /// Tests the scenario where we flip from wanting trailing to leading edge invocaton.
+    /// For instance, this could be for a case where a user has cleared the textbox, so you
+    /// want to immediately return new results vs. waiting for further input.
+    /// </summary>
+    /// <returns></returns>
+    [TestCategory("DispatcherQueueTimerExtensions")]
+    [UIThreadTestMethod]
+    public async Task DispatcherQueueTimer_Debounce_Trailing_Switch_Leading_Interrupt()
+    {
+        var debounceTimer = DispatcherQueue.GetForCurrentThread().CreateTimer();
+
+        var triggeredCount = 0;
+        string? triggeredValue = null;
+
+        var value = "Hello";
+        debounceTimer.Debounce(
+            () =>
+            {
+                triggeredCount++;
+                triggeredValue = value;
+            },
+            TimeSpan.FromMilliseconds(100), false); // Start off waiting
+
+        // Intentional pause to mimic reality
+        await Task.Delay(TimeSpan.FromMilliseconds(30));
+
+        Assert.AreEqual(true, debounceTimer.IsRunning, "Expected time to be running.");
+        Assert.AreEqual(0, triggeredCount, "Function shouldn't have run yet.");
+        Assert.IsNull(triggeredValue, "Function shouldn't have run yet.");
+
+        // Now interrupt with a scenario we want processed immediately, i.e. user started typing something new
+        var value2 = "He";
+        debounceTimer.Debounce(
+            () =>
+            {
+                triggeredCount++;
+                triggeredValue = value2;
+            },
+            TimeSpan.FromMilliseconds(100), true);
+
+        Assert.AreEqual(true, debounceTimer.IsRunning, "Expected timer should still be running.");
+        Assert.AreEqual(1, triggeredCount, "Function should now have run immediately.");
+        Assert.AreEqual(value2, triggeredValue, "Function should have set value to 'He'");
+
+        // Wait to where all should be done
+        await Task.Delay(TimeSpan.FromMilliseconds(120));
+
+        Assert.AreEqual(false, debounceTimer.IsRunning, "Expected to stop the timer.");
+        Assert.AreEqual(value2, triggeredValue, "Expected value to remain the same.");
+        Assert.AreEqual(1, triggeredCount, "Expected to interrupt execution and ignore initial queued exectution.");
+    }
+
     /// <summary>
     /// Tests where we start with immediately processing a delay, but then want to switch to processing after.
     /// For instance, maybe we want to ensure we start processing the first letter of a search query to filter initial results.