CacheRegistration.cs

using Common.Core.Caching.Internals;
using Common.Core.Caching.Options;
using Common.Core.Caching.Services;
using Common.Core.Exceptions.RuntimeExceptions;
using Common.Core.Microservice.Extensions;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using StackExchange.Redis;

namespace Common.Core.Caching;

/// <summary>
/// Hybrid Cache Registration
/// </summary>
public static class CacheRegistration
{
    /// <param name="services">The service collection to which the Redis cache services will be added.</param>
    extension(IServiceCollection services)
    {
        /// <summary>
        /// Adding memory cache related to service.
        /// </summary>
        public void AddInMemoryCache()
        {
            services.AddMemoryCache();
            services.AddSingleton<ICacheProvider, MemoryCacheProvider>();
        }

        /// <summary>
        /// Registers Redis cache services in the dependency injection container.
        /// </summary>
        /// <param name="configuration">The application configuration instance used to read Redis settings.</param>
        /// <exception cref="ConnectionStringException">Thrown when the connection string for Redis is missing or invalid.</exception>
        public async Task AddRedisCacheAsync(IConfiguration configuration)
        {
            var redisOptions = configuration.GetServiceOptions().RedisOptions;

            if (redisOptions.IsSentinelConfig)
            {
                var redisConfiguration = new ConfigurationOptions
                {
                    ServiceName = redisOptions.MasterName,
                    Password = redisOptions.Password,
                    AbortOnConnectFail = false,
                    AllowAdmin = true,
                    DefaultDatabase = redisOptions.DatabaseId,
                };

                foreach (var sentinel in redisOptions.Sentinels) redisConfiguration.EndPoints.Add(sentinel);
                
                var connection = await ConnectionMultiplexer.ConnectAsync(redisConfiguration);
                var db = connection.GetDatabase(redisOptions.DatabaseId);
                services.AddSingleton<IConnectionMultiplexer>(connection);
                services.AddSingleton(db); 
            }
            else
            {
                if (redisOptions.Password != null)
                {
                    services.AddStackExchangeRedisCache(options =>
                    {
                        options.Configuration = $"{redisOptions.ConnectionString},password={redisOptions.Password},defaultDatabase={redisOptions.DatabaseId}";
                        options.InstanceName = redisOptions.InstanceName;
                    });
                }
                else
                {
                    services.AddStackExchangeRedisCache(options =>
                    {
                        options.Configuration = $"{redisOptions.ConnectionString},defaultDatabase={redisOptions.DatabaseId}";
                        options.InstanceName = redisOptions.InstanceName;
                    });
                }

                ConfigurationOptions redisConfiguration;
                if (redisOptions.Password != null)
                {
                    redisConfiguration = new ConfigurationOptions
                    {
                        EndPoints = { redisOptions.ConnectionString },
                        Password = redisOptions.Password,
                        AbortOnConnectFail = false,
                        AllowAdmin = true,
                        SyncTimeout = 10000, 
                        AsyncTimeout = 10000,
                        ConnectTimeout = 15000,
                    };
                }
                else
                {
                    redisConfiguration = new ConfigurationOptions
                    {
                        EndPoints = { redisOptions.ConnectionString },
                        AbortOnConnectFail = false,
                        AllowAdmin = true,
                        SyncTimeout = 10000,
                        AsyncTimeout = 10000,
                        ConnectTimeout = 15000,
                    };
                }

                var connection = await ConnectionMultiplexer.ConnectAsync(redisConfiguration);
                _ = connection.GetDatabase(redisOptions.DatabaseId);
                services.AddSingleton<IConnectionMultiplexer>(connection);
                services.AddSingleton<IConnectionMultiplexer>(await ConnectionMultiplexer.ConnectAsync(redisConfiguration));
            }

            services.AddSingleton<IRedisCacheProvider, RedisCacheProvider>();
            services.AddSingleton<ICacheProvider, RedisCacheProvider>();
        }

        /// <summary>
        /// Registers and configures the hybrid caching mechanism, which combines in-memory and distributed cache services.
        /// This includes options for invalidation synchronization across nodes and centralized configuration for cache settings.
        /// </summary>
        /// <param name="configuration">Configuration instance to access application settings, including cache settings.</param>
        /// <param name="hybridCacheOptions">Optional custom configuration for the hybrid cache behavior.</param>
        /// <returns>A task that represents the asynchronous operation of adding the hybrid cache services.</returns>
        public async Task AddHybridCache(IConfiguration configuration, HybridCacheOptions? hybridCacheOptions = null)
        {
            await services.AddRedisCacheAsync(configuration);
            services.AddInMemoryCache();

            services.Configure<HybridCacheOptions>(options =>
            {
                if (hybridCacheOptions is not null)
                {
                    options.DefaultMemoryCacheDuration = hybridCacheOptions.DefaultMemoryCacheDuration;
                }
            });

            services.AddSingleton<IHybridCache, HybridCache>();

            /*
             * Cache Invalidation Background Service
             * ---------------------------------------
             * This background service is responsible for ensuring cache consistency across distributed
             * application nodes by handling cache invalidation in the in-memory cache.
             *
             * It achieves this by subscribing to a specific Redis channel that broadcasts invalidation messages.
             * When a message is received, the service decodes the message to determine the corresponding cache key
             * and removes that entry from the local memory cache.
             *
             * This mechanism ensures that stale data is not served to end users by synchronizing cache state across
             * different nodes. Additionally, the service logs any errors encountered during its operation, and it
             * captures these exceptions using an external monitoring tool for further analysis.
             */
            services.AddHostedService<CacheInvalidationBackgroundService>();
        }
    }
}