Updated Load Events to use an immutable array

Author: jschick04

src/EventLogExpert.Eventing/EventResolvers/EventResolverBase.cs

@@ -599,8 +599,8 @@ private string ResolveDescription(EventRecord eventRecord, ProviderDetails? deta
             return FormatDescription(properties, modernEvent?.Description, details.Parameters);
         }
 
-        // Legacy provider message lookup using indexed dictionary
-        var legacyMessages = details.GetMessagesByShortId((short)eventRecord.Id);
+        // Legacy provider message lookup
+        var legacyMessages = details.GetMessagesByShortId(eventRecord.Id);
 
         if (legacyMessages.Count == 1)
         {
@@ -658,8 +658,7 @@ private string ResolveTaskName(EventRecord eventRecord, ProviderDetails? details
             return _cache?.GetOrAddValue(taskName) ?? taskName;
         }
 
-        // Use indexed lookup instead of linear scan with .ToList()
-        var messagesByShortId = details.GetMessagesByShortId((short)eventRecord.Task);
+        var messagesByShortId = details.GetMessagesByShortId(eventRecord.Task.Value);
 
         List<MessageModel>? potentialTaskNames = null;
 

src/EventLogExpert.Eventing/Providers/ProviderDetails.cs

@@ -10,7 +10,7 @@ public class ProviderDetails
     private IReadOnlyList<EventModel> _events = [];
     private IReadOnlyList<MessageModel> _messages = [];
     private Dictionary<long, List<EventModel>>? _eventsByIdLookup;
-    private Dictionary<short, List<MessageModel>>? _messagesByShortIdLookup;
+    private Dictionary<int, List<MessageModel>>? _messagesByShortIdLookup;
 
     public string ProviderName { get; set; } = string.Empty;
 
@@ -53,8 +53,10 @@ internal IReadOnlyList<EventModel> GetEventsById(long id)
         return _eventsByIdLookup.TryGetValue(id, out var list) ? list : [];
     }
 
-    /// <summary>Gets messages matching the given ShortId using a pre-built lookup dictionary.</summary>
-    internal IReadOnlyList<MessageModel> GetMessagesByShortId(short shortId)
+    /// <summary>Gets messages matching the given ShortId using a pre-built lookup dictionary.
+    /// The lookup uses int keys to preserve the original implicit promotion semantics
+    /// when comparing ShortId (short) with event record Id/Task (ushort).</summary>
+    internal IReadOnlyList<MessageModel> GetMessagesByShortId(int shortId)
     {
         _messagesByShortIdLookup ??= BuildMessagesByShortIdLookup();
 
@@ -79,16 +81,18 @@ private Dictionary<long, List<EventModel>> BuildEventsByIdLookup()
         return lookup;
     }
 
-    private Dictionary<short, List<MessageModel>> BuildMessagesByShortIdLookup()
+    private Dictionary<int, List<MessageModel>> BuildMessagesByShortIdLookup()
     {
-        var lookup = new Dictionary<short, List<MessageModel>>();
+        var lookup = new Dictionary<int, List<MessageModel>>();
 
         foreach (var m in _messages)
         {
-            if (!lookup.TryGetValue(m.ShortId, out var list))
+            int key = m.ShortId;
+
+            if (!lookup.TryGetValue(key, out var list))
             {
                 list = [];
-                lookup[m.ShortId] = list;
+                lookup[key] = list;
             }
 
             list.Add(m);

src/EventLogExpert.UI.Tests/Store/EventLog/EventLogEffectsTests.cs

@@ -32,10 +32,7 @@ public async Task HandleAddEvent_WhenBufferReachesMaxEvents_ShouldSetFullFlag()
         var logData = new EventLogData(Constants.LogNameTestLog, PathType.LogName, []);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
-        var (effects, mockDispatcher) = CreateEffects(
-            false,
-            activeLogs,
-            existingBuffer);
+        var (effects, mockDispatcher) = CreateEffects(false, activeLogs, existingBuffer);
 
         var newEvent = EventUtils.CreateTestEvent(1000, logName: Constants.LogNameTestLog);
         var action = new EventLogAction.AddEvent(newEvent);
@@ -145,11 +142,10 @@ public async Task HandleCloseLog_ShouldRemoveLogAndDispatchCloseAction()
     public async Task HandleLoadEvents_ShouldFilterAndDispatchUpdateTable()
     {
         // Arrange
-        var events = new List<DisplayEventModel>
-        {
+        var events = ImmutableArray.Create(
             EventUtils.CreateTestEvent(100, level: Constants.EventLevelError),
             EventUtils.CreateTestEvent(200, level: Constants.EventLevelInformation)
-        };
+        );
 
         var logData = new EventLogData(Constants.LogNameTestLog, PathType.LogName, []);
         var (effects, mockDispatcher, _, _, mockFilterService) = CreateEffectsWithServices();

src/EventLogExpert.UI.Tests/Store/EventLog/EventLogStoreTests.cs

@@ -106,18 +106,14 @@ public void EventLogAction_LoadEvents_ShouldStoreLogDataAndEvents()
         // Arrange
         var logData = new EventLogData(Constants.LogNameTestLog, PathType.LogName, []);
 
-        var events = new List<DisplayEventModel>
-        {
-            EventUtils.CreateTestEvent(100),
-            EventUtils.CreateTestEvent(200)
-        };
+        var events = ImmutableArray.Create(EventUtils.CreateTestEvent(100), EventUtils.CreateTestEvent(200));
 
         // Act
         var action = new EventLogAction.LoadEvents(logData, events);
 
         // Assert
         Assert.Equal(logData, action.LogData);
-        Assert.Equal(2, action.Events.Count());
+        Assert.Equal(2, action.Events.Length);
     }
 
     [Fact]
@@ -352,12 +348,11 @@ public void LoadEventsAndSelect_ShouldWorkCorrectly()
 
         var logData = state.ActiveLogs[Constants.LogNameTestLog];
 
-        var events = new List<DisplayEventModel>
-        {
+        var events = ImmutableArray.Create(
             EventUtils.CreateTestEvent(100),
             EventUtils.CreateTestEvent(200),
             EventUtils.CreateTestEvent(300)
-        };
+        );
 
         // Act - Load events
         state = EventLogReducers.ReduceLoadEvents(state, new EventLogAction.LoadEvents(logData, events));
@@ -574,11 +569,7 @@ public void ReduceLoadEvents_ShouldUpdateLogWithEvents()
             ActiveLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData)
         };
 
-        var events = new List<DisplayEventModel>
-        {
-            EventUtils.CreateTestEvent(100),
-            EventUtils.CreateTestEvent(200)
-        };
+        var events = ImmutableArray.Create(EventUtils.CreateTestEvent(100), EventUtils.CreateTestEvent(200));
 
         var action = new EventLogAction.LoadEvents(logData, events);
 
@@ -600,22 +591,19 @@ public void ReduceLoadEvents_ShouldIsolateStateFromOriginalList()
             ActiveLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData)
         };
 
-        var events = new List<DisplayEventModel>
-        {
-            EventUtils.CreateTestEvent(100),
-            EventUtils.CreateTestEvent(200)
-        };
+        var events = ImmutableArray.Create(EventUtils.CreateTestEvent(100), EventUtils.CreateTestEvent(200));
 
         var action = new EventLogAction.LoadEvents(logData, events);
 
         // Act
         var newState = EventLogReducers.ReduceLoadEvents(state, action);
 
-        // Mutate the original list after state was created
-        events.Add(EventUtils.CreateTestEvent(300));
+        // ImmutableArray is inherently isolated — creating a new one doesn't affect the state
+        var extendedEvents = events.Add(EventUtils.CreateTestEvent(300));
 
-        // Assert - state should not reflect the mutation
+        // Assert - state should not reflect the extension
         Assert.Equal(2, newState.ActiveLogs[Constants.LogNameTestLog].Events.Count);
+        Assert.Equal(3, extendedEvents.Length);
     }
 
     [Fact]

src/EventLogExpert.UI/FilterMethods.cs

@@ -78,9 +78,7 @@ public static IReadOnlyList<DisplayEventModel> SortEvents(
 
     internal static Comparison<DisplayEventModel> GetComparer(ColumnName? orderBy, bool isDescending)
     {
-        // To reverse sort direction we swap operands (a,b) rather than negating the
-        // comparison result, because Compare/CompareTo may return arbitrary negative
-        // values (not just -1) and multiplying by -1 can overflow int.MinValue.
+        // To reverse sort direction we swap operands (a,b)
         Comparison<DisplayEventModel> comparer = orderBy switch
         {
             ColumnName.Level => (a, b) => WithTieBreaker(string.Compare(a.Level, b.Level, StringComparison.Ordinal), a, b),
@@ -106,11 +104,10 @@ internal static Comparison<DisplayEventModel> GetComparer(ColumnName? orderBy, b
         return isDescending ? (a, b) => comparer(b, a) : comparer;
     }
 
-    /// <summary>Falls back to RecordId, then OwningLog and Id to guarantee a total order for List.Sort stability.</summary>
     private static int WithTieBreaker(int primaryResult, DisplayEventModel a, DisplayEventModel b) =>
         primaryResult != 0 ? primaryResult : FallbackTieBreaker(Nullable.Compare(a.RecordId, b.RecordId), a, b);
 
-    /// <summary>Ensures distinct events never compare as equal so List.Sort (unstable) produces deterministic results.</summary>
+    /// <summary>Falls back to RecordId, then OwningLog (for combined logs) to guarantee a total order for List.Sort stability.</summary>
     private static int FallbackTieBreaker(int recordIdResult, DisplayEventModel a, DisplayEventModel b) =>
         recordIdResult != 0 ? recordIdResult : string.Compare(a.OwningLog, b.OwningLog, StringComparison.Ordinal);
 

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

@@ -20,7 +20,7 @@ public sealed record CloseAll;
 
     public sealed record CloseLog(EventLogId LogId, string LogName);
 
-    public sealed record LoadEvents(EventLogData LogData, IReadOnlyList<DisplayEventModel> Events);
+    public sealed record LoadEvents(EventLogData LogData, ImmutableArray<DisplayEventModel> Events);
 
     public sealed record LoadNewEvents;
 

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

@@ -200,7 +200,7 @@ await Parallel.ForEachAsync(
         dispatcher.Dispatch(
             new EventLogAction.LoadEvents(
                 logData,
-                events.OrderByDescending(e => e.RecordId).ToList()));
+                [.. events.OrderByDescending(e => e.RecordId)]));
 
         dispatcher.Dispatch(new StatusBarAction.SetEventsLoading(activityId, 0, 0));
 

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

@@ -53,7 +53,7 @@ public static EventLogState ReduceLoadEvents(EventLogState state, EventLogAction
         {
             ActiveLogs = newLogsCollection.Add(
                 action.LogData.Name,
-                action.LogData with { Events = action.Events.ToImmutableArray() })
+                action.LogData with { Events = action.Events })
         };
     }