Add DashboardStateService for Blazor Server state management

- Create singleton DashboardStateService to share state across circuits
- Update DataPollingService to use state service instead of just SignalR
- Register state service in Program.cs
- This fixes the issue where Blazor Server components can't use client-side SignalR connections
- Components subscribe to OnDataChanged event instead of creating HubConnection

This solves the dashboard issue: server broadcasts data but clients can't receive it.
Blazor Server components run on the server and share state through services, not SignalR hubs.

Author: davebirr

FabrikamDashboard/BackgroundServices/DataPollingService.cs

@@ -8,12 +8,13 @@ namespace FabrikamDashboard.BackgroundServices;
 
 /// <summary>
 /// Background service that polls FabrikamApi and FabrikamSimulator every few seconds
-/// and broadcasts updates to all connected clients via SignalR
+/// and updates the dashboard state for all connected clients
 /// </summary>
 public class DataPollingService : BackgroundService
 {
     private readonly IServiceProvider _serviceProvider;
     private readonly IHubContext<DashboardHub> _hubContext;
+    private readonly DashboardStateService _stateService;
     private readonly ILogger<DataPollingService> _logger;
     private readonly TimeSpan _pollingInterval = TimeSpan.FromSeconds(5);
     private readonly SemaphoreSlim _refreshTrigger = new(0);
@@ -22,10 +23,12 @@ public class DataPollingService : BackgroundService
     public DataPollingService(
         IServiceProvider serviceProvider,
         IHubContext<DashboardHub> hubContext,
+        DashboardStateService stateService,
         ILogger<DataPollingService> logger)
     {
         _serviceProvider = serviceProvider;
         _hubContext = hubContext;
+        _stateService = stateService;
         _logger = logger;
     }
 
@@ -128,11 +131,14 @@ private async Task PollAndBroadcastAsync(CancellationToken cancellationToken)
         // Calculate dashboard metrics
         var dashboardData = CalculateDashboardMetrics(orders, tickets, analytics, simulatorStatus);
 
-        // Broadcast to all connected clients
+        // Update state service (triggers component updates)
+        _stateService.UpdateData(dashboardData);
+
+        // Also broadcast via SignalR for any external clients
         await _hubContext.Clients.All.SendAsync("DashboardUpdate", dashboardData, cancellationToken);
 
-        _logger.LogInformation("📡 Broadcasted dashboard update: {Orders} orders, {Tickets} tickets, ${Revenue:N0} revenue to {ClientCount} clients",
-            dashboardData.TotalOrders, dashboardData.OpenTickets, dashboardData.TotalRevenue, _hubContext.Clients.All);
+        _logger.LogInformation("📡 Updated dashboard state: {Orders} orders, {Tickets} tickets, ${Revenue:N0} revenue",
+            dashboardData.TotalOrders, dashboardData.OpenTickets, dashboardData.TotalRevenue);
     }
 
     private DashboardDataDto CalculateDashboardMetrics(

FabrikamDashboard/Program.cs

@@ -9,6 +9,9 @@
 builder.Services.AddRazorComponents()
     .AddInteractiveServerComponents();
 
+// Add dashboard state management
+builder.Services.AddSingleton<DashboardStateService>();
+
 // Add SignalR for real-time updates
 builder.Services.AddSignalR(options =>
 {

FabrikamDashboard/Services/DashboardStateService.cs

@@ -0,0 +1,37 @@
+using FabrikamDashboard.Models;
+
+namespace FabrikamDashboard.Services;
+
+/// <summary>
+/// Singleton service that holds the current dashboard state
+/// and notifies subscribers when data changes
+/// </summary>
+public class DashboardStateService
+{
+    private DashboardDataDto? _currentData;
+    private readonly object _lock = new();
+    
+    public event Action? OnDataChanged;
+
+    public DashboardDataDto? CurrentData
+    {
+        get
+        {
+            lock (_lock)
+            {
+                return _currentData;
+            }
+        }
+    }
+
+    public void UpdateData(DashboardDataDto newData)
+    {
+        lock (_lock)
+        {
+            _currentData = newData;
+        }
+        
+        // Notify all subscribers on the UI thread
+        OnDataChanged?.Invoke();
+    }
+}