Removed IsLoading for table updates with multi log loading

Author: jschick04

src/EventLogExpert.UI.Tests/Services/FilterServiceTests.cs

@@ -99,6 +99,72 @@ public void FilterActiveLogs_WhenNoFiltersEnabled_ShouldReturnAllEvents()
         Assert.Equal(2, result[logId].Count);
     }
 
+    [Theory]
+    [InlineData(100)]
+    [InlineData(9_999)]
+    [InlineData(10_000)]
+    [InlineData(10_001)]
+    public void GetFilteredEvents_WhenFilteringEnabled_ShouldFilterCorrectlyAcrossThreshold(int eventCount)
+    {
+        // Arrange
+        var filterService = CreateFilterService();
+        var baseTime = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
+
+        // Create events: half before cutoff, half after
+        var events = Enumerable.Range(0, eventCount)
+            .Select(i => EventUtils.CreateTestEvent(
+                id: i,
+                timeCreated: baseTime.AddMinutes(i),
+                recordId: i))
+            .ToList();
+
+        var cutoff = baseTime.AddMinutes(eventCount / 2);
+        var dateFilter = new FilterDateModel { After = cutoff, Before = baseTime.AddMinutes(eventCount), IsEnabled = true };
+        var eventFilter = new EventFilter(dateFilter, []);
+
+        // Act
+        var result = filterService.GetFilteredEvents(events, eventFilter);
+
+        // Assert — should return only events at or after the cutoff
+        var expectedCount = events.Count(e => e.TimeCreated >= cutoff && e.TimeCreated <= baseTime.AddMinutes(eventCount));
+        Assert.Equal(expectedCount, result.Count);
+        Assert.All(result, e => Assert.True(e.TimeCreated >= cutoff));
+    }
+
+    [Fact]
+    public void GetFilteredEvents_WhenFilteringSmallCollection_ShouldReturnSameResultsAsLargeCollection()
+    {
+        // Arrange — verify both paths produce identical results
+        var filterService = CreateFilterService();
+        var baseTime = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
+        var cutoff = baseTime.AddMinutes(50);
+
+        var dateFilter = new FilterDateModel { After = cutoff, Before = baseTime.AddMinutes(200), IsEnabled = true };
+        var eventFilter = new EventFilter(dateFilter, []);
+
+        // Small collection (sequential path)
+        var smallEvents = Enumerable.Range(0, 100)
+            .Select(i => EventUtils.CreateTestEvent(id: i, timeCreated: baseTime.AddMinutes(i), recordId: i))
+            .ToList();
+
+        // Large collection (PLINQ path) with the same first 100 events
+        var largeEvents = Enumerable.Range(0, 15_000)
+            .Select(i => EventUtils.CreateTestEvent(id: i, timeCreated: baseTime.AddMinutes(i), recordId: i))
+            .ToList();
+
+        // Act
+        var smallResult = filterService.GetFilteredEvents(smallEvents, eventFilter);
+        var largeResult = filterService.GetFilteredEvents(largeEvents, eventFilter);
+
+        // Assert — small result should match the first 100 events' filtered subset
+        var expectedSmallCount = smallEvents.Count(e => e.TimeCreated >= cutoff && e.TimeCreated <= baseTime.AddMinutes(200));
+        Assert.Equal(expectedSmallCount, smallResult.Count);
+
+        // Large result should include the same events as small result (plus more from the larger set)
+        Assert.True(largeResult.Count > smallResult.Count);
+        Assert.All(smallResult, e => Assert.Contains(e, largeResult));
+    }
+
     [Fact]
     public void GetFilteredEvents_WhenNoFiltersEnabled_ShouldReturnAllEvents()
     {

src/EventLogExpert.UI/FilterMethods.cs

@@ -73,7 +73,7 @@ public static IReadOnlyList<DisplayEventModel> SortEvents(
         var sorted = new List<DisplayEventModel>(events);
         sorted.Sort(GetComparer(orderBy, isDescending));
 
-        return sorted;
+        return sorted.AsReadOnly();
     }
 
     internal static Comparison<DisplayEventModel> GetComparer(ColumnName? orderBy, bool isDescending)

src/EventLogExpert.UI/Services/FilterService.cs

@@ -47,13 +47,15 @@ public IReadOnlyList<DisplayEventModel> GetFilteredEvents(
             return collection
                 .Where(e => e.FilterByDate(eventFilter.DateFilter)
                     .Filter(eventFilter.Filters, IsXmlEnabled))
-                .ToList();
+                .ToList()
+                .AsReadOnly();
         }
 
         return events.AsParallel()
             .Where(e => e.FilterByDate(eventFilter.DateFilter)
                 .Filter(eventFilter.Filters, IsXmlEnabled))
-            .ToList();
+            .ToList()
+            .AsReadOnly();
     }
 
     public bool TryParse(FilterModel filterModel, out string comparison)

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

@@ -65,7 +65,7 @@ public Task HandleAddEvent(EventLogAction.AddEvent action, IDispatcher dispatche
 
             var full = updatedBuffer.Count >= EventLogState.MaxNewEvents;
 
-            dispatcher.Dispatch(new EventLogAction.AddEventBuffered(updatedBuffer, full));
+            dispatcher.Dispatch(new EventLogAction.AddEventBuffered(updatedBuffer.AsReadOnly(), full));
         }
 
         return Task.CompletedTask;
@@ -151,7 +151,7 @@ public async Task HandleOpenLog(EventLogAction.OpenLog action, IDispatcher dispa
         List<DisplayEventModel> events = [];
 
         await using Timer timer = new(
-            _ => { dispatcher.Dispatch(new StatusBarAction.SetEventsLoading(activityId, Volatile.Read(ref resolved), failed)); },
+            _ => { dispatcher.Dispatch(new StatusBarAction.SetEventsLoading(activityId, Volatile.Read(ref resolved), Volatile.Read(ref failed))); },
             null,
             TimeSpan.Zero,
             TimeSpan.FromSeconds(3));
@@ -200,6 +200,9 @@ await Parallel.ForEachAsync(
 
                     try
                     {
+                        List<DisplayEventModel> localBatch = new(batch.Length);
+                        int localResolved = 0;
+
                         foreach (var @event in batch)
                         {
                             token.ThrowIfCancellationRequested();
@@ -215,17 +218,21 @@ await Parallel.ForEachAsync(
                                     continue;
                                 }
 
-                                var resolvedEvent = eventResolver.ResolveEvent(@event);
-
-                                lock (events) { events.Add(resolvedEvent); }
-
-                                Interlocked.Increment(ref resolved);
+                                localBatch.Add(eventResolver.ResolveEvent(@event));
+                                localResolved++;
                             }
                             catch (Exception ex)
                             {
                                 _logger?.Warn($"Failed to resolve RecordId: {@event.RecordId}, {ex.Message}");
                             }
                         }
+
+                        if (localBatch.Count > 0)
+                        {
+                            lock (events) { events.AddRange(localBatch); }
+
+                            Interlocked.Add(ref resolved, localResolved);
+                        }
                     }
                     finally
                     {
@@ -237,17 +244,31 @@ await Parallel.ForEachAsync(
 
             lastEvent = reader.LastBookmark;
         }
-        catch (TaskCanceledException)
+        catch (OperationCanceledException)
         {
+            await StopProducerAsync(producerTask);
+
             dispatcher.Dispatch(new EventLogAction.CloseLog(logData.Id, logData.Name));
             dispatcher.Dispatch(new StatusBarAction.ClearStatus(activityId));
 
             return;
         }
+        catch (Exception ex)
+        {
+            _logger?.Error($"Failed to load log {action.LogName}: {ex.Message}");
+
+            await StopProducerAsync(producerTask);
+
+            dispatcher.Dispatch(new EventLogAction.CloseLog(logData.Id, logData.Name));
+            dispatcher.Dispatch(new StatusBarAction.ClearStatus(activityId));
+            dispatcher.Dispatch(new StatusBarAction.SetResolverStatus($"Error: Failed to load {action.LogName}"));
+
+            return;
+        }
 
         events.Sort((a, b) => Comparer<long?>.Default.Compare(b.RecordId, a.RecordId));
 
-        dispatcher.Dispatch(new EventLogAction.LoadEvents(logData, events));
+        dispatcher.Dispatch(new EventLogAction.LoadEvents(logData, events.AsReadOnly()));
 
         dispatcher.Dispatch(new StatusBarAction.SetEventsLoading(activityId, 0, 0));
 
@@ -285,7 +306,7 @@ private static EventLogData AddEventsToOneLog(EventLogData logData, List<Display
     {
         eventsToAdd.AddRange(logData.Events);
 
-        return logData with { Events = eventsToAdd };
+        return logData with { Events = eventsToAdd.AsReadOnly() };
     }
 
     private static ImmutableDictionary<string, EventLogData> DistributeEventsToManyLogs(
@@ -320,6 +341,17 @@ private static ImmutableDictionary<string, EventLogData> DistributeEventsToManyL
         return newLogs;
     }
 
+    /// <summary>
+    ///     Awaits the producer task, suppressing all exceptions.
+    ///     The sole purpose is to ensure the producer has fully stopped before
+    ///     the reader is disposed. Any meaningful errors are handled by the caller.
+    /// </summary>
+    private static async Task StopProducerAsync(Task producerTask)
+    {
+        try { await producerTask; }
+        catch { /* Intentionally swallowed — caller handles error reporting */ }
+    }
+
     private void ProcessNewEventBuffer(EventLogState state, IDispatcher dispatcher)
     {
         var activeLogs = DistributeEventsToManyLogs(state.ActiveLogs, state.NewEventBuffer);

src/EventLogExpert.UI/Store/EventTable/EventTableReducers.cs

@@ -138,9 +138,9 @@ public static EventTableState ReduceUpdateCombinedEvents(EventTableState state)
     {
         if (state.EventTables.Count <= 1) { return state; }
 
-        if (state.EventTables.Any(table => table.IsLoading)) { return state; }
+        var existingCombinedTable = state.EventTables.FirstOrDefault(table => table.IsCombined);
 
-        var existingCombinedTable = state.EventTables.First(table => table.IsCombined);
+        if (existingCombinedTable is null) { return state; }
 
         var combinedEvents = GetCombinedEvents(
             state.EventTables
@@ -149,7 +149,9 @@ public static EventTableState ReduceUpdateCombinedEvents(EventTableState state)
             state.OrderBy ?? ColumnName.DateAndTime,
             state.IsDescending);
 
-        if (combinedEvents.SequenceEqual(existingCombinedTable.DisplayedEvents))
+        if (combinedEvents.Count == existingCombinedTable.DisplayedEvents.Count &&
+            combinedEvents.Select(e => e.RecordId)
+                .SequenceEqual(existingCombinedTable.DisplayedEvents.Select(e => e.RecordId)))
         {
             return state;
         }
@@ -204,7 +206,7 @@ public static EventTableState ReduceUpdateTable(EventTableState state, EventTabl
         };
     }
 
-    private static List<DisplayEventModel> GetCombinedEvents(
+    private static IReadOnlyList<DisplayEventModel> GetCombinedEvents(
         IEnumerable<IEnumerable<DisplayEventModel>> eventLists,
         ColumnName? orderBy = null,
         bool isDescending = false)
@@ -219,7 +221,7 @@ private static List<DisplayEventModel> GetCombinedEvents(
         // Sort in-place instead of creating a new list
         combinedEvents.Sort(FilterMethods.GetComparer(orderBy, isDescending));
 
-        return combinedEvents;
+        return combinedEvents.AsReadOnly();
     }
 
     private static EventTableState SortDisplayEvents(EventTableState state, ColumnName? orderBy, bool isDescending)