Dotnet Core 6多租户应用Redis缓存动态配置问题求助

核心思路 #

放弃依赖RedisCacheOptions.InstanceName的静态配置模式，改用租户专属缓存键前缀+包装IDistributedCache的方案，实现从租户数据库动态获取配置，同时避免作用域服务解析错误。

1. 定义租户缓存前缀提供器 #

创建一个作用域服务，负责从租户数据库获取当前租户的缓存前缀，替代固定的InstanceName。

public interface ITenantCachePrefixProvider
{
    Task<string> GetCachePrefixAsync();
}

public class TenantCachePrefixProvider : ITenantCachePrefixProvider
{
    private readonly ITenantHandler _tenantHandler;
    private readonly IDbConnection _dbConnection;
    private readonly IMemoryCache _memoryCache;

    public TenantCachePrefixProvider(ITenantHandler tenantHandler, IDbConnection dbConnection, IMemoryCache memoryCache)
    {
        _tenantHandler = tenantHandler;
        _dbConnection = dbConnection;
        _memoryCache = memoryCache;
    }

    public async Task<string> GetCachePrefixAsync()
    {
        var tenantId = _tenantHandler.CurrentTenantId;
        var cacheKey = $"Tenant_CachePrefix_{tenantId}";

        // 用内存缓存减少数据库查询次数，1小时过期可按需调整
        return await _memoryCache.GetOrCreateAsync(cacheKey, async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1);
            var prefix = await _dbConnection.QueryFirstOrDefaultAsync<string>(
                "SELECT CachePrefix FROM TenantSettings WHERE TenantId = @TenantId",
                new { TenantId = tenantId });
            
            // 兜底默认前缀，避免空值导致键冲突
            return string.IsNullOrEmpty(prefix) ? $"Tenant_{tenantId}_" : prefix;
        });
    }
}

注册服务：

builder.Services.AddScoped<ITenantCachePrefixProvider, TenantCachePrefixProvider>();
builder.Services.AddMemoryCache();
// 这里注册你的数据库连接（比如Dapper的IDbConnection或EF DbContext）
builder.Services.AddScoped<IDbConnection>(sp => 
    new SqlConnection(builder.Configuration.GetConnectionString("TenantDb")));

2. 包装IDistributedCache自动添加租户前缀 #

实现一个自定义的分布式缓存类，对所有缓存操作自动添加当前租户的前缀，避免键重复。

public class TenantDistributedCache : IDistributedCache
{
    private readonly IDistributedCache _innerCache;
    private readonly ITenantCachePrefixProvider _prefixProvider;

    public TenantDistributedCache(IDistributedCache innerCache, ITenantCachePrefixProvider prefixProvider)
    {
        _innerCache = innerCache;
        _prefixProvider = prefixProvider;
    }

    private async Task<string> GetPrefixedKeyAsync(string key)
    {
        var prefix = await _prefixProvider.GetCachePrefixAsync();
        return $"{prefix}{key}";
    }

    // 异步方法实现
    public async Task<byte[]> GetAsync(string key, CancellationToken token = default)
    {
        var prefixedKey = await GetPrefixedKeyAsync(key);
        return await _innerCache.GetAsync(prefixedKey, token);
    }

    public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default)
    {
        var prefixedKey = await GetPrefixedKeyAsync(key);
        await _innerCache.SetAsync(prefixedKey, value, options, token);
    }

    public async Task RefreshAsync(string key, CancellationToken token = default)
    {
        var prefixedKey = await GetPrefixedKeyAsync(key);
        await _innerCache.RefreshAsync(prefixedKey, token);
    }

    public async Task RemoveAsync(string key, CancellationToken token = default)
    {
        var prefixedKey = await GetPrefixedKeyAsync(key);
        await _innerCache.RemoveAsync(prefixedKey, token);
    }

    // 同步方法按需实现（建议优先用异步）
    public byte[] Get(string key)
    {
        var prefixedKey = GetPrefixedKeyAsync(key).GetAwaiter().GetResult();
        return _innerCache.Get(prefixedKey);
    }

    public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
    {
        var prefixedKey = GetPrefixedKeyAsync(key).GetAwaiter().GetResult();
        _innerCache.Set(prefixedKey, value, options);
    }

    public void Refresh(string key)
    {
        var prefixedKey = GetPrefixedKeyAsync(key).GetAwaiter().GetResult();
        _innerCache.Refresh(prefixedKey);
    }

    public void Remove(string key)
    {
        var prefixedKey = GetPrefixedKeyAsync(key).GetAwaiter().GetResult();
        _innerCache.Remove(prefixedKey);
    }
}

3. 替换默认IDistributedCache实现 #

在Program.cs中先注册底层的StackExchangeRedisCache，再用自定义包装类替换IDistributedCache的注册：

// 注册底层Redis缓存，只配置通用参数（不要设置InstanceName）
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
});

// 替换为租户专属的缓存实现（必须是Scoped，因为依赖的ITenantHandler是作用域服务）
builder.Services.AddScoped<IDistributedCache, TenantDistributedCache>();

4. 解决作用域服务解析错误 #

之前出现的InvalidOperationException: Cannot resolve scoped service ITenantHandler from root provider错误，本质是在根服务容器中直接解析了作用域服务。解决要点：

• 确保ITenantHandler是Scoped服务，且仅在请求作用域内使用（比如控制器、中间件、其他Scoped服务中）。
• 如果需要在非请求场景（如后台任务）使用，必须手动创建作用域：

using var scope = app.Services.CreateScope();
var tenantHandler = scope.ServiceProvider.GetRequiredService<ITenantHandler>();
// 执行后台任务逻辑

内容的提问来源于stack exchange，提问作者Faisal Saleem