ASP.NET Core 6中如何实现租户特定单例服务与隔离容器？

方案一：使用Autofac实现租户感知单例 #

Autofac支持自定义生命周期作用域，可基于租户ID创建专属作用域，让服务实例在租户范围内保持单例。

步骤1：集成Autofac到ASP.NET Core 6 #

在Program.cs中替换默认DI容器为Autofac：

var builder = WebApplication.CreateBuilder(args);

// 启用Autofac作为服务提供者工厂
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());

builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    // 后续在这里注册服务和自定义模块
});

var app = builder.Build();
// ... 其他中间件配置

步骤2：实现租户识别上下文 #

通过AsyncLocal存储当前租户ID，确保异步操作中也能获取租户上下文：

public static class TenantContext
{
    private static readonly AsyncLocal<string> _currentTenantId = new();
    public static string? CurrentTenantId => _currentTenantId.Value;
    public static void SetTenantId(string tenantId) => _currentTenantId.Value = tenantId;
}

// 租户识别中间件，示例从请求头获取租户ID
public class TenantIdentificationMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        var tenantId = context.Request.Headers["X-Tenant-Id"].FirstOrDefault();
        if (!string.IsNullOrEmpty(tenantId))
        {
            TenantContext.SetTenantId(tenantId);
        }

        try
        {
            await _next(context);
        }
        finally
        {
            TenantContext.SetTenantId(null);
        }
    }
}

// 在Program.cs中注册中间件
app.UseMiddleware<TenantIdentificationMiddleware>();

步骤3：自定义租户级生命周期模块 #

创建Autofac模块，实现基于租户ID的单例逻辑：

// 标记特性，用于标识需要租户单例的服务
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface)]
public class TenantSingletonAttribute : Attribute { }

public class TenantSingletonModule : Module
{
    protected override void AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration)
    {
        // 仅对标记了TenantSingletonAttribute的服务生效
        if (registration.Services.OfType<IServiceWithType>().Any(s => s.ServiceType.GetCustomAttributes<TenantSingletonAttribute>().Any()))
        {
            registration.Sharing = InstanceSharing.None;
            registration.Lifetime = new TenantSingletonLifetime();
        }
    }
}

// 自定义租户单例生命周期类
public class TenantSingletonLifetime : IComponentLifetime
{
    private readonly ConcurrentDictionary<string, ILifetimeScope> _tenantScopes = new();
    private readonly ILifetimeScope _rootScope;

    public TenantSingletonLifetime(ILifetimeScope rootScope)
    {
        _rootScope = rootScope;
    }

    public ISharingLifetimeScope FindScope(ISharingLifetimeScope mostNestedVisibleScope)
    {
        var tenantId = TenantContext.CurrentTenantId;
        if (string.IsNullOrEmpty(tenantId))
        {
            throw new InvalidOperationException("当前未识别到租户ID");
        }

        // 为每个租户创建独立作用域并注册单例服务
        return _tenantScopes.GetOrAdd(tenantId, id => _rootScope.BeginLifetimeScope(b =>
        {
            b.RegisterType<MessageService>().As<IMessageService>().SingleInstance();
        }));
    }
}

步骤4：注册服务 #

在Autofac容器配置中注册模块和标记服务：

builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    containerBuilder.RegisterModule<TenantSingletonModule>();
    // 标记MessageService为租户单例，启用特性过滤
    containerBuilder.RegisterType<MessageService>().As<IMessageService>().WithAttributeFiltering();
});

方案二：无需第三方库，基于工厂模式实现 #

如果不想引入Autofac，可通过工厂类结合线程安全字典实现租户级单例：

1. 创建租户单例工厂 #

public interface IMessageServiceFactory
{
    IMessageService GetService();
}

public class MessageServiceFactory : IMessageServiceFactory
{
    private readonly ConcurrentDictionary<string, IMessageService> _tenantServices = new();
    private readonly IServiceProvider _serviceProvider;

    public MessageServiceFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IMessageService GetService()
    {
        var tenantId = TenantContext.CurrentTenantId;
        if (string.IsNullOrEmpty(tenantId))
        {
            throw new InvalidOperationException("当前未识别到租户ID");
        }

        // 为每个租户创建并缓存唯一实例，依赖注入由服务提供者处理
        return _tenantServices.GetOrAdd(tenantId, _ => 
            ActivatorUtilities.CreateInstance<MessageService>(_serviceProvider));
    }
}

2. 注册工厂与服务 #

在Program.cs中注册相关服务：

builder.Services.AddSingleton<IMessageServiceFactory, MessageServiceFactory>();
// 注册MessageService的依赖（按需），这里用Transient因为工厂控制实例生命周期
builder.Services.AddTransient<MessageService>();

3. 使用方式 #

在控制器或其他服务中注入工厂，获取租户专属实例：

public class HomeController : ControllerBase
{
    private readonly IMessageService _messageService;

    public HomeController(IMessageServiceFactory factory)
    {
        _messageService = factory.GetService();
    }
}

注意事项 #

• 租户ID的识别逻辑需确保稳定，避免实例串用
• 若服务包含可释放资源，需在租户生命周期结束时（如租户删除）清理对应实例
• 异步操作中要保证TenantContext的AsyncLocal值正确传递，避免上下文丢失

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