SLVS-2430 Introduce service that executes a task with debounce

Author: gabriela-trutan-sonarsource

src/Integration.Vsix.UnitTests/SonarLintTagger/TaskExecutorWithDebounceFactoryTest.cs

@@ -0,0 +1,56 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2025 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using Microsoft.VisualStudio.Text;
+using SonarLint.VisualStudio.Core.Synchronization;
+using SonarLint.VisualStudio.Integration.Vsix.SonarLintTagger;
+
+namespace SonarLint.VisualStudio.Integration.UnitTests.SonarLintTagger;
+
+[TestClass]
+public class TaskExecutorWithDebounceFactoryTest
+{
+    private TaskExecutorWithDebounceFactory testSubject;
+    private IAsyncLockFactory asyncLockFactory;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        asyncLockFactory = Substitute.For<IAsyncLockFactory>();
+        testSubject = new TaskExecutorWithDebounceFactory(asyncLockFactory);
+    }
+
+    [TestMethod]
+    public void MefCtor_CheckIsExported() =>
+        MefTestHelpers.CheckTypeCanBeImported<TaskExecutorWithDebounceFactory, ITaskExecutorWithDebounceFactory>(
+            MefTestHelpers.CreateExport<IAsyncLockFactory>());
+
+    [TestMethod]
+    public void MefCtor_CheckIsSingleton() => MefTestHelpers.CheckIsSingletonMefComponent<TaskExecutorWithDebounceFactory>();
+
+    [TestMethod]
+    public void Create_ShouldReturnInstance()
+    {
+        var result = testSubject.Create<ITextSnapshot>(1.0);
+
+        result.Should().NotBeNull();
+        result.Should().BeOfType<TaskExecutorWithDebounce<ITextSnapshot>>();
+    }
+}

src/Integration.Vsix.UnitTests/SonarLintTagger/TaskExecutorWithDebounceTest.cs

@@ -0,0 +1,89 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2025 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using Microsoft.VisualStudio.Threading;
+using SonarLint.VisualStudio.Core.Synchronization;
+using SonarLint.VisualStudio.Integration.TestInfrastructure;
+using SonarLint.VisualStudio.Integration.Vsix.SonarLintTagger;
+
+namespace SonarLint.VisualStudio.Integration.UnitTests.SonarLintTagger;
+
+[TestClass]
+public class TaskExecutorWithDebounceTest
+{
+    private const int DebounceTimeInMs = 100;
+    private IAsyncLock asyncLock;
+    private IAsyncLockFactory asyncLockFactory;
+    private TaskExecutorWithDebounce<TestData> testSubject;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        asyncLockFactory = Substitute.For<IAsyncLockFactory>();
+        asyncLock = Substitute.For<IAsyncLock>();
+        asyncLockFactory.Create().Returns(asyncLock);
+        testSubject = new TaskExecutorWithDebounce<TestData>(asyncLockFactory, DebounceTimeInMs);
+    }
+
+    [TestMethod]
+    public async Task DebounceAsync_ExecutesTaskWithDebounce()
+    {
+        var currentState = new TestData { Value = 1 };
+        var tcs = new TaskCompletionSource<int>();
+        var stopwatch = Stopwatch.StartNew();
+
+        testSubject.DebounceAsync(currentState, state =>
+        {
+            UpdateState(state, 2, tcs);
+            stopwatch.Stop();
+        }).Forget();
+        await tcs.Task;
+
+        asyncLock.Received(1).AcquireAsync().IgnoreAwaitForAssert();
+        currentState.Value.Should().Be(2);
+        stopwatch.ElapsedMilliseconds.Should().BeGreaterOrEqualTo(DebounceTimeInMs);
+    }
+
+    [TestMethod]
+    public async Task DebounceAsync_MultipleTimes_UpdatesWithLatestState()
+    {
+        var currentState = new TestData { Value = 1 };
+        var tcs = new TaskCompletionSource<int>();
+
+        testSubject.DebounceAsync(currentState, state => UpdateState(state, 2)).Forget();
+        testSubject.DebounceAsync(currentState, state => UpdateState(state, 3)).Forget();
+        testSubject.DebounceAsync(currentState, state => UpdateState(state, 4, tcs)).Forget();
+        await tcs.Task;
+
+        asyncLock.Received(3).AcquireAsync().IgnoreAwaitForAssert();
+        currentState.Value.Should().Be(4);
+    }
+
+    private static void UpdateState(TestData date, int newValue, TaskCompletionSource<int> taskCompletionSource = null)
+    {
+        date.Value = newValue;
+        taskCompletionSource?.SetResult(1);
+    }
+
+    private record TestData
+    {
+        public int Value { get; set; }
+    }
+}

src/Integration.Vsix/SonarLintTagger/TaskExecutorWithDebounce.cs

@@ -0,0 +1,76 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2025 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Threading;
+using SonarLint.VisualStudio.Core.Synchronization;
+
+namespace SonarLint.VisualStudio.Integration.Vsix.SonarLintTagger;
+
+internal interface ITaskExecutorWithDebounceFactory
+{
+    ITaskExecutorWithDebounce<T> Create<T>(double debounceMilliseconds);
+}
+
+internal interface ITaskExecutorWithDebounce<T>
+{
+    Task DebounceAsync(T state, Action<T> task);
+}
+
+[Export(typeof(ITaskExecutorWithDebounceFactory))]
+[PartCreationPolicy(CreationPolicy.Shared)]
+[method: ImportingConstructor]
+internal class TaskExecutorWithDebounceFactory(IAsyncLockFactory asyncLockFactory) : ITaskExecutorWithDebounceFactory
+{
+    public ITaskExecutorWithDebounce<T> Create<T>(double debounceMilliseconds) => new TaskExecutorWithDebounce<T>(asyncLockFactory, debounceMilliseconds);
+}
+
+internal class TaskExecutorWithDebounce<T>(IAsyncLockFactory asyncLockFactory, double debounceMilliseconds) : ITaskExecutorWithDebounce<T>
+{
+    private sealed record Debounce(CancellationTokenSource CancellationTokenSource, T State);
+    private Debounce latestDebounceState;
+    private readonly IAsyncLock asyncLock = asyncLockFactory.Create();
+
+    public async Task DebounceAsync(T state, Action<T> task)
+    {
+        using (await asyncLock.AcquireAsync())
+        {
+            latestDebounceState?.CancellationTokenSource.Cancel();
+            latestDebounceState = new Debounce(new CancellationTokenSource(), state);
+        }
+
+        var latestState = latestDebounceState;
+        Task.Run(async () =>
+        {
+            try
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(debounceMilliseconds), latestState.CancellationTokenSource.Token);
+                if (!latestState.CancellationTokenSource.Token.IsCancellationRequested)
+                {
+                    task(latestState.State);
+                }
+            }
+            catch (TaskCanceledException)
+            {
+                // do nothing
+            }
+        }, latestState.CancellationTokenSource.Token).Forget();
+    }
+}