Enhancing .NET Validation with Fluent Validation

Validation is a critical aspect of software development, ensuring that data entered by users or obtained from external sources meets the expected criteria. While .NET offers built-in validation mechanisms, developers often seek more flexibility and expressiveness in their validation logic. Now we have Fluent Validation – a powerful library that simplifies and enriches the validation process in .NET applications.

What is Fluent Validation

FluentValidation is a .NET library that provides a fluent interface for defining validation rules in a clear and concise manner. Unlike traditional validation approaches, which may involve cluttered code and boilerplate, FluentValidation offers an elegant syntax for declaring validation rules, making the codebase more readable and maintainable.

Getting Started with Fluent Validation

To begin using FluentValidation in your .NET project, simply install the FluentValidation package via NuGet. Once installed, you can define validation rules for your model classes by creating validator classes that inherit from the AbstractValidator<T> base class. These validator classes encapsulate the validation logic for each corresponding model.

Creating Validation Rules

FluentValidation provides a rich set of built-in validators for common scenarios such as required fields, string length constraints, regular expressions, and more. Additionally, you can easily create custom validators to handle complex validation scenarios specific to your application’s requirements. The fluent syntax allows you to chain validation rules together intuitively, resulting in clean and expressive code.

Key Features of Fluent Validation

1. Fluent API: The library employs a fluent and expressive syntax for defining validation rules, making the code easy to read and maintain.
2. Separation of Concerns: FluentValidation encourages the separation of validation logic from the business entities, promoting a clean and modular design.
3. Extensibility: Developers can easily extend FluentValidation by creating custom validators and validation rules tailored to their application’s requirements.
4. Integration with ASP.NET Core: FluentValidation integrates seamlessly with ASP.NET Core, simplifying the validation of user input in web applications.
   

Example

Let’s illustrate some key features of FluentValidation with an example.

Consider a simple scenario where we have a user registration form in an ASP.NET Core MVC application. We want to validate the user’s input to ensure that the username is not empty, the email is in a valid format, and the password meets certain criteria.

Here’s how you can use FluentValidation to implement validation for this scenario:

1. Define the Model

public class UserRegistrationViewModel
{
public string Username { get; set; }
public string Email { get; set; }
public string Password { get; set; }
}

2. Create the Validator

using FluentValidation;

public class UserRegistrationViewModelValidator : AbstractValidator<UserRegistrationViewModel>
{
public UserRegistrationViewModelValidator()
{
RuleFor(x => x.Username)
.NotEmpty().WithMessage("Username is required.");

RuleFor(x => x.Email)
.NotEmpty().WithMessage("Email is required.")
.EmailAddress().WithMessage("Invalid email address format.");

RuleFor(x => x.Password)
.NotEmpty().WithMessage("Password is required.")
.MinimumLength(8).WithMessage("Password must be at least 8 characters long.");
}
}

3. Integrate with ASP.NET Core Controller

using Microsoft.AspNetCore.Mvc;

public class UserController : Controller
{
[HttpPost]
public IActionResult Register(UserRegistrationViewModel model)
{
var validator = new UserRegistrationViewModelValidator();
var validationResult = validator.Validate(model);

if (!validationResult.IsValid)
{
foreach (var error in validationResult.Errors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return BadRequest(ModelState);
}

// Registration logic if validation passes
return Ok("User registered successfully!");
}
}

4. Localization Support

We can provide localized error messages for different languages by utilizing resource files or custom message providers. For example, we can create resource files for different languages and specify localized error messages for each validation rule.

This example demonstrates how Fluent Validation simplifies the process of defining and enforcing validation rules in an ASP.NET Core application. It provides a fluent and expressive way to specify validation logic, integrates seamlessly with ASP.NET Core controllers, and supports localization for a better user experience.

Advanced Validation Scenarios

Cross-Property Validation: Suppose we want to ensure that the password confirmation matches the password entered by the user.

public class UserRegistrationViewModelValidator : AbstractValidator<UserRegistrationViewModel>
{
public UserRegistrationViewModelValidator()
{
RuleFor(x => x.Password)
.NotEmpty().WithMessage("Password is required.")
.MinimumLength(8).WithMessage("Password must be at least 8 characters long.");

RuleFor(x => x.ConfirmPassword)
.NotEmpty().WithMessage("Password confirmation is required.")
.Equal(x => x.Password).WithMessage("Password confirmation does not match the password.");
}
}

Group Validation: Suppose we want to ensure that at least one of the fields (Username, Email, or Password) is provided.

public class UserRegistrationViewModelValidator : AbstractValidator<UserRegistrationViewModel>
{
public UserRegistrationViewModelValidator()
{
RuleFor(x => x.Username).NotEmpty().When(x => string.IsNullOrEmpty(x.Email) && string.IsNullOrEmpty(x.Password))
.WithMessage("Username, email, or password is required.");

RuleFor(x => x.Email).NotEmpty().When(x => string.IsNullOrEmpty(x.Username) && string.IsNullOrEmpty(x.Password))
.WithMessage("Username, email, or password is required.");

RuleFor(x => x.Password).NotEmpty().When(x => string.IsNullOrEmpty(x.Username) && string.IsNullOrEmpty(x.Email))
.WithMessage("Username, email, or password is required.");
}
}

Asynchronous Validation: Suppose we need to perform an asynchronous validation, such as checking if the email already exists in the database.

public class UserRegistrationViewModelValidator : AbstractValidator<UserRegistrationViewModel>
{
private readonly IUserService _userService;

public UserRegistrationViewModelValidator(IUserService userService)
{
_userService = userService;

RuleFor(x => x.Email)
.NotEmpty().WithMessage("Email is required.")
.EmailAddress().WithMessage("Invalid email address format.")
.MustAsync(BeUniqueEmail).WithMessage("Email already exists.");
}

private async Task<bool> BeUniqueEmail(string email, CancellationToken cancellationToken)
{
return await _userService.IsEmailUniqueAsync(email);
}
}

In these examples, we’ve demonstrated how to handle more advanced validation scenarios using FluentValidation. Cross-property validation ensures that related properties are validated together, group validation allows conditional validation based on multiple properties, and asynchronous validation enables validation logic that requires asynchronous operations.

These features enhance the flexibility and robustness of validation in your application, ensuring that data integrity is maintained and user input is validated effectively.

Conclusion

In conclusion, Fluent Validation stands out as a powerful tool for enhancing validation in .NET applications. Throughout this article, we’ve explored its key features and demonstrated how it simplifies the validation process while offering flexibility and robustness.

By leveraging Fluent Validation’s fluent interface, developers can define validation rules in a clear and concise manner, leading to more readable and maintainable code. Fluent Validation stands out as an essential resource because of it’s ability to separate validation concerns and enhance capabilities. Integration with ASP.NET Core seamlessly incorporates validation into MVC controllers, ensuring consistent handling of validation errors and user feedback.