Fix(multilevelcache): fix injected by singleton to scope

src/BuildingBlocks/Caching/Masa.BuildingBlocks.Caching/Extensions/DistributedCacheBuilderExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (c) MASA Stack All rights reserved.
+// Copyright (c) MASA Stack All rights reserved.
 // Licensed under the MIT License. See LICENSE.txt in the project root for license information.
 
 // ReSharper disable once CheckNamespace
@@ -11,6 +11,7 @@ public static void UseCustomDistributedCache(
         this DistributedCacheBuilder distributedCacheBuilder,
         Func<IServiceProvider, IManualDistributedCacheClient> func)
     {
+
         distributedCacheBuilder.Services.Configure<DistributedCacheFactoryOptions>(options =>
         {
             if (options.Options.Any(opt => opt.Name == distributedCacheBuilder.Name))

src/BuildingBlocks/Caching/Masa.BuildingBlocks.Caching/Internal/ServiceCollectionExtensions.Core.cs

@@ -22,9 +22,7 @@ public static void TryAddDistributedCache(
         services.TryAddTransient<IDistributedCacheClientFactory, DefaultDistributedCacheClientFactory>();
         services.TryAddTransient<IManualDistributedCacheClient>(serviceProvider =>
         {
-            var cacheClient = serviceProvider.EnableIsolation() ?
-                serviceProvider.GetRequiredService<ScopedService<IManualDistributedCacheClient>>().Service :
-                serviceProvider.GetRequiredService<SingletonService<IManualDistributedCacheClient>>().Service;
+            var cacheClient = serviceProvider.GetRequiredService<IManualDistributedCacheClient>();
             return new DefaultDistributedCacheClient(cacheClient);
         });
         services.TryAddTransient<IDistributedCacheClient>(serviceProvider
@@ -43,9 +41,7 @@ public static void TryAddMultilevelCache(
         services.TryAddTransient<IMultilevelCacheClientFactory, DefaultMultilevelCacheClientFactory>();
         services.TryAddTransient<IManualMultilevelCacheClient>(serviceProvider =>
         {
-            var cacheClient = serviceProvider.EnableIsolation() ?
-                serviceProvider.GetRequiredService<ScopedService<IManualMultilevelCacheClient>>().Service :
-                serviceProvider.GetRequiredService<SingletonService<IManualMultilevelCacheClient>>().Service;
+            var cacheClient = serviceProvider.GetRequiredService<IManualMultilevelCacheClient>();
             return new DefaultMultilevelCacheClient(cacheClient);
         });
         services.TryAddTransient<IMultilevelCacheClient>(serviceProvider
@@ -65,17 +61,7 @@ private static void AddTypeAlias(
 
     private static void AddCaching(this IServiceCollection services)
     {
-        services.TryAddSingleton<SingletonService<IManualDistributedCacheClient>>(serviceProvider =>
-            new SingletonService<IManualDistributedCacheClient>(serviceProvider.GetRequiredService<IDistributedCacheClientFactory>()
-                .Create()));
-        services.TryAddScoped<ScopedService<IManualDistributedCacheClient>>(serviceProvider =>
-            new ScopedService<IManualDistributedCacheClient>(serviceProvider.GetRequiredService<IDistributedCacheClientFactory>()
-                .Create()));
-
-        services.TryAddSingleton<SingletonService<IManualMultilevelCacheClient>>(serviceProvider =>
-            new SingletonService<IManualMultilevelCacheClient>(serviceProvider.GetRequiredService<IMultilevelCacheClientFactory>()
-                .Create()));
-        services.TryAddScoped<ScopedService<IManualMultilevelCacheClient>>(serviceProvider =>
-            new ScopedService<IManualMultilevelCacheClient>(serviceProvider.GetRequiredService<IMultilevelCacheClientFactory>().Create()));
+        services.TryAddScoped(serviceProvider => serviceProvider.GetRequiredService<IDistributedCacheClientFactory>().Create());
+        services.TryAddScoped(serviceProvider => serviceProvider.GetRequiredService<IMultilevelCacheClientFactory>().Create());
     }
 }

src/Contrib/Caching/Distributed/Masa.Contrib.Caching.Distributed.StackExchangeRedis/Extensions/DistributedCacheBuilderExtensions.cs

@@ -20,58 +20,43 @@ public static void UseStackExchangeRedisCache(
         JsonSerializerOptions? jsonSerializerOptions = null)
     {
         distributedCacheBuilder.Services.AddConfigure<RedisConfigurationOptions>(redisSectionName, distributedCacheBuilder.Name);
-
-        distributedCacheBuilder.UseCustomDistributedCache(serviceProvider =>
-        {
-            var redisConfigurationOptions = ComponentConfigUtils.GetComponentConfigByExecute(
-                serviceProvider,
-                distributedCacheBuilder.Name,
-                redisSectionName,
-                () =>
-                {
-                    if (serviceProvider.EnableIsolation())
-                        return serviceProvider.GetRequiredService<IOptionsSnapshot<RedisConfigurationOptions>>()
-                            .Get(distributedCacheBuilder.Name);
-
-                    var optionsMonitor = serviceProvider.GetRequiredService<IOptionsMonitor<RedisConfigurationOptions>>();
-                    return optionsMonitor.Get(distributedCacheBuilder.Name);
-                });
-
-            return new RedisCacheClient(
-                redisConfigurationOptions,
+        distributedCacheBuilder.Services.AddScoped(serviceProvider => ConnectionMultiplexer.Connect(GetRedisConfig(serviceProvider, distributedCacheBuilder, redisSectionName).GetAvailableRedisOptions()));
+        distributedCacheBuilder.UseCustomDistributedCache(serviceProvider => new RedisCacheClient(
+                serviceProvider.GetRequiredService<ConnectionMultiplexer>(),
+                GetRedisConfig(serviceProvider, distributedCacheBuilder, redisSectionName),
                 serviceProvider.GetService<IFormatCacheKeyProvider>(),
                 jsonSerializerOptions,
-                serviceProvider.GetRequiredService<ITypeAliasFactory>().Create(distributedCacheBuilder.Name));
-        });
+                serviceProvider.GetRequiredService<ITypeAliasFactory>().Create(distributedCacheBuilder.Name))
+        );
     }
 
     public static void UseStackExchangeRedisCache(
         this DistributedCacheBuilder distributedCacheBuilder,
         Action<RedisConfigurationOptions> action,
         JsonSerializerOptions? jsonSerializerOptions = null)
     {
-        distributedCacheBuilder.UseCustomDistributedCache(serviceProvider =>
-        {
-            var redisConfigurationOptions = new RedisConfigurationOptions();
-            action.Invoke(redisConfigurationOptions);
-            var distributedCacheClient = new RedisCacheClient(
+        var redisConfigurationOptions = new RedisConfigurationOptions();
+        action.Invoke(redisConfigurationOptions);
+        distributedCacheBuilder.Services.AddScoped(serviceProvider => ConnectionMultiplexer.Connect(redisConfigurationOptions.GetAvailableRedisOptions()));
+        distributedCacheBuilder.UseCustomDistributedCache(serviceProvider => new RedisCacheClient(
+                serviceProvider.GetRequiredService<ConnectionMultiplexer>(),
                 redisConfigurationOptions,
                 serviceProvider.GetService<IFormatCacheKeyProvider>(),
                 jsonSerializerOptions,
                 serviceProvider.GetRequiredService<ITypeAliasFactory>().Create(distributedCacheBuilder.Name)
-            );
-            return distributedCacheClient;
-        });
+            ));
     }
 
     public static void UseStackExchangeRedisCache(
         this DistributedCacheBuilder distributedCacheBuilder,
         RedisConfigurationOptions redisConfigurationOptions,
         JsonSerializerOptions? jsonSerializerOptions = null)
     {
+        distributedCacheBuilder.Services.AddScoped(serviceProvider => ConnectionMultiplexer.Connect(redisConfigurationOptions.GetAvailableRedisOptions()));
         distributedCacheBuilder.UseCustomDistributedCache(serviceProvider =>
         {
             var distributedCacheClient = new RedisCacheClient(
+                serviceProvider.GetRequiredService<ConnectionMultiplexer>(),
                 redisConfigurationOptions,
                 serviceProvider.GetService<IFormatCacheKeyProvider>(),
                 jsonSerializerOptions,
@@ -80,4 +65,22 @@ public static void UseStackExchangeRedisCache(
             return distributedCacheClient;
         });
     }
+
+    private static RedisConfigurationOptions GetRedisConfig(IServiceProvider serviceProvider, DistributedCacheBuilder distributedCacheBuilder, string redisSectionName)
+    {
+        var redisConfigurationOptions = ComponentConfigUtils.GetComponentConfigByExecute(
+              serviceProvider,
+              distributedCacheBuilder.Name,
+              redisSectionName,
+        () =>
+        {
+            if (serviceProvider.EnableIsolation())
+                return serviceProvider.GetRequiredService<IOptionsSnapshot<RedisConfigurationOptions>>()
+                    .Get(distributedCacheBuilder.Name);
+
+            var optionsMonitor = serviceProvider.GetRequiredService<IOptionsMonitor<RedisConfigurationOptions>>();
+            return optionsMonitor.Get(distributedCacheBuilder.Name);
+        });
+        return redisConfigurationOptions;
+    }
 }

src/Contrib/Caching/Distributed/Masa.Contrib.Caching.Distributed.StackExchangeRedis/RedisCacheClient.cs

@@ -9,11 +9,12 @@ public class RedisCacheClient : RedisCacheClientBase
     private readonly ITypeAliasProvider? _typeAliasProvider;
 
     public RedisCacheClient(
+        IConnectionMultiplexer connect,
         RedisConfigurationOptions redisConfigurationOptions,
         IFormatCacheKeyProvider? formatCacheKeyProvider = null,
         JsonSerializerOptions? jsonSerializerOptions = null,
         ITypeAliasProvider? typeAliasProvider = null)
-        : base(redisConfigurationOptions, jsonSerializerOptions)
+        : base(connect, redisConfigurationOptions, jsonSerializerOptions)
     {
         _formatCacheKeyProvider = formatCacheKeyProvider ?? new DefaultFormatCacheKeyProvider();
         _typeAliasProvider = typeAliasProvider;

src/Contrib/Caching/Distributed/Masa.Contrib.Caching.Distributed.StackExchangeRedis/RedisCacheClientBase.cs

@@ -26,14 +26,15 @@ protected IDatabase Db
     private readonly CacheOptions _globalCacheOptions;
 
     protected RedisCacheClientBase(
+        IConnectionMultiplexer connection,
         RedisConfigurationOptions redisConfigurationOptions,
         JsonSerializerOptions? jsonSerializerOptions)
         : this(redisConfigurationOptions.GlobalCacheOptions, redisConfigurationOptions, jsonSerializerOptions)
     {
         var redisConfiguration = redisConfigurationOptions.GetAvailableRedisOptions();
-        _connection = ConnectionMultiplexer.Connect(redisConfiguration);
+        _connection = connection;
         Subscriber = _connection.GetSubscriber();
-        InstanceId = redisConfiguration.InstanceId;
+        InstanceId =  redisConfiguration.InstanceId;
     }
 
     private RedisCacheClientBase(

src/Contrib/Caching/Distributed/Tests/Masa.Contrib.Caching.Distributed.StackExchangeRedis.Tests/DistributedCacheClientTest.cs

@@ -1,4 +1,4 @@
-// Copyright (c) MASA Stack All rights reserved.
+// Copyright (c) MASA Stack All rights reserved.
 // Licensed under the MIT License. See LICENSE.txt in the project root for license information.
 
 namespace Masa.Contrib.Caching.Distributed.StackExchangeRedis.Tests;
@@ -7,14 +7,15 @@ namespace Masa.Contrib.Caching.Distributed.StackExchangeRedis.Tests;
 public class DistributedCacheClientTest : TestBase
 {
     private RedisCacheClient _distributedCacheClient;
+    private ConnectionMultiplexer _connection;
     private IDatabase _database;
 
     [TestInitialize]
     public void Initialize()
     {
-        _distributedCacheClient = new RedisCacheClient(GetConfigurationOptions());
-
-        _database = ConnectionMultiplexer.Connect(GetConfigurationOptions()).GetDatabase();
+        _connection = ConnectionMultiplexer.Connect(GetConfigurationOptions());
+        _distributedCacheClient = new RedisCacheClient(_connection, GetConfigurationOptions());
+        _database = _connection.GetDatabase();
 
         _distributedCacheClient.Set("test_caching", "1");
         _distributedCacheClient.Set("test_caching_2", Guid.Empty.ToString());
@@ -96,8 +97,9 @@ public async Task SetAndSpecifyTimeAsyncAndUseGlobalOptions(string key, string v
     {
         var globalRedisConfigurationOptions = GetConfigurationOptions();
         globalRedisConfigurationOptions.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(60);
-        var distributedCacheClient = new RedisCacheClient(globalRedisConfigurationOptions);
-        var database = (await ConnectionMultiplexer.ConnectAsync(globalRedisConfigurationOptions)).GetDatabase();
+        var connection = await ConnectionMultiplexer.ConnectAsync(globalRedisConfigurationOptions);
+        var distributedCacheClient = new RedisCacheClient(connection, globalRedisConfigurationOptions);
+        var database = connection.GetDatabase();
 
         await distributedCacheClient.SetAsync(key, value);
         CheckLifeCycle(database, key, 55, 60);
@@ -110,8 +112,9 @@ public void SetAndSpecifyTimeAndUseGlobalOptions(string key, string value)
     {
         var globalRedisConfigurationOptions = GetConfigurationOptions();
         globalRedisConfigurationOptions.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(60);
-        var distributedCacheClient = new RedisCacheClient(globalRedisConfigurationOptions);
-        var database = ConnectionMultiplexer.Connect(globalRedisConfigurationOptions).GetDatabase();
+        var connection = ConnectionMultiplexer.Connect(globalRedisConfigurationOptions);
+        var distributedCacheClient = new RedisCacheClient(connection, globalRedisConfigurationOptions);
+        var database = connection.GetDatabase();
 
         distributedCacheClient.Set(key, value);
         CheckLifeCycle(database, key, 55, 60);
@@ -528,7 +531,7 @@ public void TestGetKeys(string keyPattern, int count)
     public void TestGetKeys2()
     {
         string key = "te" + Guid.NewGuid();
-        var distributedCacheClient = new RedisCacheClient(new RedisConfigurationOptions()
+        var distributedCacheClient = new RedisCacheClient(_connection, new RedisConfigurationOptions()
         {
             GlobalCacheOptions = new CacheOptions()
             {
@@ -851,7 +854,7 @@ public void TestExists()
         {
             CacheKeyType = CacheKeyType.TypeName
         };
-        var distributedCacheClient = new RedisCacheClient(configurationOptions);
+        var distributedCacheClient = new RedisCacheClient(_connection, configurationOptions);
         var key = "redis.exist";
         distributedCacheClient.Set(key, "1");
         Assert.IsFalse(distributedCacheClient.Exists(key));
@@ -874,7 +877,7 @@ public async Task TestExistsAsync()
         {
             CacheKeyType = CacheKeyType.TypeName
         };
-        var distributedCacheClient = new RedisCacheClient(configurationOptions);
+        var distributedCacheClient = new RedisCacheClient(_connection, configurationOptions);
         var key = "redis.exist";
         await distributedCacheClient.SetAsync(key, "1");
         Assert.IsFalse(await distributedCacheClient.ExistsAsync(key));

src/Contrib/Data/IdGenerator/Snowflake/Masa.Contrib.Data.IdGenerator.Snowflake.Distributed.Redis/BaseRedis.cs

@@ -11,9 +11,9 @@ public class BaseRedis
 
     public BaseRedis(RedisConfigurationOptions redisOptions)
     {
-        DistributedCacheClient = new RedisCacheClient(redisOptions);
         var options = (ConfigurationOptions)redisOptions;
         Connection = ConnectionMultiplexer.Connect(options);
+        DistributedCacheClient = new RedisCacheClient(Connection, redisOptions);
         Database = Connection.GetDatabase(options.DefaultDatabase ?? 0);
     }
 }