Clear tenant cache on name change.

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/AbpAspNetCoreMvcClientCacheOptions.cs

@@ -4,13 +4,10 @@ namespace Volo.Abp.AspNetCore.Mvc.Client;
 
 public class AbpAspNetCoreMvcClientCacheOptions
 {
-    public TimeSpan TenantConfigurationCacheAbsoluteExpiration { get; set; }
-
     public TimeSpan ApplicationConfigurationDtoCacheAbsoluteExpiration { get; set; }
 
     public AbpAspNetCoreMvcClientCacheOptions()
     {
-        TenantConfigurationCacheAbsoluteExpiration = TimeSpan.FromMinutes(5);
         ApplicationConfigurationDtoCacheAbsoluteExpiration = TimeSpan.FromSeconds(300);
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/AbpAspNetCoreMvcClientModule.cs

@@ -18,7 +18,6 @@ public class AbpAspNetCoreMvcClientModule : AbpModule
         {
             Configure<AbpAspNetCoreMvcClientCacheOptions>(options =>
             {
-                options.TenantConfigurationCacheAbsoluteExpiration = TimeSpan.FromSeconds(5);
                 options.ApplicationConfigurationDtoCacheAbsoluteExpiration = TimeSpan.FromSeconds(5);
             });
         }

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/MvcRemoteTenantStore.cs

@@ -1,10 +1,8 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Caching.Distributed;
 using Microsoft.Extensions.Options;
 using Pages.Abp.MultiTenancy.ClientProxies;
-using Volo.Abp.AspNetCore.Mvc.MultiTenancy;
 using Volo.Abp.Caching;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.MultiTenancy;
@@ -16,13 +14,13 @@ public class MvcRemoteTenantStore : ITenantStore, ITransientDependency
 {
     protected AbpTenantClientProxy TenantAppService { get; }
     protected IHttpContextAccessor HttpContextAccessor { get; }
-    protected IDistributedCache<TenantConfiguration> Cache { get; }
+    protected IDistributedCache<TenantConfigurationCacheItem> Cache { get; }
     protected AbpAspNetCoreMvcClientCacheOptions Options { get; }
 
     public MvcRemoteTenantStore(
         AbpTenantClientProxy tenantAppService,
         IHttpContextAccessor httpContextAccessor,
-        IDistributedCache<TenantConfiguration> cache,
+        IDistributedCache<TenantConfigurationCacheItem> cache,
         IOptions<AbpAspNetCoreMvcClientCacheOptions> options)
     {
         TenantAppService = tenantAppService;
@@ -33,119 +31,101 @@ public class MvcRemoteTenantStore : ITenantStore, ITransientDependency
 
     public async Task<TenantConfiguration?> FindAsync(string name)
     {
-        var cacheKey = TenantConfigurationCacheHelper.CreateCacheKey(name);
+        var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(name);
         var httpContext = HttpContextAccessor?.HttpContext;
 
-        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfiguration tenantConfiguration)
+        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfigurationCacheItem tenantConfigurationInHttpContext)
         {
-            return tenantConfiguration;
+            return tenantConfigurationInHttpContext?.Value;
         }
 
-        tenantConfiguration = (await Cache.GetOrAddAsync(
-            cacheKey,
-            async () => CreateTenantConfiguration(await TenantAppService.FindTenantByNameAsync(name))!,
-            () => new DistributedCacheEntryOptions
-            {
-                AbsoluteExpirationRelativeToNow = Options.TenantConfigurationCacheAbsoluteExpiration
-            }
-        ))!;
+        var tenantConfiguration = await Cache.GetAsync(cacheKey);
+        if (tenantConfiguration == null)
+        {
+            await TenantAppService.FindTenantByNameAsync(name);
+            tenantConfiguration = await Cache.GetAsync(cacheKey);
+        }
 
         if (httpContext != null)
         {
             httpContext.Items[cacheKey] = tenantConfiguration;
         }
 
-        return tenantConfiguration;
+        return tenantConfiguration?.Value;
     }
 
     public async Task<TenantConfiguration?> FindAsync(Guid id)
     {
-        var cacheKey = TenantConfigurationCacheHelper.CreateCacheKey(id);
+        var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(id);
         var httpContext = HttpContextAccessor?.HttpContext;
 
-        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfiguration tenantConfiguration)
+        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfigurationCacheItem tenantConfigurationInHttpContext)
         {
-            return tenantConfiguration;
+            return tenantConfigurationInHttpContext?.Value;
         }
 
-        tenantConfiguration = (await Cache.GetOrAddAsync(
-            cacheKey,
-            async () => CreateTenantConfiguration(await TenantAppService.FindTenantByIdAsync(id))!,
-            () => new DistributedCacheEntryOptions
-            {
-                AbsoluteExpirationRelativeToNow = Options.TenantConfigurationCacheAbsoluteExpiration
-            }
-        ))!;
+        var tenantConfiguration = await Cache.GetAsync(cacheKey);
+        if (tenantConfiguration == null)
+        {
+            await TenantAppService.FindTenantByIdAsync(id);
+            tenantConfiguration = await Cache.GetAsync(cacheKey);
+        }
 
         if (httpContext != null)
         {
             httpContext.Items[cacheKey] = tenantConfiguration;
         }
 
-        return tenantConfiguration;
+        return tenantConfiguration?.Value;
     }
 
-    public TenantConfiguration Find(string name)
+    public TenantConfiguration? Find(string name)
     {
-        var cacheKey = TenantConfigurationCacheHelper.CreateCacheKey(name);
+        var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(name);
         var httpContext = HttpContextAccessor?.HttpContext;
 
-        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfiguration tenantConfiguration)
+        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfigurationCacheItem tenantConfigurationInHttpContext)
         {
-            return tenantConfiguration;
+            return tenantConfigurationInHttpContext?.Value;
         }
 
-        tenantConfiguration = Cache.GetOrAdd(
-            cacheKey,
-            () => AsyncHelper.RunSync(async () => CreateTenantConfiguration(await TenantAppService.FindTenantByNameAsync(name))!),
-            () => new DistributedCacheEntryOptions
-            {
-                AbsoluteExpirationRelativeToNow = Options.TenantConfigurationCacheAbsoluteExpiration
-            }
-        )!;
+        var tenantConfiguration = Cache.Get(cacheKey);
+        if (tenantConfiguration == null)
+        {
+            AsyncHelper.RunSync(async () => await TenantAppService.FindTenantByNameAsync(name));
+            tenantConfiguration = Cache.Get(cacheKey);
+        }
 
         if (httpContext != null)
         {
             httpContext.Items[cacheKey] = tenantConfiguration;
         }
 
-        return tenantConfiguration;
+        return tenantConfiguration?.Value;
     }
 
-    public TenantConfiguration Find(Guid id)
+    public TenantConfiguration? Find(Guid id)
     {
-        var cacheKey = TenantConfigurationCacheHelper.CreateCacheKey(id);
+        var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(id);
         var httpContext = HttpContextAccessor?.HttpContext;
 
-        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfiguration tenantConfiguration)
+        if (httpContext != null && httpContext.Items[cacheKey] is TenantConfigurationCacheItem tenantConfigurationInHttpContext)
         {
-            return tenantConfiguration;
+            return tenantConfigurationInHttpContext?.Value;
         }
 
-        tenantConfiguration = Cache.GetOrAdd(
-            cacheKey,
-            () => AsyncHelper.RunSync(async () => CreateTenantConfiguration(await TenantAppService.FindTenantByIdAsync(id))!),
-            () => new DistributedCacheEntryOptions
-            {
-                AbsoluteExpirationRelativeToNow = Options.TenantConfigurationCacheAbsoluteExpiration
-            }
-        )!;
-
-        if (httpContext != null)
+        var tenantConfiguration = Cache.Get(cacheKey);
+        if (tenantConfiguration == null)
         {
-            httpContext.Items[cacheKey] = tenantConfiguration;
+            AsyncHelper.RunSync(async () => await TenantAppService.FindTenantByIdAsync(id));
+            tenantConfiguration = Cache.Get(cacheKey);
         }
 
-        return tenantConfiguration;
-    }
-
-    protected virtual TenantConfiguration? CreateTenantConfiguration(FindTenantResultDto tenantResultDto)
-    {
-        if (!tenantResultDto.Success || tenantResultDto.TenantId == null)
+        if (httpContext != null)
         {
-            return null;
+            httpContext.Items[cacheKey] = tenantConfiguration;
         }
 
-        return new TenantConfiguration(tenantResultDto.TenantId.Value, tenantResultDto.Name!);
+        return tenantConfiguration?.Value;
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.Contracts/Volo/Abp/AspNetCore/Mvc/MultiTenancy/TenantConfigurationCacheHelper.cs

@@ -1,16 +0,0 @@
-using System;
-
-namespace Volo.Abp.AspNetCore.Mvc.MultiTenancy;
-
-public static class TenantConfigurationCacheHelper
-{
-    public static string CreateCacheKey(string tenantName)
-    {
-        return $"RemoteTenantStore_Name_{tenantName}";
-    }
-
-    public static string CreateCacheKey(Guid tenantId)
-    {
-        return $"RemoteTenantStore_Id_{tenantId:N}";
-    }
-}

framework/src/Volo.Abp.MultiTenancy.Abstractions/Volo/Abp/MultiTenancy/TenantConfigurationCacheItem.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace Volo.Abp.MultiTenancy;
+
+[Serializable]
+[IgnoreMultiTenancy]
+public class TenantConfigurationCacheItem
+{
+    private const string CacheKeyFormat = "i:{0},n:{1}";
+
+    public TenantConfiguration? Value { get; set; }
+
+    public TenantConfigurationCacheItem()
+    {
+
+    }
+
+    public TenantConfigurationCacheItem(TenantConfiguration? value)
+    {
+        Value = value;
+    }
+
+    public static string CalculateCacheKey(Guid? id, string? name)
+    {
+        if (id == null && name.IsNullOrWhiteSpace())
+        {
+            throw new AbpException("Both id and name can't be invalid.");
+        }
+        return string.Format(CacheKeyFormat,
+            id?.ToString() ?? "null",
+            (name.IsNullOrWhiteSpace() ? "null" : name));
+    }
+
+    public static string CalculateCacheKey(Guid id)
+    {
+        return string.Format(CacheKeyFormat, id.ToString(), "null" );
+    }
+
+    public static string CalculateCacheKey(string name)
+    {
+        return string.Format(CacheKeyFormat, "null", name);
+    }
+}

modules/tenant-management/src/Volo.Abp.TenantManagement.Application.Contracts/Volo.Abp.TenantManagement.Application.Contracts.csproj

@@ -18,7 +18,6 @@
     <ProjectReference Include="..\Volo.Abp.TenantManagement.Domain.Shared\Volo.Abp.TenantManagement.Domain.Shared.csproj" />
     <ProjectReference Include="..\..\..\..\framework\src\Volo.Abp.Ddd.Application.Contracts\Volo.Abp.Ddd.Application.Contracts.csproj" />
     <ProjectReference Include="..\..\..\..\framework\src\Volo.Abp.Authorization.Abstractions\Volo.Abp.Authorization.Abstractions.csproj" />
-    <ProjectReference Include="..\..\..\..\framework\src\Volo.Abp.AspNetCore.Mvc.Contracts\Volo.Abp.AspNetCore.Mvc.Contracts.csproj" />
   </ItemGroup>
 
 </Project>

modules/tenant-management/src/Volo.Abp.TenantManagement.Application.Contracts/Volo/Abp/TenantManagement/AbpTenantManagementApplicationContractsModule.cs

@@ -1,5 +1,4 @@
 using Volo.Abp.Application;
-using Volo.Abp.AspNetCore.Mvc;
 using Volo.Abp.Authorization;
 using Volo.Abp.Modularity;
 using Volo.Abp.ObjectExtending;
@@ -11,8 +10,7 @@ namespace Volo.Abp.TenantManagement;
 [DependsOn(
     typeof(AbpDddApplicationContractsModule),
     typeof(AbpTenantManagementDomainSharedModule),
-    typeof(AbpAuthorizationAbstractionsModule),
-    typeof(AbpAspNetCoreMvcContractsModule)
+    typeof(AbpAuthorizationAbstractionsModule)
     )]
 public class AbpTenantManagementApplicationContractsModule : AbpModule
 {

modules/tenant-management/src/Volo.Abp.TenantManagement.Application/Volo/Abp/TenantManagement/TenantAppService.cs

@@ -3,8 +3,6 @@ using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Volo.Abp.Application.Dtos;
-using Volo.Abp.AspNetCore.Mvc.MultiTenancy;
-using Volo.Abp.Caching;
 using Volo.Abp.Data;
 using Volo.Abp.EventBus.Distributed;
 using Volo.Abp.MultiTenancy;
@@ -19,20 +17,17 @@ public class TenantAppService : TenantManagementAppServiceBase, ITenantAppServic
     protected ITenantRepository TenantRepository { get; }
     protected ITenantManager TenantManager { get; }
     protected IDistributedEventBus DistributedEventBus { get; }
-    protected IDistributedCache<TenantConfiguration> TenantConfigurationCache { get; }
 
     public TenantAppService(
         ITenantRepository tenantRepository,
         ITenantManager tenantManager,
         IDataSeeder dataSeeder,
-        IDistributedEventBus distributedEventBus,
-        IDistributedCache<TenantConfiguration> tenantConfigurationCache)
+        IDistributedEventBus distributedEventBus)
     {
         DataSeeder = dataSeeder;
         TenantRepository = tenantRepository;
         TenantManager = tenantManager;
         DistributedEventBus = distributedEventBus;
-        TenantConfigurationCache = tenantConfigurationCache;
     }
 
     public virtual async Task<TenantDto> GetAsync(Guid id)
@@ -96,9 +91,6 @@ public class TenantAppService : TenantManagementAppServiceBase, ITenantAppServic
                             );
         }
 
-        await TenantConfigurationCache.RemoveAsync(TenantConfigurationCacheHelper.CreateCacheKey(tenant.Id));
-        await TenantConfigurationCache.RemoveAsync(TenantConfigurationCacheHelper.CreateCacheKey(tenant.Name));
-
         return ObjectMapper.Map<Tenant, TenantDto>(tenant);
     }
 
@@ -114,9 +106,6 @@ public class TenantAppService : TenantManagementAppServiceBase, ITenantAppServic
 
         await TenantRepository.UpdateAsync(tenant);
 
-        await TenantConfigurationCache.RemoveAsync(TenantConfigurationCacheHelper.CreateCacheKey(tenant.Id));
-        await TenantConfigurationCache.RemoveAsync(TenantConfigurationCacheHelper.CreateCacheKey(tenant.Name));
-
         return ObjectMapper.Map<Tenant, TenantDto>(tenant);
     }
 
@@ -130,9 +119,6 @@ public class TenantAppService : TenantManagementAppServiceBase, ITenantAppServic
         }
 
         await TenantRepository.DeleteAsync(tenant);
-
-        await TenantConfigurationCache.RemoveAsync(TenantConfigurationCacheHelper.CreateCacheKey(tenant.Id));
-        await TenantConfigurationCache.RemoveAsync(TenantConfigurationCacheHelper.CreateCacheKey(tenant.Name));
     }
 
     [Authorize(TenantManagementPermissions.Tenants.ManageConnectionStrings)]

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantCacheItem.cs

@@ -1,35 +0,0 @@
-using System;
-using Volo.Abp.MultiTenancy;
-
-namespace Volo.Abp.TenantManagement;
-
-[Serializable]
-[IgnoreMultiTenancy]
-public class TenantCacheItem
-{
-    private const string CacheKeyFormat = "i:{0},n:{1}";
-
-    public TenantConfiguration Value { get; set; }
-
-    public TenantCacheItem()
-    {
-
-    }
-
-    public TenantCacheItem(TenantConfiguration value)
-    {
-        Value = value;
-    }
-
-    public static string CalculateCacheKey(Guid? id, string name)
-    {
-        if (id == null && name.IsNullOrWhiteSpace())
-        {
-            throw new AbpException("Both id and name can't be invalid.");
-        }
-
-        return string.Format(CacheKeyFormat,
-            id?.ToString() ?? "null",
-            (name.IsNullOrWhiteSpace() ? "null" : name));
-    }
-}

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantCacheItemInvalidator.cs

@@ -1,23 +0,0 @@
-using System.Threading.Tasks;
-using Volo.Abp.Caching;
-using Volo.Abp.DependencyInjection;
-using Volo.Abp.Domain.Entities.Events;
-using Volo.Abp.EventBus;
-
-namespace Volo.Abp.TenantManagement;
-
-public class TenantCacheItemInvalidator : ILocalEventHandler<EntityChangedEventData<Tenant>>, ITransientDependency
-{
-    protected IDistributedCache<TenantCacheItem> Cache { get; }
-
-    public TenantCacheItemInvalidator(IDistributedCache<TenantCacheItem> cache)
-    {
-        Cache = cache;
-    }
-
-    public virtual async Task HandleEventAsync(EntityChangedEventData<Tenant> eventData)
-    {
-        await Cache.RemoveAsync(TenantCacheItem.CalculateCacheKey(eventData.Entity.Id, null), considerUow: true);
-        await Cache.RemoveAsync(TenantCacheItem.CalculateCacheKey(null, eventData.Entity.Name), considerUow: true);
-    }
-}

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantConfigurationCacheItemInvalidator.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Threading.Tasks;
+using Volo.Abp.Caching;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Entities.Events;
+using Volo.Abp.EventBus;
+using Volo.Abp.MultiTenancy;
+
+namespace Volo.Abp.TenantManagement;
+
+
+public class TenantConfigurationCacheItemInvalidator :
+    ILocalEventHandler<EntityChangedEventData<Tenant>>,
+    ILocalEventHandler<EntityDeletedEventData<Tenant>>, ITransientDependency
+{
+    protected IDistributedCache<TenantConfigurationCacheItem> Cache { get; }
+
+    public TenantConfigurationCacheItemInvalidator(IDistributedCache<TenantConfigurationCacheItem> cache)
+    {
+        Cache = cache;
+    }
+
+    public virtual async Task HandleEventAsync(EntityChangedEventData<Tenant> eventData)
+    {
+        await ClearCacheAsync(eventData.Entity.Id, eventData.Entity.Name);
+    }
+
+    public virtual async Task HandleEventAsync(EntityDeletedEventData<Tenant> eventData)
+    {
+        await ClearCacheAsync(eventData.Entity.Id, eventData.Entity.Name);
+    }
+
+    protected virtual async Task ClearCacheAsync(Guid? id, string name)
+    {
+        await Cache.RemoveManyAsync(
+            new[]
+            {
+                TenantConfigurationCacheItem.CalculateCacheKey(id, null),
+                TenantConfigurationCacheItem.CalculateCacheKey(null, name),
+            });
+    }
+}

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantManager.cs

@@ -1,17 +1,21 @@
 using System;
 using System.Threading.Tasks;
+using Volo.Abp.Caching;
 using Volo.Abp.Domain.Services;
+using Volo.Abp.MultiTenancy;
 
 namespace Volo.Abp.TenantManagement;
 
 public class TenantManager : DomainService, ITenantManager
 {
     protected ITenantRepository TenantRepository { get; }
+    protected IDistributedCache<TenantConfigurationCacheItem> Cache { get; }
 
-    public TenantManager(ITenantRepository tenantRepository)
+    public TenantManager(ITenantRepository tenantRepository,
+        IDistributedCache<TenantConfigurationCacheItem> cache)
     {
         TenantRepository = tenantRepository;
-
+        Cache = cache;
     }
 
     public virtual async Task<Tenant> CreateAsync(string name)
@@ -28,6 +32,7 @@ public class TenantManager : DomainService, ITenantManager
         Check.NotNull(name, nameof(name));
 
         await ValidateNameAsync(name, tenant.Id);
+        await Cache.RemoveAsync(TenantConfigurationCacheItem.CalculateCacheKey(tenant.Name));
         tenant.SetName(name);
     }
 

modules/tenant-management/src/Volo.Abp.TenantManagement.Domain/Volo/Abp/TenantManagement/TenantStore.cs

@@ -13,13 +13,13 @@ public class TenantStore : ITenantStore, ITransientDependency
     protected ITenantRepository TenantRepository { get; }
     protected IObjectMapper<AbpTenantManagementDomainModule> ObjectMapper { get; }
     protected ICurrentTenant CurrentTenant { get; }
-    protected IDistributedCache<TenantCacheItem> Cache { get; }
+    protected IDistributedCache<TenantConfigurationCacheItem> Cache { get; }
 
     public TenantStore(
         ITenantRepository tenantRepository,
         IObjectMapper<AbpTenantManagementDomainModule> objectMapper,
         ICurrentTenant currentTenant,
-        IDistributedCache<TenantCacheItem> cache)
+        IDistributedCache<TenantConfigurationCacheItem> cache)
     {
         TenantRepository = tenantRepository;
         ObjectMapper = objectMapper;
@@ -49,7 +49,7 @@ public class TenantStore : ITenantStore, ITransientDependency
         return (GetCacheItem(id, null)).Value;
     }
 
-    protected virtual async Task<TenantCacheItem> GetCacheItemAsync(Guid? id, string name)
+    protected virtual async Task<TenantConfigurationCacheItem> GetCacheItemAsync(Guid? id, string name)
     {
         var cacheKey = CalculateCacheKey(id, name);
 
@@ -80,16 +80,16 @@ public class TenantStore : ITenantStore, ITransientDependency
         throw new AbpException("Both id and name can't be invalid.");
     }
 
-    protected virtual async Task<TenantCacheItem> SetCacheAsync(string cacheKey, [CanBeNull] Tenant tenant)
+    protected virtual async Task<TenantConfigurationCacheItem> SetCacheAsync(string cacheKey, [CanBeNull] Tenant tenant)
     {
         var tenantConfiguration = tenant != null ? ObjectMapper.Map<Tenant, TenantConfiguration>(tenant) : null;
-        var cacheItem = new TenantCacheItem(tenantConfiguration);
+        var cacheItem = new TenantConfigurationCacheItem(tenantConfiguration);
         await Cache.SetAsync(cacheKey, cacheItem, considerUow: true);
         return cacheItem;
     }
 
     [Obsolete("Use GetCacheItemAsync method.")]
-    protected virtual TenantCacheItem GetCacheItem(Guid? id, string name)
+    protected virtual TenantConfigurationCacheItem GetCacheItem(Guid? id, string name)
     {
         var cacheKey = CalculateCacheKey(id, name);
 
@@ -121,16 +121,16 @@ public class TenantStore : ITenantStore, ITransientDependency
     }
 
     [Obsolete("Use SetCacheAsync method.")]
-    protected virtual TenantCacheItem SetCache(string cacheKey, [CanBeNull] Tenant tenant)
+    protected virtual TenantConfigurationCacheItem SetCache(string cacheKey, [CanBeNull] Tenant tenant)
     {
         var tenantConfiguration = tenant != null ? ObjectMapper.Map<Tenant, TenantConfiguration>(tenant) : null;
-        var cacheItem = new TenantCacheItem(tenantConfiguration);
+        var cacheItem = new TenantConfigurationCacheItem(tenantConfiguration);
         Cache.Set(cacheKey, cacheItem, considerUow: true);
         return cacheItem;
     }
 
     protected virtual string CalculateCacheKey(Guid? id, string name)
     {
-        return TenantCacheItem.CalculateCacheKey(id, name);
+        return TenantConfigurationCacheItem.CalculateCacheKey(id, name);
     }
 }

modules/tenant-management/test/Volo.Abp.TenantManagement.Domain.Tests/Volo/Abp/TenantManagement/TenantCacheItemInvalidator_Tests.cs

@@ -6,17 +6,19 @@ using Xunit;
 
 namespace Volo.Abp.TenantManagement;
 
-public class TenantCacheItemInvalidator_Tests : AbpTenantManagementDomainTestBase
+public class TenantConfigurationCacheItemInvalidator_Tests : AbpTenantManagementDomainTestBase
 {
-    private readonly IDistributedCache<TenantCacheItem> _cache;
+    private readonly IDistributedCache<TenantConfigurationCacheItem> _cache;
     private readonly ITenantStore _tenantStore;
     private readonly ITenantRepository _tenantRepository;
+    private readonly ITenantManager _tenantManager;
 
-    public TenantCacheItemInvalidator_Tests()
+    public TenantConfigurationCacheItemInvalidator_Tests()
     {
-        _cache = GetRequiredService<IDistributedCache<TenantCacheItem>>();
+        _cache = GetRequiredService<IDistributedCache<TenantConfigurationCacheItem>>();
         _tenantStore = GetRequiredService<ITenantStore>();
         _tenantRepository = GetRequiredService<ITenantRepository>();
+        _tenantManager = GetRequiredService<ITenantManager>();
     }
 
     [Fact]
@@ -25,27 +27,27 @@ public class TenantCacheItemInvalidator_Tests : AbpTenantManagementDomainTestBas
         var acme = await _tenantRepository.FindByNameAsync("acme");
         acme.ShouldNotBeNull();
 
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(acme.Id, null))).ShouldBeNull();
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(null, acme.Name))).ShouldBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(acme.Id, null))).ShouldBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, acme.Name))).ShouldBeNull();
 
         await _tenantStore.FindAsync(acme.Id);
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(acme.Id, null))).ShouldNotBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(acme.Id, null))).ShouldNotBeNull();
 
         await _tenantStore.FindAsync(acme.Name);
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(null, acme.Name))).ShouldNotBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, acme.Name))).ShouldNotBeNull();
 
 
         var volosoft = _tenantRepository.FindByName("volosoft");
         volosoft.ShouldNotBeNull();
 
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldBeNull();
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldBeNull();
 
         _tenantStore.Find(volosoft.Id);
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldNotBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldNotBeNull();
 
         _tenantStore.Find(volosoft.Name);
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldNotBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldNotBeNull();
     }
 
     [Fact]
@@ -58,13 +60,13 @@ public class TenantCacheItemInvalidator_Tests : AbpTenantManagementDomainTestBas
         await _tenantStore.FindAsync(acme.Id);
         await _tenantStore.FindAsync(acme.Name);
 
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(acme.Id, null))).ShouldNotBeNull();
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(null, acme.Name))).ShouldNotBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(acme.Id, null))).ShouldNotBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, acme.Name))).ShouldNotBeNull();
 
         await _tenantRepository.DeleteAsync(acme);
 
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(acme.Id, null))).ShouldBeNull();
-        (await _cache.GetAsync(TenantCacheItem.CalculateCacheKey(null, acme.Name))).ShouldBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(acme.Id, null))).ShouldBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, acme.Name))).ShouldBeNull();
 
 
         var volosoft = await _tenantRepository.FindByNameAsync("volosoft");
@@ -74,12 +76,29 @@ public class TenantCacheItemInvalidator_Tests : AbpTenantManagementDomainTestBas
         _tenantStore.Find(volosoft.Id);
         _tenantStore.Find(volosoft.Name);
 
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldNotBeNull();
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldNotBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldNotBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldNotBeNull();
 
         await _tenantRepository.DeleteAsync(volosoft);
 
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldBeNull();
-        (_cache.Get(TenantCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(volosoft.Id, null))).ShouldBeNull();
+        (_cache.Get(TenantConfigurationCacheItem.CalculateCacheKey(null, volosoft.Name))).ShouldBeNull();
+
+        var abp = await _tenantRepository.FindByNameAsync("abp");
+        abp.ShouldNotBeNull();
+
+        // Find will cache tenant.
+        await _tenantStore.FindAsync(abp.Id);
+        await _tenantStore.FindAsync(abp.Name);
+
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(abp.Id, null))).ShouldNotBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, abp.Name))).ShouldNotBeNull();
+
+        await _tenantManager.ChangeNameAsync(abp, "abp2");
+        await _tenantRepository.UpdateAsync(abp);
+
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(abp.Id, null))).ShouldBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, "abp"))).ShouldBeNull();
+        (await _cache.GetAsync(TenantConfigurationCacheItem.CalculateCacheKey(null, "abp2"))).ShouldBeNull();
     }
 }

modules/tenant-management/test/Volo.Abp.TenantManagement.TestBase/Volo/Abp/TenantManagement/AbpTenantManagementTestDataBuilder.cs

@@ -32,5 +32,8 @@ public class AbpTenantManagementTestDataBuilder : ITransientDependency
 
         var volosoft = await _tenantManager.CreateAsync("volosoft");
         await _tenantRepository.InsertAsync(volosoft);
+
+        var abp = await _tenantManager.CreateAsync("abp");
+        await _tenantRepository.InsertAsync(abp);
     }
 }