ASP.NET Core WebAPI 2中通过IOC获取FluentValidation验证器实例

Hey there, I've been in your exact situation before—manual instantiation of validators gets messy fast, especially when you want to keep things testable and aligned with dependency injection principles. Since you've already registered FluentValidation in your Startup class, we just need to tap into the DI container properly to grab your validator instance.

Here's how to do it step by step:

1. Confirm Validator Registration (Optional but Good to Verify) #

First, make sure your MyClassValidator is properly registered with the DI container. The AddFluentValidation() extension method automatically scans your assembly for validators that inherit from AbstractValidator<T>, but you can explicitly specify the assembly to avoid any confusion:

// In Startup.cs -> ConfigureServices
services.AddMvc()
    .AddFluentValidation(fv => 
    {
        // Scans the assembly containing MyClassValidator to register all validators
        fv.RegisterValidatorsFromAssemblyContaining<MyClassValidator>();
    });

This ensures IValidator<MyClass> is available in the DI container for injection.

2. Inject the Validator into Your Controller #

Instead of manually creating MyClassValidator, inject IValidator<MyClass> directly into your controller's constructor. This lets the DI container handle instantiation and lifecycle management:

public class MyController : ControllerBase
{
    private readonly IValidator<MyClass> _myClassValidator;

    // Inject the validator via constructor
    public MyController(IValidator<MyClass> myClassValidator)
    {
        _myClassValidator = myClassValidator;
    }

    // Your action method here
}

3. Use the Injected Validator with Your Rule Set #

Now in your action method, you can call Validate() on the injected validator instance and specify your rule set just like before:

[HttpPost]
public IActionResult MyAction(MyClass obj)
{
    // Validate using the injected validator and target rule set
    var validationResult = _myClassValidator.Validate(obj, ruleSet: "RulesetName");

    if (!validationResult.IsValid)
    {
        // Return validation errors as a bad request
        return BadRequest(validationResult.Errors.Select(e => new { e.PropertyName, e.ErrorMessage }));
    }

    // Proceed with your business logic
    return Ok("Object validated successfully!");
}

Bonus: Use IValidatorFactory for Dynamic Validator Retrieval #

If you need to fetch validators dynamically (e.g., based on runtime conditions), you can inject IValidatorFactory instead:

public class MyController : ControllerBase
{
    private readonly IValidatorFactory _validatorFactory;

    public MyController(IValidatorFactory validatorFactory)
    {
        _validatorFactory = validatorFactory;
    }

    [HttpPost]
    public IActionResult MyAction(MyClass obj)
    {
        var validator = _validatorFactory.GetValidator<MyClass>();
        var validationResult = validator.Validate(obj, ruleSet: "RulesetName");
        
        // Handle validation result as before
    }
}

This approach keeps your code clean, testable (you can easily mock IValidator<MyClass> in unit tests), and follows ASP.NET Core's dependency injection best practices.

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