Fixes: Prevents ArgumentOutOfRangeException in DoMaintenance

Addresses a potential ArgumentOutOfRangeException in
`InMemoryCacheClient.DoMaintenanceAsync` when dealing with expired cache
entries that have a `DateTime.MinValue` expiration and the server's
timezone has a positive offset.

The issue arose during comparison of `expiresAt` (DateTime.MinValue)
with a DateTimeOffset. Now the DateTime.MinValue is converted using UtcDateTime which won't throw an exception for values before the Unix Epoch.

A test case is added to reproduce the error.

Fixes InMemoryCacheClient: DoMaintenance: Starting - InMemoryCacheClient 09:01.641 E: Error trying to find expired cache items: The UTC time represented when the offset is applied must be between year 0 and 10,000. (Parameter 'offset')

Fixes potential timezone conversion issues

Ensures correct DateTime comparisons in the InMemoryCacheClient maintenance process by using UtcDateTime.

Adds overflow protection to SafeAddMilliseconds for DateTime to prevent exceptions.
Adds tests for DateTimeExtensions to ensure overflow protection.

Removes unused usings

Cleans up the InMemoryCacheClientTests file by removing unused namespace imports.

Author: niemyjski

src/Foundatio/Caching/InMemoryCacheClient.cs

@@ -1611,7 +1611,6 @@ private string FindWorstSizeToUsageRatio()
             double accessWeight = Math.Log10(accessRecency);
 
             double wasteScore = sizeWeight + (ageWeight * 0.5) + (accessWeight * 2.0); // Access recency weighted more heavily
-
             if (wasteScore > worstRatio)
             {
                 worstRatio = wasteScore;
@@ -1626,7 +1625,9 @@ private string FindWorstSizeToUsageRatio()
     private async Task DoMaintenanceAsync()
     {
         _logger.LogTrace("DoMaintenance: Starting");
-        var utcNow = _timeProvider.GetUtcNow().SafeAddMilliseconds(50);
+
+        // NOTE: We want to ensure we are comparing DateTimes to avoid using the systems timezone for implicit conversion between DateTime and DateTimeOffset.
+        var utcNow = _timeProvider.GetUtcNow().UtcDateTime.SafeAddMilliseconds(50);
 
         // Remove expired items and items that are infrequently accessed as they may be updated by add.
         long lastAccessMaximumTicks = utcNow.SafeAddMilliseconds(-300).Ticks;

src/Foundatio/Extensions/DateTimeExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace Foundatio.Utility;
 
@@ -75,4 +75,16 @@ public static DateTimeOffset SafeAddMilliseconds(this DateTimeOffset date, doubl
 
         return date.SafeAdd(TimeSpan.FromMilliseconds(milliseconds));
     }
+
+    public static DateTime SafeAddMilliseconds(this DateTime date, double milliseconds)
+    {
+        // Check for overflow before creating TimeSpan to avoid exception in TimeSpan.FromMilliseconds
+        if (milliseconds > TimeSpan.MaxValue.TotalMilliseconds)
+            return DateTime.MaxValue;
+
+        if (milliseconds < TimeSpan.MinValue.TotalMilliseconds)
+            return DateTime.MinValue;
+
+        return date.SafeAdd(TimeSpan.FromMilliseconds(milliseconds));
+    }
 }

tests/Foundatio.Tests/Caching/InMemoryCacheClientTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using Foundatio.Caching;
 using Microsoft.Extensions.Logging;
@@ -1551,6 +1552,50 @@ public async Task SetAsync_WithEntryUnderLimit_CachesSuccessfully()
             Assert.Equal(smallString, cached.Value);
         }
     }
+
+    [Fact]
+    public async Task DoMaintenanceAsync_WithPositiveTimezoneOffset_ShouldNotThrowOnDateTimeMinValue()
+    {
+        // This test reproduces an issue where RemoveIfEqualAsync sets ExpiresAt to DateTime.MinValue,
+        // and DoMaintenanceAsync then compares it with a DateTimeOffset. When the system's local timezone
+        // has a positive offset (like Beirut UTC+2/+3), converting DateTime.MinValue to DateTimeOffset
+        // throws ArgumentOutOfRangeException because the resulting UTC time would be before year 0001.
+        //
+        // The bug is in InMemoryCacheClient.cs when checking the expiration:
+        //   if (expiresAt < DateTime.MaxValue && expiresAt <= utcNow)
+        //
+        // When expiresAt is DateTime.MinValue (Kind=Unspecified) and utcNow is a DateTimeOffset,
+        // the implicit conversion of DateTime.MinValue to DateTimeOffset uses the system's local
+        // timezone offset. If that offset is positive, the conversion fails.
+
+        var timeProvider = new FakeTimeProvider();
+        var cache = new InMemoryCacheClient(o => o.CloneValues(true).TimeProvider(timeProvider).LoggerFactory(Log));
+        using (cache)
+        {
+            await cache.RemoveAllAsync();
+
+            // Set up a cache entry and then remove it via RemoveIfEqualAsync
+            // This sets ExpiresAt to DateTime.MinValue on the entry
+            await cache.SetAsync("test-key", "test-value", TimeSpan.FromMinutes(1));
+            await cache.RemoveIfEqualAsync("test-key", "test-value");
+
+
+            // Advance time to ensure the entry is considered "infrequently accessed"
+            // (LastAccessTicks must be < utcNow - 300ms for maintenance to process it)
+            timeProvider.Advance(TimeSpan.FromSeconds(1));
+
+            // Trigger another cache operation to start maintenance
+            // This causes DoMaintenanceAsync to iterate over entries including the one
+            // with ExpiresAt = DateTime.MinValue
+            await cache.SetAsync("trigger", "value");
+
+            // Wait a moment to allow maintenance to complete
+            await Task.Delay(100, TestCancellationToken);
+
+            // Check for the error log that indicates the bug
+            Assert.Null(Log.LogEntries.SingleOrDefault(l => l.LogLevel == LogLevel.Error));
+        }
+    }
 }
 
 /// <summary>

tests/Foundatio.Tests/Extensions/DateTimeExtensionsTests.cs

@@ -100,6 +100,54 @@ public void SafeAddMilliseconds_WithNormalValue_AddsCorrectly()
         Assert.Equal(new DateTimeOffset(2020, 1, 1, 0, 0, 1, TimeSpan.Zero), result);
     }
 
+    [Fact]
+    public void SafeAddMilliseconds_DateTime_WithPositiveOverflow_ReturnsMaxValue()
+    {
+        var date = DateTime.MaxValue.AddDays(-1);
+        var result = date.SafeAddMilliseconds(Double.MaxValue);
+        Assert.Equal(DateTime.MaxValue, result);
+    }
+
+    [Fact]
+    public void SafeAddMilliseconds_DateTime_WithNegativeOverflow_ReturnsMinValue()
+    {
+        var date = DateTime.MinValue.AddDays(1);
+        var result = date.SafeAddMilliseconds(Double.MinValue);
+        Assert.Equal(DateTime.MinValue, result);
+    }
+
+    [Fact]
+    public void SafeAddMilliseconds_DateTime_WithNormalValue_AddsCorrectly()
+    {
+        var date = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var result = date.SafeAddMilliseconds(1000);
+        Assert.Equal(new DateTime(2020, 1, 1, 0, 0, 1, DateTimeKind.Utc), result);
+    }
+
+    [Fact]
+    public void SafeAddMilliseconds_DateTime_WithNegativeValue_SubtractsCorrectly()
+    {
+        var date = new DateTime(2020, 1, 1, 0, 0, 1, DateTimeKind.Utc);
+        var result = date.SafeAddMilliseconds(-1000);
+        Assert.Equal(new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc), result);
+    }
+
+    [Fact]
+    public void SafeAddMilliseconds_DateTime_PreservesDateTimeKind()
+    {
+        var utcDate = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var utcResult = utcDate.SafeAddMilliseconds(1000);
+        Assert.Equal(DateTimeKind.Utc, utcResult.Kind);
+
+        var localDate = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Local);
+        var localResult = localDate.SafeAddMilliseconds(1000);
+        Assert.Equal(DateTimeKind.Local, localResult.Kind);
+
+        var unspecifiedDate = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);
+        var unspecifiedResult = unspecifiedDate.SafeAddMilliseconds(1000);
+        Assert.Equal(DateTimeKind.Unspecified, unspecifiedResult.Kind);
+    }
+
     [Fact]
     public void Floor_WithMinuteInterval_FloorsCorrectly()
     {