Deactivate redis using a flag

Core.Blueprint.Redis/Configuration/RegisterBlueprint.cs

@@ -27,7 +27,7 @@ namespace Core.Blueprint.Redis.Configuration
 
             // Register RedisCacheProvider
             services.AddSingleton<IRedisCacheProvider>(provider =>
-                new RedisCacheProvider(redisConnectionString, provider.GetRequiredService<ILogger<RedisCacheProvider>>()));
+                new RedisCacheProvider(redisConnectionString, provider.GetRequiredService<ILogger<RedisCacheProvider>>(), configuration));
 
             // Get CacheSettings and register with the ICacheSettings interface
             var cacheSettings = configuration.GetSection("CacheSettings").Get<CacheSettings>();

Core.Blueprint.Redis/RedisCacheProvider.cs

@@ -1,7 +1,7 @@
 using Azure.Identity;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using StackExchange.Redis;
-using System;
 using System.Text.Json;
 
 namespace Core.Blueprint.Redis
@@ -13,6 +13,7 @@ namespace Core.Blueprint.Redis
     {
         private IDatabase _cacheDatabase = null!;
         private readonly ILogger<RedisCacheProvider> _logger;
+        private readonly bool _useRedis;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="RedisCacheProvider"/> class.
@@ -20,12 +21,13 @@ namespace Core.Blueprint.Redis
         /// <param name="connectionString">The Redis connection string.</param>
         /// <param name="logger">The logger instance for logging operations.</param>
         /// <exception cref="ArgumentNullException">Thrown when connection string is null or empty.</exception>
-        public RedisCacheProvider(string connectionString, ILogger<RedisCacheProvider> logger)
+        public RedisCacheProvider(string connectionString, ILogger<RedisCacheProvider> logger, IConfiguration configuration)
         {
             if (string.IsNullOrWhiteSpace(connectionString))
                 throw new ArgumentNullException(nameof(connectionString), "Redis connection string cannot be null or empty.");
 
             _logger = logger;
+            _useRedis = configuration.GetValue<bool>("UseRedisCache", false);
             _cacheDatabase = InitializeRedisAsync(connectionString).GetAwaiter().GetResult();
         }
 
@@ -36,30 +38,35 @@ namespace Core.Blueprint.Redis
         /// <param name="connectionString">The Redis connection string.</param>
         /// <returns>An <see cref="IDatabase"/> instance representing the Redis cache database.</returns>
         /// <exception cref="Exception">Thrown when the connection to Redis fails.</exception>
-        async Task<IDatabase> InitializeRedisAsync(string connectionString)
+        async Task<IDatabase?> InitializeRedisAsync(string connectionString)
         {
             try
             {
-                var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
+                if (_useRedis)
-                ConnectionMultiplexer connectionMultiplexer;
-
-                if (environment.Equals("Local", StringComparison.OrdinalIgnoreCase))
                 {
-                    connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(connectionString);
+                    var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
-                }
+                    ConnectionMultiplexer connectionMultiplexer;
-                else
-                {
-                    var configurationOptions = await ConfigurationOptions.Parse(connectionString)
-                        .ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
 
-                    configurationOptions.AbortOnConnectFail = false;
+                    if (environment.Equals("Local", StringComparison.OrdinalIgnoreCase))
+                    {
+                        connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(connectionString);
+                    }
+                    else
+                    {
+                        var configurationOptions = await ConfigurationOptions.Parse(connectionString)
+                            .ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
 
-                    connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
+                        configurationOptions.AbortOnConnectFail = false;
+
+                        connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
+                    }
+
+                    _logger.LogInformation("Successfully connected to Redis.");
+
+                    return connectionMultiplexer.GetDatabase();
                 }
 
-                _logger.LogInformation("Successfully connected to Redis.");
+                return null;
-
-                return connectionMultiplexer.GetDatabase();
             }
             catch (Exception ex)
             {
@@ -78,15 +85,21 @@ namespace Core.Blueprint.Redis
         {
             try
             {
-                var value = await _cacheDatabase.StringGetAsync(key);
+                if (_useRedis is not false)
-                if (value.IsNullOrEmpty)
                 {
-                    _logger.LogInformation($"Cache miss for key: {key}");
+                    var value = await _cacheDatabase.StringGetAsync(key);
-                    return default;
+
+                    if (value.IsNullOrEmpty)
+                    {
+                        _logger.LogInformation($"Cache miss for key: {key}");
+                        return default;
+                    }
+
+                    _logger.LogInformation($"Cache hit for key: {key}");
+                    return JsonSerializer.Deserialize<TEntity>(value);
                 }
 
-                _logger.LogInformation($"Cache hit for key: {key}");
+                return default;
-                return JsonSerializer.Deserialize<TEntity>(value);
             }
             catch (Exception ex)
             {
@@ -105,9 +118,12 @@ namespace Core.Blueprint.Redis
         {
             try
             {
-                var json = JsonSerializer.Serialize(value);
+                if (_useRedis is not false)
-                await _cacheDatabase.StringSetAsync(key, json, expiry);
+                {
-                _logger.LogInformation($"Cache item set with key: {key}");
+                    var json = JsonSerializer.Serialize(value);
+                    await _cacheDatabase.StringSetAsync(key, json, expiry);
+                    _logger.LogInformation($"Cache item set with key: {key}");
+                }
             }
             catch (Exception ex)
             {
@@ -124,8 +140,11 @@ namespace Core.Blueprint.Redis
         {
             try
             {
-                await _cacheDatabase.KeyDeleteAsync(key);
+                if (_useRedis is not false)
-                _logger.LogInformation($"Cache item removed with key: {key}");
+                {
+                    await _cacheDatabase.KeyDeleteAsync(key);
+                    _logger.LogInformation($"Cache item removed with key: {key}");
+                }
             }
             catch (Exception ex)
             {
@@ -143,9 +162,13 @@ namespace Core.Blueprint.Redis
         {
             try
             {
-                var exists = await _cacheDatabase.KeyExistsAsync(key);
+                if (_useRedis is not false)
-                _logger.LogInformation($"Cache item exists check for key: {key} - {exists}");
+                {
-                return exists;
+                    var exists = await _cacheDatabase.KeyExistsAsync(key);
+                    _logger.LogInformation($"Cache item exists check for key: {key} - {exists}");
+                }
+
+                return false;
             }
             catch (Exception ex)
             {
@@ -163,15 +186,18 @@ namespace Core.Blueprint.Redis
         {
             try
             {
-                var value = await _cacheDatabase.StringGetAsync(key);
+                if (_useRedis is not false)
-                if (!value.IsNullOrEmpty)
                 {
-                    await _cacheDatabase.StringSetAsync(key, value, expiry);
+                    var value = await _cacheDatabase.StringGetAsync(key);
-                    _logger.LogInformation($"Cache item refreshed with key: {key}");
+                    if (!value.IsNullOrEmpty)
-                }
+                    {
-                else
+                        await _cacheDatabase.StringSetAsync(key, value, expiry);
-                {
+                        _logger.LogInformation($"Cache item refreshed with key: {key}");
-                    _logger.LogWarning($"Cache item with key: {key} does not exist, cannot refresh");
+                    }
+                    else
+                    {
+                        _logger.LogWarning($"Cache item with key: {key} does not exist, cannot refresh");
+                    }
                 }
             }
             catch (Exception ex)