Allow caching with no expiration, Close #289

VahidN · VahidN · commit 5a05b2dc25af · 2025-02-22T14:56:07.000+03:30
diff --git a/src/EFCoreSecondLevelCacheInterceptor.CacheManager.Core/EFCacheManagerCoreProvider.cs b/src/EFCoreSecondLevelCacheInterceptor.CacheManager.Core/EFCacheManagerCoreProvider.cs
@@ -79,10 +79,18 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy
         }
         else
         {
-            _valuesCacheManager.Add(new CacheItem<EFCachedData>(keyHash, value,
-                cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute
-                    ? ExpirationMode.Absolute
-                    : ExpirationMode.Sliding, cachePolicy.CacheTimeout));
+            if (cachePolicy.CacheExpirationMode == CacheExpirationMode.NeverRemove ||
+                !cachePolicy.CacheTimeout.HasValue)
+            {
+                _valuesCacheManager.Add(new CacheItem<EFCachedData>(keyHash, value));
+            }
+            else if (cachePolicy.CacheTimeout.HasValue)
+            {
+                _valuesCacheManager.Add(new CacheItem<EFCachedData>(keyHash, value,
+                    cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute
+                        ? ExpirationMode.Absolute
+                        : ExpirationMode.Sliding, cachePolicy.CacheTimeout.Value));
+            }
         }
     }
 
diff --git a/src/EFCoreSecondLevelCacheInterceptor.CacheManager.Core/EFCacheManagerCoreProviderOptions.cs b/src/EFCoreSecondLevelCacheInterceptor.CacheManager.Core/EFCacheManagerCoreProviderOptions.cs
@@ -31,7 +31,7 @@ public static EFCoreSecondLevelCacheOptions UseCacheManagerCoreProvider(this EFC
     /// <param name="timeout">The expiration timeout.</param>
     public static EFCoreSecondLevelCacheOptions UseCacheManagerCoreProvider(this EFCoreSecondLevelCacheOptions options,
         CacheExpirationMode expirationMode,
-        TimeSpan timeout)
+        TimeSpan? timeout = null)
     {
         if (options == null)
         {
diff --git a/src/EFCoreSecondLevelCacheInterceptor.CacheManager.Core/EFCoreSecondLevelCacheInterceptor.CacheManager.Core.csproj b/src/EFCoreSecondLevelCacheInterceptor.CacheManager.Core/EFCoreSecondLevelCacheInterceptor.CacheManager.Core.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>5.0.0</VersionPrefix>
+        <VersionPrefix>5.1.1</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;net7.0;net6.0;net5.0;netstandard2.1;netstandard2.0;net462;netcoreapp3.1;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core.csproj b/src/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>5.0.0</VersionPrefix>
+        <VersionPrefix>5.1.1</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;net7.0;net6.0;net5.0;netstandard2.1;netstandard2.0;net462;netcoreapp3.1;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core/EFEasyCachingCoreProvider.cs b/src/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core/EFEasyCachingCoreProvider.cs
@@ -69,6 +69,7 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy
         var easyCachingProvider = GetEasyCachingProvider(cacheKey);
 
         var keyHash = cacheKey.KeyHash;
+        var timeout = cachePolicy.CacheTimeout ?? TimeSpan.MaxValue;
 
         foreach (var rootCacheKey in cacheKey.CacheDependencies)
         {
@@ -84,17 +85,17 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy
                 easyCachingProvider.Set(rootCacheKey, new HashSet<string>(StringComparer.OrdinalIgnoreCase)
                 {
                     keyHash
-                }, cachePolicy.CacheTimeout);
+                }, timeout);
             }
             else
             {
                 items.Value.Add(keyHash);
-                easyCachingProvider.Set(rootCacheKey, items.Value, cachePolicy.CacheTimeout);
+                easyCachingProvider.Set(rootCacheKey, items.Value, timeout);
             }
         }
 
         // We don't support Sliding Expiration at this time. -> https://github.com/dotnetcore/EasyCaching/issues/113
-        easyCachingProvider.Set(keyHash, value, cachePolicy.CacheTimeout);
+        easyCachingProvider.Set(keyHash, value, timeout);
     }
 
     /// <summary>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core/EFEasyCachingCoreProviderOptions.cs b/src/EFCoreSecondLevelCacheInterceptor.EasyCaching.Core/EFEasyCachingCoreProviderOptions.cs
@@ -67,7 +67,7 @@ public static EFCoreSecondLevelCacheOptions UseEasyCachingCoreProvider(this EFCo
     public static EFCoreSecondLevelCacheOptions UseEasyCachingCoreProvider(this EFCoreSecondLevelCacheOptions options,
         string providerName,
         CacheExpirationMode expirationMode,
-        TimeSpan timeout,
+        TimeSpan? timeout = null,
         bool isHybridCache = false)
     {
         if (options == null)
@@ -105,7 +105,7 @@ public static EFCoreSecondLevelCacheOptions UseEasyCachingCoreProvider(this EFCo
     public static EFCoreSecondLevelCacheOptions UseEasyCachingCoreProvider(this EFCoreSecondLevelCacheOptions options,
         Func<IServiceProvider, EFCacheKey?, string> providerName,
         CacheExpirationMode expirationMode,
-        TimeSpan timeout,
+        TimeSpan? timeout = null,
         bool isHybridCache = false)
     {
         if (options == null)
diff --git a/src/EFCoreSecondLevelCacheInterceptor.FusionCache/EFCoreSecondLevelCacheInterceptor.FusionCache.csproj b/src/EFCoreSecondLevelCacheInterceptor.FusionCache/EFCoreSecondLevelCacheInterceptor.FusionCache.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>5.1.0</VersionPrefix>
+        <VersionPrefix>5.1.1</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.FusionCache/EFFusionCacheProvider.cs b/src/EFCoreSecondLevelCacheInterceptor.FusionCache/EFFusionCacheProvider.cs
@@ -50,11 +50,15 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy
 
         _fusionCache.Set(cacheKey.KeyHash, value, entryOptions =>
         {
-            entryOptions.SetDuration(cachePolicy.CacheTimeout);
-
-            if (cachePolicy.CacheExpirationMode == CacheExpirationMode.Sliding)
+            if (cachePolicy.CacheExpirationMode != CacheExpirationMode.NeverRemove && cachePolicy.CacheTimeout.HasValue)
             {
-                entryOptions.SetFailSafe(isEnabled: true, cachePolicy.CacheTimeout.Add(cachePolicy.CacheTimeout));
+                entryOptions.SetDuration(cachePolicy.CacheTimeout.Value);
+
+                if (cachePolicy.CacheExpirationMode == CacheExpirationMode.Sliding)
+                {
+                    entryOptions.SetFailSafe(isEnabled: true,
+                        cachePolicy.CacheTimeout.Value.Add(cachePolicy.CacheTimeout.Value));
+                }
             }
         }, cacheKey.CacheDependencies);
     }
diff --git a/src/EFCoreSecondLevelCacheInterceptor.FusionCache/EFFusionCacheProviderOptions.cs b/src/EFCoreSecondLevelCacheInterceptor.FusionCache/EFFusionCacheProviderOptions.cs
@@ -43,7 +43,7 @@ public static EFCoreSecondLevelCacheOptions UseFusionCacheProvider(this EFCoreSe
     /// </param>
     public static EFCoreSecondLevelCacheOptions UseFusionCacheProvider(this EFCoreSecondLevelCacheOptions options,
         CacheExpirationMode expirationMode,
-        TimeSpan timeout,
+        TimeSpan? timeout = null,
         string? namedCache = null)
     {
         ArgumentNullException.ThrowIfNull(options);
diff --git a/src/EFCoreSecondLevelCacheInterceptor.HybridCache/EFCoreSecondLevelCacheInterceptor.HybridCache.csproj b/src/EFCoreSecondLevelCacheInterceptor.HybridCache/EFCoreSecondLevelCacheInterceptor.HybridCache.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>5.0.0</VersionPrefix>
+        <VersionPrefix>5.1.1</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.HybridCache/EFHybridCacheProviderOptions.cs b/src/EFCoreSecondLevelCacheInterceptor.HybridCache/EFHybridCacheProviderOptions.cs
@@ -30,7 +30,7 @@ public static EFCoreSecondLevelCacheOptions UseHybridCacheProvider(this EFCoreSe
     /// <param name="timeout">The expiration timeout.</param>
     public static EFCoreSecondLevelCacheOptions UseHybridCacheProvider(this EFCoreSecondLevelCacheOptions options,
         CacheExpirationMode expirationMode,
-        TimeSpan timeout)
+        TimeSpan? timeout = null)
     {
         ArgumentNullException.ThrowIfNull(options);
 
diff --git a/src/EFCoreSecondLevelCacheInterceptor.MemoryCache/EFCoreSecondLevelCacheInterceptor.MemoryCache.csproj b/src/EFCoreSecondLevelCacheInterceptor.MemoryCache/EFCoreSecondLevelCacheInterceptor.MemoryCache.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>5.0.0</VersionPrefix>
+        <VersionPrefix>5.1.1</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;net7.0;net6.0;net5.0;netstandard2.1;netstandard2.0;net462;netcoreapp3.1;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.MemoryCache/EFMemoryCacheProviderOptions.cs b/src/EFCoreSecondLevelCacheInterceptor.MemoryCache/EFMemoryCacheProviderOptions.cs
@@ -35,7 +35,7 @@ public static EFCoreSecondLevelCacheOptions UseMemoryCacheProvider(this EFCoreSe
     /// <param name="timeout">The expiration timeout.</param>
     public static EFCoreSecondLevelCacheOptions UseMemoryCacheProvider(this EFCoreSecondLevelCacheOptions options,
         CacheExpirationMode expirationMode,
-        TimeSpan timeout)
+        TimeSpan? timeout = null)
     {
         if (options == null)
         {
diff --git a/src/EFCoreSecondLevelCacheInterceptor.MemoryCache/EFMemoryCacheServiceProvider.cs b/src/EFCoreSecondLevelCacheInterceptor.MemoryCache/EFMemoryCacheServiceProvider.cs
@@ -40,13 +40,19 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy
             Size = 1
         };
 
-        if (cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute)
+        switch (cachePolicy.CacheExpirationMode)
         {
-            options.AbsoluteExpirationRelativeToNow = cachePolicy.CacheTimeout;
-        }
-        else
-        {
-            options.SlidingExpiration = cachePolicy.CacheTimeout;
+            case CacheExpirationMode.NeverRemove:
+                // the item will theoretically remain cached indefinitely
+                break;
+            case CacheExpirationMode.Absolute:
+                options.AbsoluteExpirationRelativeToNow = cachePolicy.CacheTimeout;
+
+                break;
+            default:
+                options.SlidingExpiration = cachePolicy.CacheTimeout;
+
+                break;
         }
 
         foreach (var rootCacheKey in cacheKey.CacheDependencies)
diff --git a/src/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis.csproj b/src/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <Description>Entity Framework Core Second Level Caching Library.</Description>
-        <VersionPrefix>5.0.0</VersionPrefix>
+        <VersionPrefix>5.1.1</VersionPrefix>
         <Authors>Vahid Nasiri</Authors>
         <TargetFrameworks>net9.0;net8.0;net7.0;net6.0;net5.0;netstandard2.1;netstandard2.0;net462;netcoreapp3.1;</TargetFrameworks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis/EFStackExchangeRedisCacheProvider.cs b/src/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis/EFStackExchangeRedisCacheProvider.cs
@@ -45,10 +45,18 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy
                 continue;
             }
 
-            var expiryTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() +
-                             cachePolicy.CacheTimeout.TotalMilliseconds;
+            if (cachePolicy.CacheTimeout.HasValue)
+            {
+                var expiryTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() +
+                                 cachePolicy.CacheTimeout.Value.TotalMilliseconds;
 
-            redisDb.SortedSetAdd(rootCacheKey, keyHash, expiryTime);
+                redisDb.SortedSetAdd(rootCacheKey, keyHash, expiryTime);
+            }
+            else
+            {
+                redisDb.SortedSetAdd(rootCacheKey, keyHash,
+                    long.MaxValue - DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
+            }
         }
 
         var data = dataSerializer.Serialize(value);
diff --git a/src/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis/EFStackExchangeRedisCacheProviderOptions.cs b/src/EFCoreSecondLevelCacheInterceptor.StackExchange.Redis/EFStackExchangeRedisCacheProviderOptions.cs
@@ -54,7 +54,7 @@ public static EFCoreSecondLevelCacheOptions UseStackExchangeRedisCacheProvider(
     }
 
     private static void SetOptions(EFCoreSecondLevelCacheOptions options,
-        TimeSpan timeout,
+        TimeSpan? timeout,
         EFRedisCacheConfigurationOptions configurationOptions)
     {
         options.Settings.Services?.TryAddSingleton<IEFDataSerializer, EFMessagePackSerializer>();
diff --git a/src/EFCoreSecondLevelCacheInterceptor/CacheAllQueriesOptions.cs b/src/EFCoreSecondLevelCacheInterceptor/CacheAllQueriesOptions.cs
@@ -15,7 +15,7 @@ public class CacheAllQueriesOptions
     /// <summary>
     ///     The expiration timeout.
     /// </summary>
-    public TimeSpan Timeout { set; get; }
+    public TimeSpan? Timeout { set; get; }
 
     /// <summary>
     ///     Enables or disables the `CacheAllQueries` feature.
diff --git a/src/EFCoreSecondLevelCacheInterceptor/CacheExpirationMode.cs b/src/EFCoreSecondLevelCacheInterceptor/CacheExpirationMode.cs
@@ -14,4 +14,10 @@ public enum CacheExpirationMode
     ///     Defines sliding expiration. The expiration timeout will be refreshed on every access.
     /// </summary>
     Sliding,
+
+    /// <summary>
+    ///     If you do not specify an absolute and/or sliding expiration, then the item will `theoretically` remain cached
+    ///     indefinitely.
+    /// </summary>
+    NeverRemove
 }
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCachePolicy.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCachePolicy.cs
@@ -38,7 +38,7 @@ public class EFCachePolicy
     ///     The expiration timeout.
     ///     Its default value is 20 minutes later.
     /// </summary>
-    public TimeSpan CacheTimeout { get; private set; } = TimeSpan.FromMinutes(20);
+    public TimeSpan? CacheTimeout { get; private set; } = TimeSpan.FromMinutes(value: 20);
 
     /// <summary>
     ///     If you think the computed hash of the query to calculate the cache-key is not enough, set this value.
@@ -67,6 +67,7 @@ public class EFCachePolicy
     public EFCachePolicy CacheDependencies(params string[] cacheDependencies)
     {
         CacheItemsDependencies = new SortedSet<string>(cacheDependencies, StringComparer.OrdinalIgnoreCase);
+
         return this;
     }
 
@@ -77,16 +78,18 @@ public EFCachePolicy CacheDependencies(params string[] cacheDependencies)
     public EFCachePolicy ExpirationMode(CacheExpirationMode expirationMode)
     {
         CacheExpirationMode = expirationMode;
+
         return this;
     }
 
     /// <summary>
     ///     The expiration timeout.
     ///     Its default value is 20 minutes later.
     /// </summary>
-    public EFCachePolicy Timeout(TimeSpan timeout)
+    public EFCachePolicy Timeout(TimeSpan? timeout)
     {
         CacheTimeout = timeout;
+
         return this;
     }
 
@@ -97,6 +100,7 @@ public EFCachePolicy Timeout(TimeSpan timeout)
     public EFCachePolicy SaltKey(string saltKey)
     {
         CacheSaltKey = saltKey;
+
         return this;
     }
 
@@ -106,6 +110,7 @@ public EFCachePolicy SaltKey(string saltKey)
     public EFCachePolicy DefaultCacheableMethod(bool state)
     {
         IsDefaultCacheableMethod = state;
+
         return this;
     }
 
@@ -121,13 +126,14 @@ public static string Configure(Action<EFCachePolicy> options)
 
         var cachePolicy = new EFCachePolicy();
         options.Invoke(cachePolicy);
+
         return cachePolicy.ToString();
     }
 
     /// <summary>
     ///     Represents the textual form of the current object
     /// </summary>
-    public override string ToString() =>
-        $"{nameof(EFCachePolicy)} {PartsSeparator} {CacheExpirationMode}{ItemsSeparator}{CacheTimeout}{ItemsSeparator}{CacheSaltKey}{ItemsSeparator}{string.Join(CacheDependenciesSeparator, CacheItemsDependencies)}{ItemsSeparator}{IsDefaultCacheableMethod}"
+    public override string ToString()
+        => $"{nameof(EFCachePolicy)} {PartsSeparator} {CacheExpirationMode}{ItemsSeparator}{CacheTimeout}{ItemsSeparator}{CacheSaltKey}{ItemsSeparator}{string.Join(CacheDependenciesSeparator, CacheItemsDependencies)}{ItemsSeparator}{IsDefaultCacheableMethod}"
             .TrimEnd(ItemsSeparator);
 }
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCachePolicyParser.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCachePolicyParser.cs
@@ -409,9 +409,11 @@ private bool ShouldCacheQueriesContainingTableNames(string commandText, CacheSpe
             return null;
         }
 
-        if (!TimeSpan.TryParse(options[1], CultureInfo.InvariantCulture, out var timeout))
+        TimeSpan? cacheTimeout = null;
+
+        if (TimeSpan.TryParse(options[1], CultureInfo.InvariantCulture, out var timeout))
         {
-            return null;
+            cacheTimeout = timeout;
         }
 
         var saltKey = options.Length >= 3 ? options[2] : string.Empty;
@@ -425,17 +427,17 @@ private bool ShouldCacheQueriesContainingTableNames(string commandText, CacheSpe
         if (isDefaultCacheableMethod && _cacheSettings.CacheAllQueriesOptions.IsActive)
         {
             expirationMode = _cacheSettings.CacheAllQueriesOptions.ExpirationMode;
-            timeout = _cacheSettings.CacheAllQueriesOptions.Timeout;
+            cacheTimeout = _cacheSettings.CacheAllQueriesOptions.Timeout;
         }
         else if (isDefaultCacheableMethod && _cacheSettings.CachableQueriesOptions.IsActive)
         {
             expirationMode = _cacheSettings.CachableQueriesOptions.ExpirationMode;
-            timeout = _cacheSettings.CachableQueriesOptions.Timeout;
+            cacheTimeout = _cacheSettings.CachableQueriesOptions.Timeout;
         }
 
         return new EFCachePolicy().ExpirationMode(expirationMode)
             .SaltKey(saltKey)
-            .Timeout(timeout)
+            .Timeout(cacheTimeout)
             .CacheDependencies(cacheDependencies);
     }
 
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCachedQueryExtensions.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCachedQueryExtensions.cs
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCoreSecondLevelCacheInterceptor.csproj b/src/EFCoreSecondLevelCacheInterceptor/EFCoreSecondLevelCacheInterceptor.csproj
diff --git a/src/EFCoreSecondLevelCacheInterceptor/EFCoreSecondLevelCacheOptions.cs b/src/EFCoreSecondLevelCacheInterceptor/EFCoreSecondLevelCacheOptions.cs
diff --git a/src/Tests/EFCoreSecondLevelCacheInterceptor.UnitTests/EFCachePolicyParserTests.cs b/src/Tests/EFCoreSecondLevelCacheInterceptor.UnitTests/EFCachePolicyParserTests.cs

Original file line number	Diff line number	Diff line change
`@@ -79,10 +79,18 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy`
`79`	`79`	`}`
`80`	`80`	`else`
`81`	`81`	`{`
`82`		`- _valuesCacheManager.Add(new CacheItem<EFCachedData>(keyHash, value,`
`83`		`- cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute`
`84`		`- ? ExpirationMode.Absolute`
`85`		`- : ExpirationMode.Sliding, cachePolicy.CacheTimeout));`
	`82`	`+ if (cachePolicy.CacheExpirationMode == CacheExpirationMode.NeverRemove \|\|`
	`83`	`+ !cachePolicy.CacheTimeout.HasValue)`
	`84`	`+ {`
	`85`	`+ _valuesCacheManager.Add(new CacheItem<EFCachedData>(keyHash, value));`
	`86`	`+ }`
	`87`	`+ else if (cachePolicy.CacheTimeout.HasValue)`
	`88`	`+ {`
	`89`	`+ _valuesCacheManager.Add(new CacheItem<EFCachedData>(keyHash, value,`
	`90`	`+ cachePolicy.CacheExpirationMode == CacheExpirationMode.Absolute`
	`91`	`+ ? ExpirationMode.Absolute`
	`92`	`+ : ExpirationMode.Sliding, cachePolicy.CacheTimeout.Value));`
	`93`	`+ }`
`86`	`94`	`}`
`87`	`95`	`}`
`88`	`96`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public static EFCoreSecondLevelCacheOptions UseCacheManagerCoreProvider(this EFC`
`31`	`31`	`/// <param name="timeout">The expiration timeout.</param>`
`32`	`32`	`public static EFCoreSecondLevelCacheOptions UseCacheManagerCoreProvider(this EFCoreSecondLevelCacheOptions options,`
`33`	`33`	`CacheExpirationMode expirationMode,`
`34`		`- TimeSpan timeout)`
	`34`	`+ TimeSpan? timeout = null)`
`35`	`35`	`{`
`36`	`36`	`if (options == null)`
`37`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,7 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy`
`69`	`69`	`var easyCachingProvider = GetEasyCachingProvider(cacheKey);`
`70`	`70`
`71`	`71`	`var keyHash = cacheKey.KeyHash;`
	`72`	`+ var timeout = cachePolicy.CacheTimeout ?? TimeSpan.MaxValue;`
`72`	`73`
`73`	`74`	`foreach (var rootCacheKey in cacheKey.CacheDependencies)`
`74`	`75`	`{`
`@@ -84,17 +85,17 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy`
`84`	`85`	`easyCachingProvider.Set(rootCacheKey, new HashSet<string>(StringComparer.OrdinalIgnoreCase)`
`85`	`86`	`{`
`86`	`87`	`keyHash`
`87`		`- }, cachePolicy.CacheTimeout);`
	`88`	`+ }, timeout);`
`88`	`89`	`}`
`89`	`90`	`else`
`90`	`91`	`{`
`91`	`92`	`items.Value.Add(keyHash);`
`92`		`- easyCachingProvider.Set(rootCacheKey, items.Value, cachePolicy.CacheTimeout);`
	`93`	`+ easyCachingProvider.Set(rootCacheKey, items.Value, timeout);`
`93`	`94`	`}`
`94`	`95`	`}`
`95`	`96`
`96`	`97`	`// We don't support Sliding Expiration at this time. -> https://github.com/dotnetcore/EasyCaching/issues/113`
`97`		`- easyCachingProvider.Set(keyHash, value, cachePolicy.CacheTimeout);`
	`98`	`+ easyCachingProvider.Set(keyHash, value, timeout);`
`98`	`99`	`}`
`99`	`100`
`100`	`101`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -50,11 +50,15 @@ public void InsertValue(EFCacheKey cacheKey, EFCachedData? value, EFCachePolicy`
`50`	`50`
`51`	`51`	`_fusionCache.Set(cacheKey.KeyHash, value, entryOptions =>`
`52`	`52`	`{`
`53`		`- entryOptions.SetDuration(cachePolicy.CacheTimeout);`
`54`		`-`
`55`		`- if (cachePolicy.CacheExpirationMode == CacheExpirationMode.Sliding)`
	`53`	`+ if (cachePolicy.CacheExpirationMode != CacheExpirationMode.NeverRemove && cachePolicy.CacheTimeout.HasValue)`
`56`	`54`	`{`
`57`		`- entryOptions.SetFailSafe(isEnabled: true, cachePolicy.CacheTimeout.Add(cachePolicy.CacheTimeout));`
	`55`	`+ entryOptions.SetDuration(cachePolicy.CacheTimeout.Value);`
	`56`	`+`
	`57`	`+ if (cachePolicy.CacheExpirationMode == CacheExpirationMode.Sliding)`
	`58`	`+ {`
	`59`	`+ entryOptions.SetFailSafe(isEnabled: true,`
	`60`	`+ cachePolicy.CacheTimeout.Value.Add(cachePolicy.CacheTimeout.Value));`
	`61`	`+ }`
`58`	`62`	`}`
`59`	`63`	`}, cacheKey.CacheDependencies);`
`60`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public static EFCoreSecondLevelCacheOptions UseFusionCacheProvider(this EFCoreSe`
`43`	`43`	`/// </param>`
`44`	`44`	`public static EFCoreSecondLevelCacheOptions UseFusionCacheProvider(this EFCoreSecondLevelCacheOptions options,`
`45`	`45`	`CacheExpirationMode expirationMode,`
`46`		`- TimeSpan timeout,`
	`46`	`+ TimeSpan? timeout = null,`
`47`	`47`	`string? namedCache = null)`
`48`	`48`	`{`
`49`	`49`	`ArgumentNullException.ThrowIfNull(options);`