如何通过Microsoft依赖注入实现租户级单例服务？

一、基于依赖注入扩展实现租户级单例 #

1. 租户实例管理器方案 #

核心思路是维护一个以租户ID为键的服务实例缓存，结合IServiceScopeFactory为每个租户创建专属作用域，确保每个租户的服务仅初始化一次。

示例代码：

public class TenantSingletonManager<T> where T : class
{
    private readonly ConcurrentDictionary<string, T> _tenantInstances = new();
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly Func<IServiceProvider, T> _instanceCreator;

    public TenantSingletonManager(IServiceScopeFactory scopeFactory, Func<IServiceProvider, T> instanceCreator)
    {
        _scopeFactory = scopeFactory;
        _instanceCreator = instanceCreator;
    }

    public T GetTenantInstance(string tenantId)
    {
        return _tenantInstances.GetOrAdd(tenantId, id =>
        {
            using var tenantScope = _scopeFactory.CreateScope();
            var instance = _instanceCreator(tenantScope.ServiceProvider);
            // 在此执行数据初始化逻辑，比如从租户专属数据库加载数据
            return instance;
        });
    }
}

注册方式：

services.AddSingleton<TenantSingletonManager<YourTenantDataService>>();
services.AddScoped<YourTenantDataService>(); // 内部可注入租户专属DB上下文等依赖

使用示例：

public class DataController : ControllerBase
{
    private readonly TenantSingletonManager<YourTenantDataService> _tenantManager;

    public DataController(TenantSingletonManager<YourTenantDataService> tenantManager)
    {
        _tenantManager = tenantManager;
    }

    [HttpGet]
    public IActionResult GetCachedData()
    {
        var tenantId = ExtractTenantIdFromRequest(); // 自定义逻辑从请求中获取租户ID
        var tenantService = _tenantManager.GetTenantInstance(tenantId);
        var cachedData = tenantService.GetData();
        return Ok(cachedData);
    }
}

2. 自定义DI扩展封装 #

可以将上述逻辑封装为IServiceCollection的扩展方法，让注册更简洁，本质逻辑与上述方案一致。

二、替代方案 #

1. 带过期策略的缓存式单例 #

针对你提到的键值对Singleton内存占用问题，可结合IMemoryCache添加自动过期清理机制，避免闲置租户数据长期占用内存：

public class TenantCachedService
{
    private readonly IMemoryCache _cache;
    private readonly IDbContextFactory<TenantDbContext> _dbContextFactory;

    public TenantCachedService(IMemoryCache cache, IDbContextFactory<TenantDbContext> dbContextFactory)
    {
        _cache = cache;
        _dbContextFactory = dbContextFactory;
    }

    public async Task<CoreData> GetTenantDataAsync(string tenantId)
    {
        return await _cache.GetOrCreateAsync($"Tenant_{tenantId}_Data", async entry =>
        {
            entry.SlidingExpiration = TimeSpan.FromHours(12); // 12小时未访问自动清理
            using var dbContext = await _dbContextFactory.CreateDbContextAsync();
            return await dbContext.CoreData.FirstOrDefaultAsync();
        });
    }
}

注册为Singleton：

services.AddSingleton<TenantCachedService>();
services.AddDbContextFactory<TenantDbContext>(options => /* 租户数据库配置 */);

2. 分布式缓存方案（多实例部署场景） #

如果Web API是多实例集群部署，本地内存缓存会导致实例间数据不一致，此时可改用Redis等分布式缓存，以租户ID为键存储数据，同时设置过期时间，既实现租户隔离，又能跨实例共享缓存。

3. 租户专属作用域内的单例 #

通过中间件为每个租户请求创建专属作用域，在该作用域内注册Singleton服务，同一租户的请求复用该作用域内的实例，不同租户的作用域相互隔离：

中间件示例：

public class TenantScopeMiddleware
{
    private readonly RequestDelegate _next;

    public TenantScopeMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context, IServiceScopeFactory scopeFactory)
    {
        var tenantId = ExtractTenantIdFromRequest(context);
        using var tenantScope = scopeFactory.CreateScope();
        tenantScope.ServiceProvider.GetRequiredService<ITenantContext>().TenantId = tenantId;
        context.Items["TenantScope"] = tenantScope;
        await _next(context);
    }
}

注册服务：

services.AddScoped<ITenantContext, TenantContext>();
services.AddSingleton<YourTenantDataService>(); // 该单例仅在租户作用域内有效

总结 #

• 如需严格实现租户级单例，自定义租户实例管理器是最直接的方案，结合IServiceScopeFactory保证实例隔离。
• 对内存占用敏感时，优先选择带过期策略的缓存方案，自动清理闲置租户数据。
• 多实例部署场景下，分布式缓存是更可靠的选择，避免数据一致性问题。

内容的提问来源于stack exchange，提问作者Weanich Sanchol