Fluent Validation in .Net core

 

In every application, making sure the data is accurate and error-free is crucial. In .NET Core applications, handling this validation process has become easier and more understandable, thanks to FluentValidation. FluentValidation is a popular library that lets you define and apply validation rules in a clear and readable way. In this blog post, we'll dive into how to use FluentValidation to simplify data validation in your .NET Core projects.

What is FluentValidation?

FluentValidation is a free-to-use library in .NET that offers a clearer and easier method to validate data. It's particularly well-liked in ASP.NET Core applications, where checking user inputs in forms, API requests, and other data is often necessary. With FluentValidation, you can create validation rules using a clear and straightforward syntax. This makes your validation logic easy to comprehend and manage, making the process of checking data much simpler.

Getting Started with FluentValidation

To begin using FluentValidation in your .NET Core project, follow these steps:

The tools I utilized for this sample project were:

1. VS 2022 Community Edition
2. Web API
3. FluentValidation NuGet Package
4. .NET 6.0

You can download the source code from GitHub.

Step 1. Install the FluentValidation NuGet Package

Start by installing the FluentValidation NuGet package in your project. You can do this using the Package Manager Console or by adding it to your project file, as demonstrated in the previous section.

  Install-Package FluentValidation
  

Step 2. Create Validation Rules

Next, establish validation rules by crafting validator classes that inherit from AbstractValidator<T>. These classes define how the validation should occur for a specific data type T. For instance:

  public class UserValidator:AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(x => x.Name).NotEmpty().WithMessage("Name is required");
        RuleFor(x => x.Age).InclusiveBetween(18,55).WithMessage("User Age must be between 18 and 60");
        RuleFor(x => x.EmailAddress).NotEmpty().WithMessage("Email is required");
        RuleFor(x => x.EmailAddress).EmailAddress().WithMessage("Email is not valid");
    }
}
  

Step 3. Register the Validators in the Program.cs

You can add below code in Proram.cs file

  builder.Services.AddScoped<IValidator<Person>, PersonValidator>();
  

Step 4. Use Validation in Your Code

In your application code, utilize the validator to check your data objects. For instance, this can be done in an ASP.NET Core controller action.

  namespace FluentValidationTutorials.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class UserController : ControllerBase
    {
        private readonly IValidator<User> validation;

        public PersonController(IValidator<User> validation)
        {
            this.validation = validation;
        }

        [HttpPost("createuser")]
        public async Task<IActionResult> CreatePerson([FromBody] User user)
        {
            var result = await this.validation.ValidateAsync(user);

            if (!result.IsValid)
            {
                return BadRequest(result.ToDictionary());
            }

            return Ok("User created successfully!");
        }
    }
}

//An extension method has been added to group error messages.
public static class FluentValidationExtension
{
    public static IDictionary<string, string[]> ToDictionary(this ValidationResult validationResult)
    {
        return validationResult.Errors
          .GroupBy(x => x.PropertyName)
          .ToDictionary(
            g => g.Key,
            g => g.Select(x => x.ErrorMessage).ToArray()
          );
    }
}
  

Step 5. Handle Validation Errors

If validation doesn't pass, FluentValidation offers clear error messages. You can use these messages to fill your ModelState or manage errors as you wish. The IsValid property of the ValidationResult object tells you whether the data is valid or not.

Advantages of Using FluentValidation

FluentValidation provides many benefits for data validation in .NET Core.

• Readability: The clear and straightforward language used in FluentValidation makes your validation rules easy to read and understand, even in complicated situations.
• Separation of Concerns: By putting validation rules into distinct validator classes, you enhance the organization of your code. This separation ensures different aspects of your codebase are neatly handled, improving overall clarity and maintainability.
• Reusability: Validator classes can be reused in various parts of your application, encouraging the reuse of code. This helps in making your codebase more efficient and reduces the need to rewrite validation logic for different sections of your project.
• Customization: FluentValidation offers a variety of predefined validation rules, and if you have specific requirements, you can easily design custom validators tailored to your needs. This flexibility ensures your validation process aligns perfectly with your unique application requirements.
• Localization: It enables error messages to be localized, simplifying the process of creating applications in multiple languages.