ASP.NET Core如何移除指定用户的Session？

兄弟，这个问题我在做后台权限管控的时候踩过坑！ASP.NET Core里默认的Session机制确实只能操作当前请求的会话，没法直接定位到其他用户的Session，但咱们可以从Session的存储逻辑和用户关联关系入手，给你三个实用的方案，按需选择：

方案1：自定义Session存储关联，主动销毁指定Session #

这个方案的核心是在用户登录时，把用户ID和对应的SessionId做映射存储，封禁时通过用户ID找到所有关联的SessionId，再直接删除存储中的Session数据。

步骤1：登录时建立用户与Session的关联 #

结合你提供的HttpContextAccessorAdapter，在设置用户Session的时候，把SessionId和用户ID绑定（推荐用Redis等分布式缓存，适配集群环境）：

public class HttpContextAccessorAdapter<TAccount> : IAccountAccessor<TAccount> where TAccount : AccountBase 
{ 
    private static string AccountSessionName = "Account"; 
    private readonly IServiceProvider _serviceProvider;

    public HttpContextAccessorAdapter(IHttpContextAccessor accessor, IServiceProvider serviceProvider) 
    { 
        Accessor = accessor; 
        _serviceProvider = serviceProvider;
    } 

    private IHttpContextAccessor Accessor { get; } 

    public TAccount Account { 
        get => Accessor.HttpContext.Session.GetObject<TAccount>(AccountSessionName); 
        set {
            var currentAccount = Get();
            // 登出时移除旧的关联
            if (currentAccount != null && value == null)
            {
                var redis = _serviceProvider.GetRequiredService<IDistributedCache>();
                await redis.HashDeleteAsync($"UserSessions:{currentAccount.Id}", Accessor.HttpContext.Session.Id);
            }

            Accessor.HttpContext.Session.SetObject(AccountSessionName, value);
            
            // 登录时添加新的关联
            if (value != null)
            {
                var redis = _serviceProvider.GetRequiredService<IDistributedCache>();
                var sessionId = Accessor.HttpContext.Session.Id;
                // 用Hash存储用户对应的所有SessionId（支持同一用户多端登录）
                await redis.HashSetAsync($"UserSessions:{value.Id}", sessionId, DateTime.UtcNow.ToString());
                // 映射关系的过期时间和Session保持一致
                await redis.KeyExpireAsync($"UserSessions:{value.Id}", Accessor.HttpContext.Session.IdleTimeout);
            }
        } 
    } 
}

步骤2：封禁时销毁指定用户的Session #

在你的封禁服务里，通过用户ID找到所有关联的SessionId，直接删除存储中的Session数据：

public async Task BanUserAsync(string userId)
{
    var redis = _serviceProvider.GetRequiredService<IDistributedCache>();
    // 获取该用户所有活跃的SessionId
    var sessionIds = await redis.HashKeysAsync($"UserSessions:{userId}");
    
    foreach (var sessionId in sessionIds)
    {
        // 删除ASP.NET Core默认的Session缓存键（格式为.AspNetCore.Session:{SessionId}）
        await redis.RemoveAsync($".AspNetCore.Session:{sessionId}");
        // 移除用户与Session的映射关系
        await redis.HashDeleteAsync($"UserSessions:{userId}", sessionId);
    }
    
    // 最后更新数据库中用户的封禁状态
    await _userRepository.UpdateBanStatus(userId, isBanned: true);
}

注意：如果用的是内存缓存（仅适合单实例），把Redis操作换成内存缓存的集合存储即可，但集群环境必须用分布式缓存。

方案2：利用ASP.NET Core Identity的SecurityStamp（推荐用Identity的场景） #

如果你的项目已经用了ASP.NET Core Identity，这个方案最省心：当用户被封禁时，更新用户的SecurityStamp，这样该用户的所有Session会自动失效，下次请求会被强制重新登录。

实现代码： #

public async Task BanUserWithIdentityAsync(string userId)
{
    var user = await _userManager.FindByIdAsync(userId);
    if (user != null)
    {
        // 更新SecurityStamp，让所有关联Session失效
        user.SecurityStamp = Guid.NewGuid().ToString();
        user.IsBanned = true;
        await _userManager.UpdateAsync(user);
    }
}

原理：Identity会在每个请求验证SecurityStamp和Session中的值是否一致，不一致则视为Session无效，自动清除。

方案3：中间件被动拦截（快速实现，无需主动销毁） #

如果不需要主动立即销毁Session，只是想让封禁用户无法继续操作，可以写一个全局中间件，每次请求检查用户状态，若已封禁则清除当前Session：

中间件代码： #

public class BanCheckMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, IAccountAccessor<AccountBase> accountAccessor, IUserRepository userRepo)
    {
        var currentAccount = accountAccessor.Account;
        if (currentAccount != null)
        {
            var user = await userRepo.GetByIdAsync(currentAccount.Id);
            if (user.IsBanned)
            {
                // 清除当前用户Session
                context.Session.Clear();
                // 跳转到封禁提示页
                context.Response.Redirect("/Account/Banned");
                return;
            }
        }
        // 状态正常，继续执行后续中间件
        await _next(context);
    }
}

// 在Program.cs中注册中间件（要放在UseSession之后）
app.UseSession();
app.UseMiddleware<BanCheckMiddleware>();

这个方案的优点是实现简单，缺点是不会主动销毁Session，要等用户发起下一次请求才会触发拦截。

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