Fluent Validation in .NET Core

Fluent Validation in .NET Core 8 with Example : In the world of .NET Core development, validation is a crucial aspect of ensuring that the data we handle is accurate and meets the expected criteria. Fluent Validation is a popular library that provides a fluent interface for building strongly-typed validation rules. This chsarpmaster’s blog post will guide you through using Fluent Validation in .NET Core 8 with a detailed example.

What is Fluent Validation?

Fluent Validation is a .NET library that helps developers create validation rules for their models in a fluent and expressive way. It is an open-source library that provides a clear and readable syntax for defining validation logic, making it easier to maintain and extend.

Learn about Dictionary in c#.

Why Use Fluent Validation in .NET Core 8?

Using Fluent Validation in .NET Core 8 brings several benefits:

Strongly Typed Validation: Fluent validation is not like traditional validation methods, Fluent Validation leverages strongly-typed expressions, reducing runtime errors and improving code readability.
Separation of Concerns: Since we are keeping validation logic separate from the model, its encouraging a clean architecture.
Extensibility: Fluent Validation allows us to easily create custom validators and integrate them into your validation rules.
Community Support: As an open-source library, Fluent Validation has a strong community that contributes to its continuous improvement.

Getting Started with Fluent Validation in .NET Core 8

Let’s dive into setting up Fluent Validation in a .NET Core 8 project with a practical example. We will create a simple API that validates user input for a registration form.

Step 1: Setting Up the Project

First, create a new .NET Core 8 Web API project. Open your terminal and run the following command:

dotnet new webapi -n FluentValidationDemo
cd FluentValidationDemo

Next, add the Fluent Validation package to your project:

dotnet add package FluentValidation

Step 2: Creating the Model

Create a UserRegistration model that represents the data we want to validate. In the Models folder, add a new class named UserRegistration.cs:

namespace FluentValidationDemo.Models
{
    public class UserRegistration
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Email { get; set; }
        public string Password { get; set; }
        public string ConfirmPassword { get; set; }
    }
}

Step 3: Creating the Validator

Create a validator for the UserRegistration model. In the Validators folder, add a new class named UserRegistrationValidator.cs:

using FluentValidation;
using FluentValidationDemo.Models;

namespace FluentValidationDemo.Validators
{
    public class UserRegistrationValidator : AbstractValidator<UserRegistration>
    {
        public UserRegistrationValidator()
        {
            RuleFor(user => user.FirstName)
                .NotEmpty().WithMessage("First name is required.")
                .Length(2, 50).WithMessage("First name must be between 2 and 50 characters.");

            RuleFor(user => user.LastName)
                .NotEmpty().WithMessage("Last name is required.")
                .Length(2, 50).WithMessage("Last name must be between 2 and 50 characters.");

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

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

            RuleFor(user => user.ConfirmPassword)
                .Equal(user => user.Password).WithMessage("Passwords do not match.");
        }
    }
}

Step 4: Integrating Fluent Validation with ASP.NET Core

To integrate Fluent Validation with ASP.NET Core, we need to register the validators in the Startup.cs file. However, in .NET Core 8, the Program.cs file is used instead. Update your Program.cs to include Fluent Validation:

using FluentValidation.AspNetCore;
using FluentValidationDemo.Validators;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers()
    .AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining<UserRegistrationValidator>());

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

Step 5: Creating the Controller

Create a UserController to handle user registration. In the Controllers folder, add a new class named UserController.cs:

using FluentValidationDemo.Models;
using Microsoft.AspNetCore.Mvc;

namespace FluentValidationDemo.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class UserController : ControllerBase
    {
        [HttpPost("register")]
        public IActionResult Register(UserRegistration registration)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            // Simulate user registration logic
            return Ok("User registered successfully.");
        }
    }
}

Step 6: Testing the Validation

To Test the API and fluent validation, We can use tools like Postman or Swagger to send a POST request to https://localhost:5001/api/user/register with the following JSON payload:

{
    "firstName": "John",
    "lastName": "Doe",
    "email": "johndoe@example.com",
    "password": "password123",
    "confirmPassword": "password123"
}

If the validation rules are met, you should receive a success response. If not, you will receive detailed error messages specifying which validations failed.

Conclusion

In this blog post, we explored how to use Fluent Validation in .NET Core 8 with a practical example. We discussed the benefits of using Fluent Validation, set up a new .NET Core project, created a model and its validator, integrated Fluent Validation with ASP.NET Core, and tested our validation logic.

Using Fluent Validation in .NET Core 8 not only enhances your application’s data integrity but also improves the maintainability and readability of your code. With the strong typing and expressive syntax that Fluent Validation offers, you can build robust validation rules that are easy to understand and extend.

By following this guide, you should now have a solid foundation for incorporating Fluent Validation into your .NET Core applications. Remember to always validate user input to prevent errors and ensure data quality.

Feel free to share your thoughts and experiences with Fluent Validation in .NET Core 8 in the comments below. Happy coding!

Learn more about Difference Between Monolithic and Microservices Architecture with Example.

Using Fluent Validation in .NET Core 8 with Example