Defer dashboard refreshes until the charts panel is active

Introduces activation logic to NamespaceDashboardViewModel to ensure that data fetching and auto-refresh cycles only run when the dashboard is visible. MainWindowViewModel now manages this lifecycle, deactivating refreshes when switching to other panels like Live Stream or Alerts to reduce unnecessary background operations.

Author: soliktomasz

BusLane.Tests/ViewModels/MainWindowViewModelTests.cs

@@ -142,6 +142,79 @@ public void ActiveWorkspaceModeLabel_WithConnectionStringTab_ReturnsConnectionTy
         sut.ActiveWorkspaceModeLabel.Should().Be("Queue connection");
     }
 
+    [Fact]
+    public async Task ConnectionStringTab_DoesNotStartDashboardRefreshUntilChartsAreOpened()
+    {
+        // Arrange
+        var preferences = new TestPreferencesService();
+        var operationsFactory = Substitute.For<IServiceBusOperationsFactory>();
+        var operations = Substitute.For<IConnectionStringOperations>();
+        var dashboardRefreshService = Substitute.For<IDashboardRefreshService>();
+        using var sut = CreateSut(
+            preferences,
+            operationsFactory: operationsFactory,
+            dashboardRefreshService: dashboardRefreshService);
+
+        operationsFactory.CreateFromConnectionString(Arg.Any<string>()).Returns(operations);
+        operations.GetQueueInfoAsync("orders", Arg.Any<CancellationToken>())
+            .Returns(new QueueInfo(
+                "orders",
+                12,
+                10,
+                2,
+                0,
+                1024,
+                DateTimeOffset.UtcNow,
+                false,
+                TimeSpan.FromDays(14),
+                TimeSpan.FromMinutes(1)));
+
+        var tab = CreateTab("tab-1", preferences);
+        var connection = SavedConnection.Create(
+            "Orders",
+            "Endpoint=sb://orders.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=test",
+            ConnectionType.Queue,
+            entityName: "orders");
+
+        await tab.ConnectWithConnectionStringAsync(connection, operationsFactory);
+        sut.ConnectionTabs.Add(tab);
+
+        // Act
+        sut.ActiveTab = tab;
+
+        // Assert
+        _ = dashboardRefreshService.DidNotReceive().RefreshAsync(
+            "Orders",
+            operations,
+            Arg.Any<CancellationToken>());
+        dashboardRefreshService.DidNotReceive().StartAutoRefresh(
+            "Orders",
+            operations,
+            TimeSpan.FromSeconds(30));
+
+        // Act
+        sut.OpenChartsCommand.Execute(null);
+
+        // Assert
+        _ = dashboardRefreshService.Received(1).RefreshAsync(
+            "Orders",
+            operations,
+            Arg.Any<CancellationToken>());
+        dashboardRefreshService.Received(1).StartAutoRefresh(
+            "Orders",
+            operations,
+            TimeSpan.FromSeconds(30));
+        sut.FeaturePanels.ShowCharts.Should().BeTrue();
+        dashboardRefreshService.ClearReceivedCalls();
+
+        // Act
+        sut.CloseChartsCommand.Execute(null);
+
+        // Assert
+        dashboardRefreshService.Received(1).StopAutoRefresh();
+        sut.FeaturePanels.ShowCharts.Should().BeFalse();
+    }
+
     [Fact]
     public void ShowNamespaceSelectionPrompt_IsTrueOnlyWhenAzureIsReadyWithoutActiveConnection()
     {
@@ -431,11 +504,13 @@ private static MainWindowViewModel CreateSut(
         IConnectionStorageService? connectionStorage = null,
         IUpdateService? updateService = null,
         IAppLockService? appLockService = null,
-        IBiometricAuthService? biometricAuthService = null)
+        IBiometricAuthService? biometricAuthService = null,
+        IServiceBusOperationsFactory? operationsFactory = null,
+        IDashboardRefreshService? dashboardRefreshService = null)
     {
         auth ??= Substitute.For<IAzureAuthService>();
         var azureResources = Substitute.For<IAzureResourceService>();
-        var operationsFactory = Substitute.For<IServiceBusOperationsFactory>();
+        operationsFactory ??= Substitute.For<IServiceBusOperationsFactory>();
         connectionStorage ??= Substitute.For<IConnectionStorageService>();
         var connectionBackupService = Substitute.For<IConnectionBackupService>();
         var versionService = Substitute.For<IVersionService>();
@@ -452,7 +527,7 @@ private static MainWindowViewModel CreateSut(
         var logSink = CreateLogSink();
 
         var dashboardPersistenceService = Substitute.For<IDashboardPersistenceService>();
-        var dashboardRefreshService = Substitute.For<IDashboardRefreshService>();
+        dashboardRefreshService ??= Substitute.For<IDashboardRefreshService>();
         var inboxScoringService = Substitute.For<INamespaceInboxScoringService>();
         var inboxReviewStore = Substitute.For<INamespaceInboxReviewStore>();
 

BusLane/ViewModels/Dashboard/NamespaceDashboardViewModel.cs

@@ -16,6 +16,7 @@ public partial class NamespaceDashboardViewModel : ObservableObject
     private readonly IAlertService _alertService;
     private IServiceBusOperations? _operations;
     private readonly List<NamespaceDashboardSummary> _summaryHistory = [];
+    private bool _isActive;
 
     [ObservableProperty]
     private string _selectedTimeRange = "1 Hour";
@@ -105,17 +106,17 @@ partial void OnSelectedTimeRangeChanged(string value)
         }
 
         UpdateCharts();
-        _ = RefreshAsync();
+        if (_isActive)
+        {
+            _ = RefreshAsync();
+        }
     }
 
     partial void OnAutoRefreshEnabledChanged(bool value)
     {
-        if (value && _operations != null)
+        if (_isActive && value && _operations != null)
         {
-            _refreshService.StartAutoRefresh(
-                CurrentNamespaceId ?? "current-namespace",
-                _operations,
-                TimeSpan.FromSeconds(RefreshIntervalSeconds));
+            StartAutoRefresh();
         }
         else
         {
@@ -125,12 +126,9 @@ partial void OnAutoRefreshEnabledChanged(bool value)
 
     partial void OnRefreshIntervalSecondsChanged(int value)
     {
-        if (AutoRefreshEnabled && _operations != null)
+        if (_isActive && AutoRefreshEnabled && _operations != null)
         {
-            _refreshService.StartAutoRefresh(
-                CurrentNamespaceId ?? "current-namespace",
-                _operations,
-                TimeSpan.FromSeconds(value));
+            StartAutoRefresh();
         }
     }
 
@@ -165,14 +163,18 @@ public void SetOperations(IServiceBusOperations? operations, string? namespaceId
 
         if (_operations != null)
         {
-            _ = RefreshAsync();
+            if (_isActive)
+            {
+                _ = RefreshAsync();
 
-            if (AutoRefreshEnabled)
+                if (AutoRefreshEnabled)
+                {
+                    StartAutoRefresh();
+                }
+            }
+            else
             {
-                _refreshService.StartAutoRefresh(
-                    CurrentNamespaceId ?? "current-namespace",
-                    _operations,
-                    TimeSpan.FromSeconds(RefreshIntervalSeconds));
+                _refreshService.StopAutoRefresh();
             }
         }
         else
@@ -181,6 +183,45 @@ public void SetOperations(IServiceBusOperations? operations, string? namespaceId
         }
     }
 
+    /// <summary>
+    /// Activates dashboard refresh while the dashboard overlay is visible.
+    /// </summary>
+    public void Activate()
+    {
+        if (_isActive)
+        {
+            return;
+        }
+
+        _isActive = true;
+
+        if (_operations == null)
+        {
+            return;
+        }
+
+        _ = RefreshAsync();
+
+        if (AutoRefreshEnabled)
+        {
+            StartAutoRefresh();
+        }
+    }
+
+    /// <summary>
+    /// Deactivates dashboard refresh when the dashboard overlay is hidden.
+    /// </summary>
+    public void Deactivate()
+    {
+        if (!_isActive)
+        {
+            return;
+        }
+
+        _isActive = false;
+        _refreshService.StopAutoRefresh();
+    }
+
     private void OnSummaryUpdated(object? sender, NamespaceDashboardSummary summary)
     {
         if (!Dispatcher.UIThread.CheckAccess())
@@ -247,6 +288,19 @@ private void OnChartTimeRangeChanged(object? sender, string value)
         UpdateCharts();
     }
 
+    private void StartAutoRefresh()
+    {
+        if (_operations == null)
+        {
+            return;
+        }
+
+        _refreshService.StartAutoRefresh(
+            CurrentNamespaceId ?? "current-namespace",
+            _operations,
+            TimeSpan.FromSeconds(RefreshIntervalSeconds));
+    }
+
     private void PruneHistory()
     {
         var threshold = DateTimeOffset.UtcNow - TimeSpan.FromHours(24);

BusLane/ViewModels/MainWindowViewModel.cs

@@ -1268,19 +1268,35 @@ private async Task ToggleDeadLetterViewAsync()
     #region Feature Panels (delegated)
 
     [RelayCommand]
-    private async Task OpenLiveStream() => await FeaturePanels.OpenLiveStream();
+    private async Task OpenLiveStream()
+    {
+        NamespaceDashboard.Deactivate();
+        await FeaturePanels.OpenLiveStream();
+    }
 
     [RelayCommand]
     private void CloseLiveStream() => FeaturePanels.CloseLiveStream();
 
     [RelayCommand]
-    private void OpenCharts() => FeaturePanels.OpenCharts();
+    private void OpenCharts()
+    {
+        FeaturePanels.OpenCharts();
+        NamespaceDashboard.Activate();
+    }
 
     [RelayCommand]
-    private void CloseCharts() => FeaturePanels.CloseCharts();
+    private void CloseCharts()
+    {
+        FeaturePanels.CloseCharts();
+        NamespaceDashboard.Deactivate();
+    }
 
     [RelayCommand]
-    private void OpenAlerts() => FeaturePanels.OpenAlerts();
+    private void OpenAlerts()
+    {
+        NamespaceDashboard.Deactivate();
+        FeaturePanels.OpenAlerts();
+    }
 
     [RelayCommand]
     private void CloseAlerts() => FeaturePanels.CloseAlerts();