FluentValidation is a popular library in .NET for validating objects. It allows you to define rules for your models in a clean, readable way. If you're looking for a simplified overview, here's a basic guide to get you started.

Why Use FluentValidation?

FluentValidation provides several advantages:

• Fluent API: It allows for a more readable and maintainable code structure.
• Separation of Concerns: Validation logic is separated from the business logic.
• Rich Validation Capabilities: It supports advanced features like conditional validation, custom rules, and rule sets.

Getting Started

1. Install Fluentvalidation Library

First, you need to add the FluentValidation package to your project. You can do this via NuGet Package Manager:

dotnet add package FluentValidation

Or, using the NuGet Package Manager Console:

Install-Package FluentValidation

Configuring FluentValidation in .NET Projects

For ASP.NET Core projects, you need to register FluentValidation with the dependency injection container. In your Startup.cs file, add the following configuration:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews()
            .AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining<Startup>());
}

Basic Concepts of FluentValidation

Validators and Validation Rules

A validator in FluentValidation is a class that derives from AbstractValidator<T>, where T is the type of object being validated. Here’s a basic example of a validator for a User model:

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Username).NotEmpty().WithMessage("Username is required.");
        RuleFor(user => user.Email).EmailAddress().WithMessage("Invalid email address.");
    }
}

Creating a Simple Validator

To create a simple validator:

• Define a class that extends AbstractValidator<T>.
• Use the RuleFor method to specify validation rules.

This setup helps keep validation logic organized and separate from your model classes.

Advanced Validation Techniques

Conditional Validation

FluentValidation allows for conditional validation based on certain criteria. For instance, if you only want to validate a field when another field has a specific value, you can use the When method:

RuleFor(user => user.Password)
    .NotEmpty().WithMessage("Password is required.")
    .When(user => user.RequirePassword);

Custom Validators

For more complex scenarios, you might need custom validation logic. You can create custom validators by implementing the IValidator<T> interface:

public class CustomPasswordValidator : PropertyValidator
{
    public CustomPasswordValidator() : base("Invalid password.")
    {
    }

    protected override bool IsValid(PropertyValidatorContext context)
    {
        var password = context.PropertyValue as string;
        return !string.IsNullOrEmpty(password) && password.Length > 6;
    }
}

Sample Test With API 🕶️

// Controllers/UserController.cs
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class UserController : ControllerBase
{
    [HttpPost]
    public IActionResult CreateUser([FromBody] User user)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        
        // Handle user creation logic
        return Ok("User created successfully.");
    }
}

Test the API with CURL.

curl -X POST "https://localhost:5001/api/user" -H "Content-Type: application/json" -d '{"username": "", "email": "invalid-email"}'

Expected Response

{
    "errors": {
        "username": ["Username is required."],
        "email": ["Invalid email address."],
    }
}

Best Practices for Using FluentValidation

Organizing Validators

Keep validators in separate files or folders to maintain a clean project structure. This organization helps in managing and scaling validation rules effectively.

Handling Validation Errors

Handle validation errors gracefully in your application. Ensure that users receive clear and actionable error messages. In ASP.NET Core, you can access validation errors through the ModelState property.

Performance Considerations 🚀

While FluentValidation is efficient, ensure that your validation logic is optimized. Avoid unnecessary validations and be mindful of performance when dealing with large data sets.

Conclusion

FluentValidation offers a powerful and flexible approach to validation in .NET applications. By using its fluent API, you can write cleaner and more maintainable validation logic. Whether you’re building web forms, APIs, or desktop applications, FluentValidation can enhance your validation strategy and ensure your data is always accurate and reliable.