MVC内部应用重构：跨应用持久化用户数据的简便可靠方案咨询

针对你这个小型内部MVC应用的用户数据传递需求，我给你几个轻量又可靠的方案——都是适合从零搭建的项目，完全不用搞那些重量级的身份验证框架，简单实用：

1. 请求内传递：HttpContext.Items + 自定义中间件 #

这是最直接的方案，适合只需要在单个请求生命周期内传递用户对象的场景，比如控制器、视图、服务之间共享用户数据。

实现步骤： #

首先写一个自定义中间件，在请求开始时完成用户校验并把对象存入HttpContext.Items：

public class UserContextMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IUserRepository _userRepo; // 假设你有查询用户的仓储类

    public UserContextMiddleware(RequestDelegate next, IUserRepository userRepo)
    {
        _next = next;
        _userRepo = userRepo;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 从HttpContext获取用户名（这里根据你的实际方式调整，比如Cookie/Header）
        var userName = context.User.Identity?.Name ?? context.Request.Headers["X-Username"];
        if (!string.IsNullOrEmpty(userName))
        {
            // 查数据库获取完整用户对象
            var user = await _userRepo.GetUserByUserNameAsync(userName);
            if (user != null)
            {
                // 存入HttpContext.Items，供整个请求链路使用
                context.Items["CurrentUser"] = user;
            }
        }

        await _next(context);
    }
}

// 写个扩展方法，方便全局获取用户
public static class HttpContextExtensions
{
    public static User GetCurrentUser(this HttpContext context)
    {
        return context.Items["CurrentUser"] as User;
    }
}

然后在Startup.cs里注册中间件（注意顺序要放在路由之前）：

app.UseMiddleware<UserContextMiddleware>();

使用方式： #

• 控制器里：var currentUser = HttpContext.GetCurrentUser();
• 视图里：@Context.GetCurrentUser().DisplayName

2. 跨请求持久化：Session缓存 #

如果希望用户登录后不用每次请求都查数据库，可以结合Session做轻量缓存，适合小型内部应用的会话持久化需求。

实现步骤： #

首先在Startup.cs里配置Session：

// ConfigureServices中
services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(15); // 会话过期时间
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
});

// Configure中（要放在UseRouting之前）
app.UseSession();

然后修改中间件，优先从Session取用户对象，不存在再查库：

public async Task InvokeAsync(HttpContext context)
{
    // 先从Session获取序列化的用户对象
    var user = context.Session.GetObjectFromJson<User>("CurrentUser");
    if (user == null)
    {
        var userName = context.User.Identity?.Name ?? context.Request.Headers["X-Username"];
        if (!string.IsNullOrEmpty(userName))
        {
            user = await _userRepo.GetUserByUserNameAsync(userName);
            if (user != null)
            {
                // 序列化存入Session，同时放入HttpContext.Items
                context.Session.SetObjectAsJson("CurrentUser", user);
                context.Items["CurrentUser"] = user;
            }
        }
    }
    else
    {
        context.Items["CurrentUser"] = user;
    }

    await _next(context);
}

// Session序列化扩展方法
public static class SessionExtensions
{
    public static void SetObjectAsJson(this ISession session, string key, object value)
    {
        session.SetString(key, JsonSerializer.Serialize(value));
    }

    public static T GetObjectFromJson<T>(this ISession session, string key)
    {
        var value = session.GetString(key);
        return value == null ? default : JsonSerializer.Deserialize<T>(value);
    }
}

3. 规范解耦：依赖注入IUserAccessor #

如果想让代码更符合MVC的依赖注入设计原则，避免直接依赖HttpContext，可以封装一个用户访问服务。

实现步骤： #

先定义接口和实现类（Scoped生命周期，每个请求一个实例）：

public interface IUserAccessor
{
    User CurrentUser { get; set; }
}

public class UserAccessor : IUserAccessor
{
    public User CurrentUser { get; set; }
}

在Startup.cs里注册服务：

services.AddScoped<IUserAccessor, UserAccessor>();

修改中间件注入IUserAccessor并赋值：

public class UserContextMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IUserRepository _userRepo;
    private readonly IUserAccessor _userAccessor;

    public UserContextMiddleware(RequestDelegate next, IUserRepository userRepo, IUserAccessor userAccessor)
    {
        _next = next;
        _userRepo = userRepo;
        _userAccessor = userAccessor;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var userName = context.User.Identity?.Name ?? context.Request.Headers["X-Username"];
        if (!string.IsNullOrEmpty(userName))
        {
            var user = await _userRepo.GetUserByUserNameAsync(userName);
            if (user != null)
            {
                _userAccessor.CurrentUser = user;
            }
        }

        await _next(context);
    }
}

使用方式： #

在控制器或服务中直接注入IUserAccessor：

public class HomeController : Controller
{
    private readonly IUserAccessor _userAccessor;

    public HomeController(IUserAccessor userAccessor)
    {
        _userAccessor = userAccessor;
    }

    public IActionResult Index()
    {
        var currentUser = _userAccessor.CurrentUser;
        // 业务逻辑处理
        return View();
    }
}

方案选择建议 #

• 只需要请求内传递：选方案1，最简单直接
• 需要跨请求缓存用户数据：选方案2，轻量无额外依赖
• 想让代码更规范解耦：选方案3，符合MVC设计模式

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