Improves GetAllExpirationAsync performance

Optimizes GetAllExpirationAsync in HybridCacheClient and InMemoryCacheClient by first checking the local cache and then retrieving any missed keys from the distributed cache to reduce distributed cache calls.

Adds null checks and optimizes the handling of empty key lists to improve efficiency and prevent errors.

Author: niemyjski

src/Foundatio/Caching/HybridCacheClient.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -372,33 +373,35 @@ public async Task<bool> ExistsAsync(string key)
 
     public async Task<IDictionary<string, TimeSpan?>> GetAllExpirationAsync(IEnumerable<string> keys)
     {
-        if (keys == null)
+        if (keys is null)
             throw new ArgumentNullException(nameof(keys));
 
-        var keyList = keys.ToList();
-        var result = new Dictionary<string, TimeSpan?>(keyList.Count);
-        var misses = new List<string>();
+        string[] keysArray = keys.ToArray();
+        if (keysArray.Length is 0)
+            return ReadOnlyDictionary<string, TimeSpan?>.Empty;
 
-        foreach (var key in keyList)
+        var localExpirations = await _localCache.GetAllExpirationAsync(keysArray).AnyContext();
+        foreach (string key in localExpirations.Keys)
         {
-            if (await _localCache.ExistsAsync(key).AnyContext())
-            {
-                var expiration = await _localCache.GetExpirationAsync(key).AnyContext();
-                result[key] = expiration;
-            }
-            else
-            {
-                misses.Add(key);
-            }
+            _logger.LogTrace("Local cache hit: {Key}", key);
+            Interlocked.Increment(ref _localCacheHits);
         }
 
-        if (misses.Count > 0)
+        if (keysArray.Length == localExpirations.Count)
+            return localExpirations;
+
+        // Get the missed keys from the distributed cache.
+        string[] missedKeys = keysArray.Except(localExpirations.Keys).ToArray();
+        foreach (string key in missedKeys)
         {
-            var distributedExpirations = await _distributedCache.GetAllExpirationAsync(misses).AnyContext();
-            foreach (var kvp in distributedExpirations)
-                result[kvp.Key] = kvp.Value;
+            _logger.LogTrace("Local cache miss: {Key}", key);
         }
 
+        var result = new Dictionary<string, TimeSpan?>(localExpirations);
+        var distributedExpirations = await _distributedCache.GetAllExpirationAsync(missedKeys).AnyContext();
+        foreach (var kvp in distributedExpirations)
+            result[kvp.Key] = kvp.Value;
+
         return result.AsReadOnly();
     }
 
@@ -414,7 +417,7 @@ public async Task SetExpirationAsync(string key, TimeSpan expiresIn)
 
     public async Task SetAllExpirationAsync(IDictionary<string, TimeSpan?> expirations)
     {
-        if (expirations == null)
+        if (expirations is null)
             throw new ArgumentNullException(nameof(expirations));
 
         await _localCache.SetAllExpirationAsync(expirations).AnyContext();

src/Foundatio/Caching/InMemoryCacheClient.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;
@@ -955,12 +954,10 @@ public Task<bool> ExistsAsync(string key)
             throw new ArgumentNullException(nameof(keys));
 
         var result = new Dictionary<string, TimeSpan?>();
-        var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
-
         foreach (string key in keys)
         {
             if (String.IsNullOrEmpty(key))
-                continue;
+                throw new ArgumentNullException(nameof(key), "Key cannot be null or empty");
 
             if (!_memory.TryGetValue(key, out var existingEntry))
             {
@@ -983,10 +980,9 @@ public Task<bool> ExistsAsync(string key)
                 result[key] = existingEntry.ExpiresAt.Value.Subtract(_timeProvider.GetUtcNow().UtcDateTime);
         }
 
-        return Task.FromResult<IDictionary<string, TimeSpan?>>(new ReadOnlyDictionary<string, TimeSpan?>(result));
+        return Task.FromResult<IDictionary<string, TimeSpan?>>(result.AsReadOnly());
     }
 
-
     public async Task SetExpirationAsync(string key, TimeSpan expiresIn)
     {
         if (String.IsNullOrEmpty(key))
@@ -1000,9 +996,9 @@ public async Task SetExpirationAsync(string key, TimeSpan expiresIn)
             return;
         }
 
-        Interlocked.Increment(ref _writes);
-        if (_memory.TryGetValue(key, out var existingEntry))
+        if (_memory.TryGetValue(key, out var existingEntry) && existingEntry.ExpiresAt != expiresAt)
         {
+            Interlocked.Increment(ref _writes);
             existingEntry.ExpiresAt = expiresAt;
             await StartMaintenanceAsync().AnyContext();
         }
@@ -1013,7 +1009,7 @@ public async Task SetAllExpirationAsync(IDictionary<string, TimeSpan?> expiratio
         if (expirations is null)
             throw new ArgumentNullException(nameof(expirations));
 
-        if (expirations.Count == 0)
+        if (expirations.Count is 0)
             return;
 
         var utcNow = _timeProvider.GetUtcNow().UtcDateTime;
@@ -1022,16 +1018,17 @@ public async Task SetAllExpirationAsync(IDictionary<string, TimeSpan?> expiratio
         foreach (var kvp in expirations)
         {
             if (String.IsNullOrEmpty(kvp.Key))
-                continue;
+                throw new ArgumentNullException(nameof(kvp.Key), "Key cannot be null or empty");
 
             if (!_memory.TryGetValue(kvp.Key, out var existingEntry))
                 continue;
 
-            Interlocked.Increment(ref _writes);
-
             if (kvp.Value is null)
             {
-                // Null TimeSpan clears the expiration, making the key persistent
+                if (existingEntry.ExpiresAt is null)
+                    continue;
+
+                Interlocked.Increment(ref _writes);
                 existingEntry.ExpiresAt = null;
                 updated++;
             }
@@ -1042,8 +1039,9 @@ public async Task SetAllExpirationAsync(IDictionary<string, TimeSpan?> expiratio
                 {
                     RemoveExpiredKey(kvp.Key);
                 }
-                else
+                else if (existingEntry.ExpiresAt != expiresAt)
                 {
+                    Interlocked.Increment(ref _writes);
                     existingEntry.ExpiresAt = expiresAt;
                     updated++;
                 }