Razor Pages中服务层(Service Layer)验证实现问题

方案1：让服务层返回独立的验证结果（推荐） #

服务层不应该依赖Web层的ModelState，这会破坏分层架构的关注点分离。更好的做法是自定义一个验证结果对象，让StudentService返回验证错误，再由Razor Pages的PageModel将错误映射到ModelState中。

步骤： #

1. 定义验证结果类：

public class ServiceValidationResult
{
    public bool IsValid { get; set; }
    public Dictionary<string, string> Errors { get; set; } = new();

    // 快捷方法：添加错误
    public void AddError(string key, string message)
    {
        Errors.Add(key, message);
        IsValid = false;
    }
}

2. 在StudentService的方法中实现验证逻辑，返回验证结果：

public class StudentService : IStudentService
{
    private readonly IStudentRepository _studentRepo;

    public StudentService(IStudentRepository studentRepo)
    {
        _studentRepo = studentRepo;
    }

    public async Task<ServiceValidationResult> CreateStudentAsync(Student student)
    {
        var result = new ServiceValidationResult();

        // 自定义验证逻辑
        if (string.IsNullOrWhiteSpace(student.Name))
        {
            result.AddError(nameof(student.Name), "学生姓名不能为空");
        }

        if (student.Age <= 0 || student.Age > 100)
        {
            result.AddError(nameof(student.Age), "年龄必须在1-100之间");
        }

        // 如果验证通过，执行业务逻辑
        if (result.IsValid)
        {
            await _studentRepo.AddAsync(student);
        }

        return result;
    }
}

3. 在Razor Pages的PageModel中处理验证结果，映射到ModelState：

public class CreateStudentModel : PageModel
{
    private readonly IStudentService _studentService;

    public CreateStudentModel(IStudentService studentService)
    {
        _studentService = studentService;
    }

    [BindProperty]
    public Student Student { get; set; }

    public async Task<IActionResult> OnPostAsync()
    {
        // 先做基础模型验证
        if (!ModelState.IsValid)
        {
            return Page();
        }

        // 调用服务层的验证和业务逻辑
        var validationResult = await _studentService.CreateStudentAsync(Student);

        if (!validationResult.IsValid)
        {
            // 将服务层的错误添加到ModelState
            foreach (var error in validationResult.Errors)
            {
                ModelState.AddModelError(error.Key, error.Value);
            }
            return Page();
        }

        return RedirectToPage("./Index");
    }
}

方案2：直接在方法参数中传入ModelState（快速实现） #

如果只是想快速复用现有逻辑，可以在调用服务方法时，把PageModel的ModelState作为参数传进去。这种方式会让服务层依赖Web层的ModelStateDictionary，但能快速实现需求。

示例： #

1. 修改IStudentService和StudentService的方法：

public interface IStudentService
{
    Task<bool> CreateStudentAsync(Student student, ModelStateDictionary modelState);
}

public class StudentService : IStudentService
{
    private readonly IStudentRepository _studentRepo;

    public StudentService(IStudentRepository studentRepo)
    {
        _studentRepo = studentRepo;
    }

    public async Task<bool> CreateStudentAsync(Student student, ModelStateDictionary modelState)
    {
        // 直接操作ModelState
        if (string.IsNullOrWhiteSpace(student.Name))
        {
            modelState.AddModelError(nameof(student.Name), "学生姓名不能为空");
        }

        if (student.Age <= 0 || student.Age > 100)
        {
            modelState.AddModelError(nameof(student.Age), "年龄必须在1-100之间");
        }

        if (!modelState.IsValid)
        {
            return false;
        }

        await _studentRepo.AddAsync(student);
        return true;
    }
}

2. 在PageModel中调用：

public async Task<IActionResult> OnPostAsync()
{
    if (!await _studentService.CreateStudentAsync(Student, ModelState))
    {
        return Page();
    }

    return RedirectToPage("./Index");
}

方案3：注入验证上下文（进阶解耦） #

如果想在服务层中解耦ModelState，可以定义一个通用的验证接口，让ModelState实现这个接口，然后注入到服务中。

步骤： #

1. 定义验证接口：

public interface IValidationContext
{
    bool IsValid { get; }
    void AddError(string key, string message);
}

2. 实现基于ModelState的验证上下文：

public class ModelStateValidationContext : IValidationContext
{
    private readonly ModelStateDictionary _modelState;

    public ModelStateValidationContext(ModelStateDictionary modelState)
    {
        _modelState = modelState;
    }

    public bool IsValid => _modelState.IsValid;

    public void AddError(string key, string message)
    {
        _modelState.AddModelError(key, message);
    }
}

3. 注册服务（ModelStateDictionary是Scoped的，所以上下文也注册为Scoped）：

services.AddScoped<IValidationContext>(sp => 
    new ModelStateValidationContext(sp.GetRequiredService<ModelStateDictionary>())
);

4. 在StudentService中注入IValidationContext：

public class StudentService : IStudentService
{
    private readonly IStudentRepository _studentRepo;
    private readonly IValidationContext _validationContext;

    public StudentService(IStudentRepository studentRepo, IValidationContext validationContext)
    {
        _studentRepo = studentRepo;
        _validationContext = validationContext;
    }

    public async Task<bool> CreateStudentAsync(Student student)
    {
        if (string.IsNullOrWhiteSpace(student.Name))
        {
            _validationContext.AddError(nameof(student.Name), "学生姓名不能为空");
        }

        if (student.Age <= 0 || student.Age > 100)
        {
            _validationContext.AddError(nameof(student.Age), "年龄必须在1-100之间");
        }

        if (!_validationContext.IsValid)
        {
            return false;
        }

        await _studentRepo.AddAsync(student);
        return true;
    }
}

5. 在PageModel中调用：

public async Task<IActionResult> OnPostAsync()
{
    if (!await _studentService.CreateStudentAsync(Student))
    {
        return Page();
    }

    return RedirectToPage("./Index");
}

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