无私分享：从入门到精通ASP.NET MVC】从0开始，一起搭框架、做项目（6）控制器基类——统一处理登录用户、权限认证与日志记录

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;
    private readonly IUserService _userService;
 
    public HomeController(ILogger<HomeController> logger, IUserService userService)
    {
        _logger = logger;
        _userService = userService;
    }
 
    public ActionResult Index()
    {
        // 1. 获取当前用户信息
        var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        if (string.IsNullOrEmpty(userId))
        {
            return RedirectToAction("Login", "Account");
        }
        var user = _userService.GetUserById(userId);
        if (user == null)
        {
            return RedirectToAction("Login", "Account");
        }
 
        // 2. 权限验证（假设需要 "Home.View" 权限）
        if (!_userService.HasPermission(user.Id, "Home.View"))
        {
            return new HttpStatusCodeResult(403, "无访问权限");
        }
 
        // 3. 记录日志
        _logger.LogInformation($"用户 {user.UserName} 访问了首页");
 
        // 业务逻辑...
        return View();
    }
}

using System.Security.Claims;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.Logging;
 
// 基类继承自 Controller
public class BaseController : Controller
{
    // 后续会添加构造函数、属性和方法
}

// 日志服务（记录操作日志和异常）
protected readonly ILogger<BaseController> _logger;
// 用户服务（获取用户信息、验证权限）
protected readonly IUserService _userService;
 
// 构造函数注入依赖
public BaseController(ILogger<BaseController> logger, IUserService userService)
{
    _logger = logger;
    _userService = userService;
}

// 当前登录用户信息（延迟加载，首次访问时解析）
private UserInfo _currentUser;
protected UserInfo CurrentUser
{
    get
    {
        if (_currentUser != null) return _currentUser;
 
        // 从 HttpContext.User 中解析用户 ID（假设登录时已将用户 ID 存入 ClaimTypes.NameIdentifier）
        var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
        if (string.IsNullOrEmpty(userId))
        {
            // 未登录：抛出异常或返回 null，根据业务需求处理
            _logger.LogWarning("当前用户未登录");
            return null;
        }
 
        // 从用户服务获取完整用户信息（包含角色、权限等）
        _currentUser = _userService.GetUserById(userId);
        if (_currentUser == null)
        {
            _logger.LogError($"用户 ID {userId} 不存在");
            return null;
        }
 
        return _currentUser;
    }
}
 
// 用户信息模型（示例）
public class UserInfo
{
    public string Id { get; set; } // 用户 ID
    public string UserName { get; set; } // 用户名
    public List<string> Roles { get; set; } // 角色列表
    public List<string> Permissions { get; set; } // 权限列表
}
 
// IUserService 接口（示例）
public interface IUserService
{
    UserInfo GetUserById(string userId);
    bool HasPermission(string userId, string permission);
}

public class HomeController : BaseController
{
    public HomeController(ILogger<BaseController> logger, IUserService userService) 
        : base(logger, userService) { }
 
    public IActionResult Index()
    {
        // 直接使用基类的 CurrentUser 属性
        ViewBag.UserName = CurrentUser?.UserName; 
        return View();
    }
}

// 用于标记 Action 所需权限的特性
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class AuthorizePermissionAttribute : Attribute
{
    public string Permission { get; }
 
    // 构造函数：传入所需权限（如 "Home.View"）
    public AuthorizePermissionAttribute(string permission)
    {
        Permission = permission;
    }
}

public override void OnActionExecuting(ActionExecutingContext context)
{
    // 1. 先执行基类逻辑（必须调用，确保 MVC 框架正常工作）
    base.OnActionExecuting(context);
 
    // 2. 检查用户是否已登录
    if (CurrentUser == null)
    {
        // 未登录：跳转到登录页（或返回 401）
        context.Result = new RedirectToActionResult("Login", "Account", null);
        return;
    }
 
    // 3. 获取当前 Action 标记的权限需求
    var requiredPermissions = context.ActionDescriptor.EndpointMetadata
        .OfType<AuthorizePermissionAttribute>()
        .Select(attr => attr.Permission)
        .ToList();
 
    // 4. 若无需权限，直接放行
    if (!requiredPermissions.Any()) return;
 
    // 5. 检查用户是否拥有所有 requiredPermissions
    var hasAllPermissions = requiredPermissions.All(perm => 
        _userService.HasPermission(CurrentUser.Id, perm)
    );
 
    if (!hasAllPermissions)
    {
        // 无权限：返回 403 Forbidden
        context.Result = new ForbidResult();
        _logger.LogWarning($"用户 {CurrentUser.UserName} 尝试访问无权限资源：{string.Join(",", requiredPermissions)}");
    }
}

// Action 执行前日志
public override void OnActionExecuting(ActionExecutingContext context)
{
    base.OnActionExecuting(context);
 
    // 记录 Action 开始执行（包含控制器名、Action 名、用户信息、参数）
    var controllerName = context.ActionDescriptor.ControllerName;
    var actionName = context.ActionDescriptor.ActionName;
    var parameters = string.Join(", ", context.ActionArguments.Select(kv => $"{kv.Key}={kv.Value}"));
    
    _logger.LogInformation(
        "Action 开始执行：Controller={Controller}, Action={Action}, User={User}, Parameters={Parameters}",
        controllerName, actionName, CurrentUser?.UserName ?? "未登录用户", parameters
    );
}
 
// Action 执行后日志
public override void OnActionExecuted(ActionExecutedContext context)
{
    base.OnActionExecuted(context);
 
    var controllerName = context.ActionDescriptor.ControllerName;
    var actionName = context.ActionDescriptor.ActionName;
 
    // 记录 Action 执行结束（包含是否成功、耗时）
    if (context.Exception == null)
    {
        _logger.LogInformation(
            "Action 执行成功：Controller={Controller}, Action={Action}, User={User}",
            controllerName, actionName, CurrentUser?.UserName ?? "未登录用户"
        );
    }
    else
    {
        // 异常已在 OnException 中处理，此处仅记录执行失败
        _logger.LogError(
            "Action 执行失败：Controller={Controller}, Action={Action}, User={User}",
            controllerName, actionName, CurrentUser?.UserName ?? "未登录用户"
        );
    }
}

public override void OnException(ExceptionContext context)
{
    base.OnException(context);
 
    var exception = context.Exception;
    var controllerName = context.ActionDescriptor.ControllerName;
    var actionName = context.ActionDescriptor.ActionName;
 
    // 记录异常详情（包含堆栈跟踪）
    _logger.LogError(
        exception, 
        "Action 执行异常：Controller={Controller}, Action={Action}, User={User}, Message={Message}",
        controllerName, actionName, CurrentUser?.UserName ?? "未登录用户", exception.Message
    );
 
    // 标记异常已处理，避免 MVC 框架默认返回 500 错误页（可选）
    context.ExceptionHandled = true;
 
    // 返回自定义错误响应（如 JSON 或错误视图）
    if (Request.Headers["Accept"].Contains("application/json"))
    {
        context.Result = new JsonResult(new { 
            success = false, 
            message = "操作失败：" + exception.Message 
        }) { StatusCode = 500 };
    }
    else
    {
        context.Result = View("Error", new ErrorViewModel { Message = exception.Message });
    }
}

// 异步 Action 执行前（替代 OnActionExecuting）
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
    // 执行同步逻辑（如权限检查）
    OnActionExecuting(context);
    if (context.Result != null)
    {
        // 若已设置 Result（如跳转、403），直接返回
        return;
    }
 
    // 执行后续逻辑（包括 Action 本身）
    var resultContext = await next();
 
    // 执行 Action 后逻辑（如日志记录）
    OnActionExecuted(resultContext);
}

public class HomeController : BaseController
{
    // 构造函数需调用基类构造函数，传入依赖
    public HomeController(ILogger<BaseController> logger, IUserService userService) 
        : base(logger, userService) { }
 
    // 无需权限的 Action（如首页）
    public IActionResult Index()
    {
        ViewBag.UserName = CurrentUser?.UserName; // 使用基类的 CurrentUser
        return View();
    }
 
    // 需要 "Order.View" 权限的 Action
    [AuthorizePermission("Order.View")]
    public IActionResult MyOrders()
    {
        // 业务逻辑：查询当前用户的订单
        var orders = _orderService.GetOrdersByUserId(CurrentUser.Id);
        return View(orders);
    }
 
    // 异步 Action 示例
    [AuthorizePermission("User.Edit")]
    public async Task<IActionResult> EditProfile()
    {
        var user = await _userService.GetUserByIdAsync(CurrentUser.Id);
        return View(user);
    }
}