Refactor distributed cache options

Introduces a base options class for distributed caches to consolidate common settings.

Updates `DistributedCache`, `MessagePackDistributedCache`, and `RedisHybridCache` to consume these options via `IOptions`, simplifying their constructors and internal logic.

Author: neoscie

Neolution.Extensions.Caching.Abstractions/DistributedCache.cs

@@ -4,6 +4,7 @@
     using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
+    using Microsoft.Extensions.Options;
 
     /// <inheritdoc />
     /// <summary>
@@ -26,31 +27,49 @@ public abstract class DistributedCache<TCacheId> : IDistributedCache<TCacheId>
         /// </value>
         private static string CacheIdName => typeof(TCacheId).Name;
 
+        private readonly bool enableKeyEncoding;
+        private readonly bool enableKeyLengthValidation;
+        private readonly int? version;
+        private readonly string? environmentPrefix;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DistributedCache{TCacheId}"/> class.
+        /// </summary>
+        /// <param name="optionsAccessor">The options accessor containing cache configuration.</param>
+        /// <exception cref="ArgumentNullException">Thrown when optionsAccessor is null.</exception>
+        protected DistributedCache(IOptions<DistributedCacheOptionsBase> optionsAccessor)
+        {
+            if (optionsAccessor == null)
+            {
+                throw new ArgumentNullException(nameof(optionsAccessor));
+            }
+
+            var options = optionsAccessor.Value;
+            this.enableKeyEncoding = options.EnableKeyEncoding;
+            this.enableKeyLengthValidation = options.EnableKeyLengthValidation;
+            this.version = options.Version;
+            this.environmentPrefix = options.EnvironmentPrefix;
+        }
+
         /// <summary>
         /// Gets a value indicating whether optional cache keys should be URL-encoded.
-        /// Default is true for safe handling of special characters.
-        /// Set to false to maintain backwards compatibility with existing cache keys.
         /// </summary>
-        protected virtual bool EnableKeyEncoding => true;
+        protected bool EnableKeyEncoding => this.enableKeyEncoding;
 
         /// <summary>
         /// Gets a value indicating whether cache key length should be validated.
-        /// Default is true to ensure performance and compatibility with many cache backends.
-        /// Set to false to disable length validation if your cache backend supports longer keys.
         /// </summary>
-        protected virtual bool EnableKeyLengthValidation => true;
+        protected bool EnableKeyLengthValidation => this.enableKeyLengthValidation;
 
         /// <summary>
         /// Gets the cache key version for invalidation purposes.
-        /// If null, version is not included in the cache key.
         /// </summary>
-        protected virtual int? Version => null;
+        protected int? Version => this.version;
 
         /// <summary>
         /// Gets the optional environment prefix for cache key isolation.
-        /// If null or empty, environment prefix is not included in the cache key.
         /// </summary>
-        protected virtual string? EnvironmentPrefix => null;
+        protected string? EnvironmentPrefix => this.environmentPrefix;
 
         /// <inheritdoc />
         public T? Get<T>(TCacheId id)

Neolution.Extensions.Caching.Abstractions/DistributedCacheOptionsBase.cs

@@ -0,0 +1,48 @@
+namespace Neolution.Extensions.Caching.Abstractions
+{
+    /// <summary>
+    /// Base class for distributed cache configuration options.
+    /// Provides common configuration properties shared across all distributed cache implementations.
+    /// </summary>
+    public abstract class DistributedCacheOptionsBase
+    {
+        /// <summary>
+        /// Gets or sets the cache key version for invalidation purposes.
+        /// If null, version is not included in the cache key.
+        /// Changing this version will invalidate all existing cache entries.
+        /// The version will be formatted as "v{number}" in the cache key (e.g., v1, v2).
+        /// Default: null (no version in cache key).
+        /// </summary>
+        /// <example>
+        /// options.Version = 2; // Cache key becomes: "MyCacheId:v2:UserProfile"
+        /// </example>
+        public int? Version { get; set; }
+
+        /// <summary>
+        /// Gets or sets the optional environment prefix for cache key isolation.
+        /// If null or empty, environment prefix is not included in the cache key.
+        /// Useful for multi-environment scenarios sharing the same cache backend.
+        /// Default: null (no environment prefix in cache key).
+        /// </summary>
+        /// <example>
+        /// options.EnvironmentPrefix = "staging"; // Cache key becomes: "staging:MyCacheId:UserProfile"
+        /// </example>
+        public string? EnvironmentPrefix { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether optional cache keys should be URL-encoded.
+        /// URL encoding ensures safe handling of special characters in distributed cache backends.
+        /// Set to false to maintain backwards compatibility with existing cache keys.
+        /// Default: true.
+        /// </summary>
+        public bool EnableKeyEncoding { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether cache key length should be validated.
+        /// Default is true to ensure performance and compatibility with many cache backends.
+        /// Set to false to disable length validation if your cache backend supports longer keys.
+        /// Default: true.
+        /// </summary>
+        public bool EnableKeyLengthValidation { get; set; } = true;
+    }
+}

Neolution.Extensions.Caching.Abstractions/Neolution.Extensions.Caching.Abstractions.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
     <PackageReference Include="Neolution.CodeAnalysis" Version="2.6.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

Neolution.Extensions.Caching.Distributed/MessagePackDistributedCache.cs

@@ -33,6 +33,7 @@ public class MessagePackDistributedCache<TCacheId> : DistributedCache<TCacheId>
         /// <param name="cache">The cache.</param>
         /// <param name="optionsAccessor">The options accessor.</param>
         public MessagePackDistributedCache(IDistributedCache cache, IOptions<MessagePackDistributedCacheOptions> optionsAccessor)
+            : base(optionsAccessor)
         {
             this.cache = cache ?? throw new ArgumentNullException(nameof(cache));
 
@@ -42,8 +43,6 @@ public MessagePackDistributedCache(IDistributedCache cache, IOptions<MessagePack
             }
 
             var options = optionsAccessor.Value;
-            this.Version = options.Version;
-            this.EnvironmentPrefix = options.EnvironmentPrefix;
 
             if (options.RequireMessagePackObjectAnnotation)
             {
@@ -56,12 +55,6 @@ public MessagePackDistributedCache(IDistributedCache cache, IOptions<MessagePack
             }
         }
 
-        /// <inheritdoc />
-        protected override int? Version { get; }
-
-        /// <inheritdoc />
-        protected override string? EnvironmentPrefix { get; }
-
         /// <inheritdoc />
         protected override T? GetCacheObject<T>(string key)
             where T : class

Neolution.Extensions.Caching.Distributed/MessagePackDistributedCacheOptions.cs

@@ -1,48 +1,25 @@
 namespace Neolution.Extensions.Caching.Distributed
 {
-    using Microsoft.Extensions.Options;
+    using Neolution.Extensions.Caching.Abstractions;
 
     /// <summary>
-    /// The options for the MessagePack distributed cache implementation.
+    /// Configuration options for MessagePack distributed cache.
     /// </summary>
-    public class MessagePackDistributedCacheOptions : IOptions<MessagePackDistributedCacheOptions>
+    public class MessagePackDistributedCacheOptions : DistributedCacheOptionsBase
     {
         /// <summary>
-        /// Gets or sets a value indicating whether to disable compression, to not waste CPU resources if working with an in-memory cache backend.
+        /// Gets or sets a value indicating whether to disable compression.
+        /// Set to true to save CPU when using in-memory cache backends.
+        /// Default: false (compression enabled with LZ4).
         /// </summary>
         public bool DisableCompression { get; set; }
 
         /// <summary>
-        /// Gets or sets a value indicating whether to require <see cref="MessagePack.MessagePackObjectAttribute"/> annotation for serializable types.
-        /// Doing so would result in better overall serialization performance and smaller files.
+        /// Gets or sets a value indicating whether to require MessagePackObject attribute.
+        /// Setting this to true improves serialization performance but requires decorating
+        /// your classes with [MessagePackObject] attribute.
+        /// Default: false (uses contractless serialization).
         /// </summary>
-        /// <value>
-        ///   <c>true</c> to require <see cref="MessagePack.MessagePackObjectAttribute"/> annotation; otherwise, <c>false</c>.
-        /// </value>
         public bool RequireMessagePackObjectAnnotation { get; set; }
-
-        /// <summary>
-        /// Gets or sets the cache key version to use for cache invalidation.
-        /// If not set, version is not included in the cache key.
-        /// Changing this version will invalidate all existing cache keys with that version.
-        /// The version will be formatted as "v{number}" in the cache key (e.g., v1, v2).
-        /// </summary>
-        /// <value>
-        /// The cache key version. Defaults to null (no version in cache key).
-        /// </value>
-        public int? Version { get; set; }
-
-        /// <summary>
-        /// Gets or sets the optional environment prefix for cache key isolation.
-        /// If not set, environment prefix is not included in the cache key.
-        /// Useful for multi-environment scenarios (e.g., "dev", "staging", "prod").
-        /// </summary>
-        /// <value>
-        /// The environment prefix. Defaults to null (no environment prefix in cache key).
-        /// </value>
-        public string? EnvironmentPrefix { get; set; }
-
-        /// <inheritdoc />
-        public MessagePackDistributedCacheOptions Value => this;
     }
 }

Neolution.Extensions.Caching.Distributed/ServiceCollectionExtensions.cs

@@ -11,20 +11,28 @@ namespace Microsoft.Extensions.DependencyInjection
     public static class ServiceCollectionExtensions
     {
         /// <summary>
-        /// Adds the distributed caching implementation that uses MessagePack to serialize and deserialize the values to cache.
+        /// Adds the distributed caching implementation that uses MessagePack for serialization.
+        /// Requires an <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/>
+        /// provider to be registered (e.g., Redis, SQL Server, Memory).
         /// </summary>
-        /// <param name="services">The services.</param>
-        public static void AddMessagePackDistributedCache(this IServiceCollection services)
+        /// <param name="services">The service collection.</param>
+        /// <returns>The service collection for fluent chaining.</returns>
+        public static IServiceCollection AddMessagePackDistributedCache(this IServiceCollection services)
         {
-            services.AddMessagePackDistributedCache(_ => { });
+            return services.AddMessagePackDistributedCache(_ => { });
         }
 
         /// <summary>
-        /// Adds the distributed caching implementation that uses MessagePack to serialize and deserialize the values to cache. Allows to configure options.
+        /// Adds the distributed caching implementation that uses MessagePack for serialization,
+        /// with custom configuration options.
+        /// Requires an <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/>
+        /// provider to be registered (e.g., Redis, SQL Server, Memory).
         /// </summary>
-        /// <param name="services">The services.</param>
-        /// <param name="configureOptions">The setup action.</param>
-        public static void AddMessagePackDistributedCache(this IServiceCollection services, Action<MessagePackDistributedCacheOptions> configureOptions)
+        /// <param name="services">The service collection.</param>
+        /// <param name="configureOptions">The action to configure cache options.</param>
+        /// <returns>The service collection for fluent chaining.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when configureOptions is null.</exception>
+        public static IServiceCollection AddMessagePackDistributedCache(this IServiceCollection services, Action<MessagePackDistributedCacheOptions> configureOptions)
         {
             if (configureOptions == null)
             {
@@ -34,6 +42,8 @@ public static void AddMessagePackDistributedCache(this IServiceCollection servic
             services.AddOptions();
             services.Configure(configureOptions);
             services.AddSingleton(typeof(IDistributedCache<>), typeof(MessagePackDistributedCache<>));
+
+            return services;
         }
     }
 }

Neolution.Extensions.Caching.InMemory/ServiceCollectionExtensions.cs

@@ -10,13 +10,16 @@ namespace Microsoft.Extensions.DependencyInjection
     public static class ServiceCollectionExtensions
     {
         /// <summary>
-        /// Adds the Neolution default non-distributed memory caching implementation.
+        /// Adds the in-memory caching implementation.
+        /// Uses Microsoft's <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> internally.
         /// </summary>
-        /// <param name="services">The services.</param>
-        public static void AddInMemoryCache(this IServiceCollection services)
+        /// <param name="services">The service collection.</param>
+        /// <returns>The service collection for fluent chaining.</returns>
+        public static IServiceCollection AddInMemoryCache(this IServiceCollection services)
         {
             services.AddMemoryCache();
             services.AddSingleton(typeof(IMemoryCache<>), typeof(InMemoryCache<>));
+            return services;
         }
     }
 }

Neolution.Extensions.Caching.RedisHybrid/MsgPackSerializer.cs

@@ -12,10 +12,28 @@
     public class MsgPackSerializer : ISerializer
     {
         /// <summary>
-        /// The options
+        /// The MessagePack serializer options.
         /// </summary>
-        private readonly MessagePackSerializerOptions options = MessagePack.Resolvers.ContractlessStandardResolver.Options
-            .WithCompression(MessagePackCompression.Lz4BlockArray);
+        private readonly MessagePackSerializerOptions options;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MsgPackSerializer"/> class.
+        /// Compression is disabled by default to save CPU for in-memory scenarios.
+        /// </summary>
+        public MsgPackSerializer()
+            : this(false)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MsgPackSerializer"/> class.
+        /// </summary>
+        /// <param name="enableCompression">If set to <c>true</c>, enables LZ4 compression.</param>
+        public MsgPackSerializer(bool enableCompression)
+        {
+            this.options = MessagePack.Resolvers.ContractlessStandardResolver.Options
+                .WithCompression(enableCompression ? MessagePackCompression.Lz4BlockArray : MessagePackCompression.None);
+        }
 
         /// <summary>
         /// Deserializes the specified data.

Neolution.Extensions.Caching.RedisHybrid/RedisHybridCache.cs

@@ -28,25 +28,16 @@ public class RedisHybridCache<TCacheId> : DistributedCache<TCacheId>
         /// <param name="cacheClient">The cache client.</param>
         /// <param name="optionsAccessor">The options accessor.</param>
         public RedisHybridCache(ICacheClient cacheClient, IOptions<RedisHybridCacheOptions> optionsAccessor)
+            : base(optionsAccessor)
         {
             this.cacheClient = cacheClient ?? throw new ArgumentNullException(nameof(cacheClient));
 
             if (optionsAccessor == null)
             {
                 throw new ArgumentNullException(nameof(optionsAccessor));
             }
-
-            var options = optionsAccessor.Value;
-            this.Version = options.Version;
-            this.EnvironmentPrefix = options.EnvironmentPrefix;
         }
 
-        /// <inheritdoc />
-        protected override int? Version { get; }
-
-        /// <inheritdoc />
-        protected override string? EnvironmentPrefix { get; }
-
         /// <inheritdoc />
         protected override T? GetCacheObject<T>(string key)
             where T : class

Neolution.Extensions.Caching.RedisHybrid/RedisHybridCacheOptions.cs

@@ -1,34 +1,17 @@
 namespace Neolution.Extensions.Caching.RedisHybrid
 {
-    using Microsoft.Extensions.Options;
+    using Neolution.Extensions.Caching.Abstractions;
 
     /// <summary>
-    /// The options for the Redis hybrid cache implementation.
+    /// Configuration options for Redis hybrid cache (L1 + L2 caching).
     /// </summary>
-    public class RedisHybridCacheOptions : IOptions<RedisHybridCacheOptions>
+    public class RedisHybridCacheOptions : DistributedCacheOptionsBase
     {
         /// <summary>
-        /// Gets or sets the cache key version to use for cache invalidation.
-        /// If not set, version is not included in the cache key.
-        /// Changing this version will invalidate all existing cache keys with that version.
-        /// The version will be formatted as "v{number}" in the cache key (e.g., v1, v2).
+        /// Gets or sets a value indicating whether to enable compression for serialization.
+        /// Set to true to enable compression (LZ4) when bandwidth is a concern.
+        /// Default: false (compression disabled to save CPU cycles).
         /// </summary>
-        /// <value>
-        /// The cache key version. Defaults to null (no version in cache key).
-        /// </value>
-        public int? Version { get; set; }
-
-        /// <summary>
-        /// Gets or sets the optional environment prefix for cache key isolation.
-        /// If not set, environment prefix is not included in the cache key.
-        /// Useful for multi-environment scenarios (e.g., "dev", "staging", "prod").
-        /// </summary>
-        /// <value>
-        /// The environment prefix. Defaults to null (no environment prefix in cache key).
-        /// </value>
-        public string? EnvironmentPrefix { get; set; }
-
-        /// <inheritdoc />
-        public RedisHybridCacheOptions Value => this;
+        public bool EnableCompression { get; set; }
     }
 }