Updated Status bar to only trigger an update when there is value changes

Author: jschick04

src/EventLogExpert.UI.Tests/Store/StatusBar/StatusBarStoreTests.cs

@@ -189,6 +189,23 @@ public void ReduceSetEventsLoading_WithNewActivity_ShouldAddActivity()
         Assert.Equal((100, 5), result.EventsLoading[activityId]);
     }
 
+    [Fact]
+    public void ReduceSetEventsLoading_WithUnchangedValues_ShouldReturnSameState()
+    {
+        var activityId = Guid.NewGuid();
+
+        var state = new StatusBarState
+        {
+            EventsLoading = ImmutableDictionary<Guid, (int, int)>.Empty.Add(activityId, (100, 5))
+        };
+
+        var action = new StatusBarAction.SetEventsLoading(activityId, 100, 5);
+
+        var result = StatusBarReducers.ReduceSetEventsLoading(state, action);
+
+        Assert.Same(state, result);
+    }
+
     [Fact]
     public void ReduceSetEventsLoading_WithZeroCount_ShouldRemoveActivity()
     {

src/EventLogExpert.UI/Store/EventLog/EventLogEffects.cs

@@ -144,7 +144,7 @@ public async Task HandleOpenLog(EventLogAction.OpenLog action, IDispatcher dispa
             _ => { dispatcher.Dispatch(new StatusBarAction.SetEventsLoading(activityId, events.Count, failed)); },
             null,
             TimeSpan.Zero,
-            TimeSpan.FromSeconds(1));
+            TimeSpan.FromSeconds(3));
 
         using var reader = new EventLogReader(action.LogName, action.PathType, filterState?.Value.IsXmlEnabled ?? false);
 

src/EventLogExpert.UI/Store/StatusBar/StatusBarReducers.cs

@@ -27,10 +27,9 @@ public static StatusBarState ReduceClearStatus(StatusBarState state, StatusBarAc
     [ReducerMethod]
     public static StatusBarState ReduceSetEventsLoading(StatusBarState state, StatusBarAction.SetEventsLoading action)
     {
-        return state with
-        {
-            EventsLoading = CommonLoadingReducer(state.EventsLoading, action.ActivityId, action.Count, action.FailedCount)
-        };
+        var newLoading = CommonLoadingReducer(state.EventsLoading, action.ActivityId, action.Count, action.FailedCount);
+
+        return ReferenceEquals(newLoading, state.EventsLoading) ? state : state with { EventsLoading = newLoading };
     }
 
     [ReducerMethod]
@@ -44,11 +43,13 @@ public static StatusBarState
         int count,
         int failedCount)
     {
-        if (loadingEntries.ContainsKey(activityId))
+        if (loadingEntries.TryGetValue(activityId, out var existing) && existing == (count, failedCount))
         {
-            loadingEntries = loadingEntries.Remove(activityId);
+            return loadingEntries;
         }
 
-        return count == 0 ? loadingEntries : loadingEntries.Add(activityId, (count, failedCount));
+        var updated = loadingEntries.Remove(activityId);
+
+        return count == 0 ? updated : updated.Add(activityId, (count, failedCount));
     }
 }

src/EventLogExpert/Components/StatusBar.razor

@@ -1,17 +1,8 @@
-@using EventLogExpert.UI.Store.EventLog
-@using EventLogExpert.UI.Store.EventTable
-@using EventLogExpert.UI.Store.FilterPane
-@using EventLogExpert.UI.Store.StatusBar
-@using EventLogExpert.UI
+@using EventLogExpert.UI
 @inherits FluxorComponent
 
-@inject IState<EventLogState> EventLogState
-@inject IState<EventTableState> EventTableState
-@inject IState<FilterPaneState> FilterPaneState
-@inject IState<StatusBarState> StatusBarState
-
 <div class="status-bar">
-    @foreach (var loadingProgress in StatusBarState.Value.EventsLoading)
+    @foreach (var loadingProgress in _statusBarState.EventsLoading)
     {
         <span>Loading: @loadingProgress.Value.Item1</span>
 
@@ -21,42 +12,42 @@
         }
     }
 
-    <span>Events Loaded: @EventLogState.Value.ActiveLogs.Values.Sum(log => log.Events.Count)</span>
+    <span>Events Loaded: @_eventLogState.ActiveLogs.Values.Sum(log => log.Events.Count)</span>
 
-    @if (EventTableState.Value.ActiveEventLogId is not null && FilterMethods.IsFilteringEnabled(EventLogState.Value.AppliedFilter))
+    @if (_eventTableState.ActiveEventLogId is not null && FilterMethods.IsFilteringEnabled(_eventLogState.AppliedFilter))
     {
-        var activeTable = EventTableState.Value.EventTables.FirstOrDefault(table => table.Id == EventTableState.Value.ActiveEventLogId);
+        var activeTable = _eventTableState.EventTables.FirstOrDefault(table => table.Id == _eventTableState.ActiveEventLogId);
 
         if (activeTable is null) { return; }
 
         var totalEvents = activeTable.IsCombined ?
-            EventLogState.Value.ActiveLogs.Sum(l => l.Value.Events.Count) :
-            EventLogState.Value.ActiveLogs[activeTable.LogName].Events.Count;
+            _eventLogState.ActiveLogs.Sum(l => l.Value.Events.Count) :
+            _eventLogState.ActiveLogs[activeTable.LogName].Events.Count;
 
         var filteredEvents = activeTable.DisplayedEvents.Count;
 
         <span>Visible: @(filteredEvents) Hidden by filter: @(totalEvents - filteredEvents)</span>
     }
 
-    @if (EventLogState.Value.ActiveLogs.Values.Any(l => l.Type == PathType.LogName))
+    @if (_eventLogState.ActiveLogs.Values.Any(l => l.Type == PathType.LogName))
     {
-        @if (EventLogState.Value.ContinuouslyUpdate)
+        @if (_eventLogState.ContinuouslyUpdate)
         {
             <span>Continuously Updating</span>
         }
         else
         {
-            <span>New Events: @EventLogState.Value.NewEventBuffer.Count</span>
+            <span>New Events: @_eventLogState.NewEventBuffer.Count</span>
 
-            @if (EventLogState.Value.NewEventBufferIsFull)
+            @if (_eventLogState.NewEventBufferIsFull)
             {
                 <span>Buffer Full</span>
             }
         }
     }
 
-    @if (!string.IsNullOrEmpty(StatusBarState.Value.ResolverStatus))
+    @if (!string.IsNullOrEmpty(_statusBarState.ResolverStatus))
     {
-        <span>@StatusBarState.Value.ResolverStatus</span>
+        <span>@_statusBarState.ResolverStatus</span>
     }
 </div>

src/EventLogExpert/Components/StatusBar.razor.cs

@@ -0,0 +1,52 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.UI.Store.EventLog;
+using EventLogExpert.UI.Store.EventTable;
+using EventLogExpert.UI.Store.FilterPane;
+using EventLogExpert.UI.Store.StatusBar;
+using Fluxor;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.Components;
+
+public sealed partial class StatusBar
+{
+    private EventLogState _eventLogState = null!;
+    private EventTableState _eventTableState = null!;
+    private FilterPaneState _filterPaneState = null!;
+    private StatusBarState _statusBarState = null!;
+
+    [Inject] private IState<EventLogState> EventLogState { get; set; } = null!;
+
+    [Inject] private IState<EventTableState> EventTableState { get; set; } = null!;
+
+    [Inject] private IState<FilterPaneState> FilterPaneState { get; set; } = null!;
+
+    [Inject] private IState<StatusBarState> StatusBarState { get; set; } = null!;
+
+    protected override void OnInitialized()
+    {
+        base.OnInitialized();
+
+        _eventLogState = EventLogState.Value;
+        _eventTableState = EventTableState.Value;
+        _filterPaneState = FilterPaneState.Value;
+        _statusBarState = StatusBarState.Value;
+    }
+
+    protected override bool ShouldRender()
+    {
+        if (ReferenceEquals(EventLogState.Value, _eventLogState) &&
+            ReferenceEquals(EventTableState.Value, _eventTableState) &&
+            ReferenceEquals(FilterPaneState.Value, _filterPaneState) &&
+            ReferenceEquals(StatusBarState.Value, _statusBarState)) { return false; }
+
+        _eventLogState = EventLogState.Value;
+        _eventTableState = EventTableState.Value;
+        _filterPaneState = FilterPaneState.Value;
+        _statusBarState = StatusBarState.Value;
+
+        return true;
+    }
+}