Introduction
Data validation is a fundamental aspect of any application, ensuring that user inputs meet the required criteria before processing. FluentValidation is a powerful .NET library that simplifies the validation process while maintaining clean and maintainable code.
In this article, we will explore:
- Why FluentValidation?
- Setting up FluentValidation in .NET Core
- Writing custom validators
- Integrating FluentValidation with CQRS
- Handling localization for multilingual validation messages
Why FluentValidation?
Key Benefits:
✅ Separation of Concerns – Keeps validation logic separate from business rules.
✅ Improved Readability – Uses an expressive, fluent API for defining validation rules.
✅ Reusable & Maintainable – Eliminates repetitive validation logic across multiple components.
✅ Supports Complex Validations – Easily handle conditional and cross-field validations.
✅ Built-in Localization – Supports multi-language validation messages.
✅ Seamless Integration – Works well with ASP.NET Core and Dependency Injection.
1️⃣ Installing FluentValidation
To get started, install the FluentValidation package via NuGet:
Install-Package FluentValidation.AspNetCore
Then, register FluentValidation in Program.cs:
var builder = WebApplication.CreateBuilder(args);
// Register FluentValidation
builder.Services.AddControllers();
builder.Services.AddFluentValidationAutoValidation();
builder.Services.AddValidatorsFromAssemblyContaining<CarValidator>();
var app = builder.Build();
app.UseAuthorization();
app.MapControllers();
app.Run();
2️⃣ Creating a Validator Class
Let's define a Car model and create a validator for it:
public class Car
{
public string Make { get; set; }
public string Model { get; set; }
public string VIN { get; set; }
public int Year { get; set; }
public decimal PricePerDay { get; set; }
}
Writing a Validator for the Car Model
using FluentValidation;
public class CarValidator : AbstractValidator<Car>
{
public CarValidator()
{
RuleFor(car => car.Make)
.NotEmpty().WithMessage("Make is required")
.MaximumLength(50).WithMessage("Make cannot exceed 50 characters");
RuleFor(car => car.Model)
.NotEmpty().WithMessage("Model is required")
.MaximumLength(50).WithMessage("Model cannot exceed 50 characters");
RuleFor(car => car.VIN)
.NotEmpty().WithMessage("VIN is required")
.Matches("^[A-HJ-NPR-Z0-9]{17}$").WithMessage("VIN must be exactly 17 characters");
RuleFor(car => car.Year)
.InclusiveBetween(1886, DateTime.UtcNow.Year)
.WithMessage($"Year must be between 1886 and {DateTime.UtcNow.Year}");
RuleFor(car => car.PricePerDay)
.GreaterThan(0).WithMessage("Price per day must be greater than zero");
}
}
3️⃣ Using FluentValidation in Controllers
[ApiController]
[Route("api/cars")]
public class CarController : ControllerBase
{
[HttpPost]
public IActionResult CreateCar([FromBody] Car car)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
return Ok("Car successfully created");
}
}
With FluentValidation, validation happens automatically, and invalid requests return structured error messages.
4️⃣ Advanced: Integrating FluentValidation with CQRS
In a CQRS (Command Query Responsibility Segregation) architecture, FluentValidation helps validate commands before they reach the handler.
Define a CreateCarCommand:
using MediatR;
public class CreateCarCommand : IRequest<int>
{
public string Make { get; set; }
public string Model { get; set; }
public int Year { get; set; }
}
Create a Validator for the Command:
public class CreateCarCommandValidator : AbstractValidator<CreateCarCommand>
{
public CreateCarCommandValidator()
{
RuleFor(command => command.Make).NotEmpty().WithMessage("Make is required");
RuleFor(command => command.Model).NotEmpty().WithMessage("Model is required");
RuleFor(command => command.Year).InclusiveBetween(1886, DateTime.UtcNow.Year);
}
}
Register and Validate in a Handler:
public class CreateCarCommandHandler : IRequestHandler<CreateCarCommand, int>
{
public async Task<int> Handle(CreateCarCommand request, CancellationToken cancellationToken)
{
// Business logic for car creation
return await Task.FromResult(1);
}
}
Now, whenever CreateCarCommand is executed, FluentValidation ensures the request is valid before reaching the handler.
5️⃣ Localization Support (Multi-language Validation Messages)
To support multiple languages, integrate a translation service:
RuleFor(car => car.Make)
.NotEmpty().WithMessage(_ => _translationService.GetTranslation("MakeRequired"));
Example Translation Service:
public interface ITranslationService
{
string GetTranslation(string key);
}
public class TranslationService : ITranslationService
{
private readonly Dictionary<string, string> _translations = new()
{
{ "MakeRequired", "La marque est requise" } // French Example
};
public string GetTranslation(string key)
{
return _translations.TryGetValue(key, out var value) ? value : key;
}
}
This way, validation messages can be translated dynamically based on the user's language.
Conclusion
FluentValidation is a powerful tool for managing input validation in .NET Core applications. It keeps validation logic clean, reusable, and maintainable while supporting complex business rules, CQRS integration, and localization.
🚀 Want More Advanced Logic?
Check out a full GitHub example integrating FluentValidation with CQRS:
🔗 GitHub – FluentValidation with CQRS
Are you using FluentValidation in your projects? Let’s discuss in the comments! 👇
Top comments (0)