Updated provider lock with a simpler pattern

Author: jschick04

src/EventLogExpert.Eventing/EventResolvers/EventProviderDatabaseEventResolver.cs

@@ -73,73 +73,49 @@ public void ResolveProviderDetails(EventRecord eventRecord)
         ObjectDisposedException.ThrowIf(IsDisposed, nameof(EventProviderDatabaseEventResolver));
 
         // Fast path: ConcurrentDictionary is thread-safe for reads, so we can check
-        // without any lock. This avoids serializing all 8 parallel reader threads on
-        // the UpgradeableReadLock for providers that are already cached.
+        // without any lock. This avoids serializing all parallel reader threads for
+        // providers that are already cached.
         if (ProviderDetails.ContainsKey(eventRecord.ProviderName)) { return; }
 
-        ProviderDetailsLock.EnterUpgradeableReadLock();
-
-        try
+        using (ProviderDetailsLock.EnterScope())
         {
             // Re-check after acquiring lock - another thread may have added this provider
-            if (ProviderDetails.ContainsKey(eventRecord.ProviderName))
-            {
-                return;
-            }
+            if (ProviderDetails.ContainsKey(eventRecord.ProviderName)) { return; }
 
-            ProviderDetailsLock.EnterWriteLock();
-
-            try
+            // Use EnterScope() for exception-safe lock management
+            using (_databaseAccessLock.EnterScope())
             {
-                // Triple-check after acquiring write lock
-                if (ProviderDetails.ContainsKey(eventRecord.ProviderName))
-                {
-                    return;
-                }
+                // Check disposed inside the database lock to prevent race with Dispose().
+                // This ensures we don't proceed if Dispose() has swapped out _dbContexts.
+                ObjectDisposedException.ThrowIf(IsDisposed, nameof(EventProviderDatabaseEventResolver));
 
-                // Use EnterScope() for exception-safe lock management
-                using (_databaseAccessLock.EnterScope())
+                foreach (var dbContext in _dbContexts)
                 {
-                    // Check disposed inside the database lock to prevent race with Dispose().
-                    // This ensures we don't proceed if Dispose() has swapped out _dbContexts.
-                    ObjectDisposedException.ThrowIf(IsDisposed, nameof(EventProviderDatabaseEventResolver));
-
-                    foreach (var dbContext in _dbContexts)
-                    {
-                        // Use EF.Functions.Collate() with NOCASE on both sides for case-insensitive comparison.
-                        // Applying to both sides ensures the comparison is case-insensitive regardless of the
-                        // case in eventRecord.ProviderName. SQLite will use NOCASE collation for the comparison.
-                        // Note: The loop over databases is intentional for priority-based resolution.
-                        var details = dbContext.ProviderDetails.FirstOrDefault(p =>
-                            EF.Functions.Collate(p.ProviderName, "NOCASE") ==
-                            EF.Functions.Collate(eventRecord.ProviderName, "NOCASE"));
-
-                        if (details is null) { continue; }
-
-                        Logger?.Debug($"Resolved {eventRecord.ProviderName} provider from database {dbContext.Name}.");
-                        ProviderDetails.TryAdd(eventRecord.ProviderName, details);
-
-                        // Exit after first match - databases are sorted by priority (SortDatabases),
-                        // so the first database containing the provider is the preferred source.
-                        // TryAdd would prevent duplicates anyway, but breaking early avoids unnecessary queries.
-                        break;
-                    }
+                    // Use EF.Functions.Collate() with NOCASE on both sides for case-insensitive comparison.
+                    // Applying to both sides ensures the comparison is case-insensitive regardless of the
+                    // case in eventRecord.ProviderName. SQLite will use NOCASE collation for the comparison.
+                    // Note: The loop over databases is intentional for priority-based resolution.
+                    var details = dbContext.ProviderDetails.FirstOrDefault(p =>
+                        EF.Functions.Collate(p.ProviderName, "NOCASE") ==
+                        EF.Functions.Collate(eventRecord.ProviderName, "NOCASE"));
+
+                    if (details is null) { continue; }
+
+                    Logger?.Debug($"Resolved {eventRecord.ProviderName} provider from database {dbContext.Name}.");
+                    ProviderDetails.TryAdd(eventRecord.ProviderName, details);
+
+                    // Exit after first match - databases are sorted by priority (SortDatabases),
+                    // so the first database containing the provider is the preferred source.
+                    // TryAdd would prevent duplicates anyway, but breaking early avoids unnecessary queries.
+                    break;
                 }
             }
-            finally
-            {
-                ProviderDetailsLock.ExitWriteLock();
-            }
 
             if (!ProviderDetails.ContainsKey(eventRecord.ProviderName))
             {
                 ProviderDetails.TryAdd(eventRecord.ProviderName, new ProviderDetails { ProviderName = eventRecord.ProviderName });
             }
         }
-        finally
-        {
-            ProviderDetailsLock.ExitUpgradeableReadLock();
-        }
     }
 
     /// <summary>

src/EventLogExpert.Eventing/EventResolvers/EventResolverBase.cs

@@ -48,7 +48,7 @@ public partial class EventResolverBase : IDisposable
     };
 
     protected readonly ConcurrentDictionary<string, ProviderDetails?> ProviderDetails = new();
-    protected readonly ReaderWriterLockSlim ProviderDetailsLock = new();
+    protected readonly Lock ProviderDetailsLock = new();
 
     private readonly IEventResolverCache? _cache;
     private readonly ITraceLogger? _logger;
@@ -113,27 +113,6 @@ protected virtual void Dispose(bool disposing)
         {
             return; // Already disposed by another thread
         }
-
-        // Attempt to dispose the lock to avoid leaking wait handles.
-        // If other threads are still waiting to acquire the lock (rare race condition),
-        // ReaderWriterLockSlim.Dispose() will throw SynchronizationLockException.
-        // In that case, we suppress the exception to avoid crashing during disposal.
-        // This is a pragmatic trade-off: accept a potential wait handle leak in an
-        // extremely rare concurrent disposal scenario rather than crash the application.
-        try
-        {
-            ProviderDetailsLock.Dispose();
-        }
-        catch (SynchronizationLockException)
-        {
-            // Lock is still being used by other threads. This is extremely rare but can happen
-            // in concurrent disposal scenarios. We suppress the exception to prevent disposal
-            // from throwing, accepting a potential wait handle leak as the lesser evil.
-        }
-        catch (ObjectDisposedException)
-        {
-            // Lock has already been disposed by another thread. Suppress to ensure disposal never throws.
-        }
     }
 
     private static void CleanupFormatting(ReadOnlySpan<char> unformattedString, ref Span<char> buffer, out int bufferIndex)

src/EventLogExpert.Eventing/EventResolvers/LocalProviderEventResolver.cs

@@ -23,31 +23,13 @@ public void ResolveProviderDetails(EventRecord eventRecord)
         // Fast path: ConcurrentDictionary is thread-safe for reads
         if (ProviderDetails.ContainsKey(eventRecord.ProviderName)) { return; }
 
-        ProviderDetailsLock.EnterUpgradeableReadLock();
-
-        try
+        using (ProviderDetailsLock.EnterScope())
         {
-            // Re-check after acquiring lock
             if (ProviderDetails.ContainsKey(eventRecord.ProviderName)) { return; }
 
-            ProviderDetailsLock.EnterWriteLock();
-
-            try
-            {
-                if (ProviderDetails.ContainsKey(eventRecord.ProviderName)) { return; }
-
-                var details = new EventMessageProvider(eventRecord.ProviderName, Logger).LoadProviderDetails();
+            var details = new EventMessageProvider(eventRecord.ProviderName, Logger).LoadProviderDetails();
 
-                ProviderDetails.TryAdd(eventRecord.ProviderName, details);
-            }
-            finally
-            {
-                ProviderDetailsLock.ExitWriteLock();
-            }
-        }
-        finally
-        {
-            ProviderDetailsLock.ExitUpgradeableReadLock();
+            ProviderDetails.TryAdd(eventRecord.ProviderName, details);
         }
     }
 }