Deni Dev

FluentValidation in .NET 8: Enhancing Data Validation with Ease

Deni Leocadio's photo
Deni Leocadio
·

3 min read

FluentValidation in .NET 8: Enhancing Data Validation with Ease

Photo by CDC on Unsplash

Intro

Data validation is a critical aspect of application development, ensuring that the input data meets certain criteria before processing it. In the .NET ecosystem, FluentValidation is a popular library that provides a fluent interface for building strongly-typed validation rules. With the release of .NET 8, FluentValidation continues to offer robust features and improvements that streamline the validation process.

Overview of FluentValidation

FluentValidation is an open-source library for .NET that allows developers to create complex validation logic for their models in a clear and concise manner. It promotes the separation of validation logic from the business logic, making the code more readable and maintainable.

Key Features of FluentValidation

  1. Fluent Interface: FluentValidation uses a fluent interface, which allows for the chaining of method calls to define validation rules in a readable and expressive manner.

  2. Strongly-Typed Validation: The library leverages generics to provide compile-time type checking, reducing runtime errors.

  3. Integration with ASP.NET Core: FluentValidation integrates seamlessly with ASP.NET Core, allowing for easy validation of request models in web applications.

  4. Custom Validators: Developers can create custom validation logic by extending the base validator class, providing flexibility to handle unique validation scenarios.

  5. Localization: The library supports localization, making it easy to provide validation messages in different languages.

  6. Conditional Validation: FluentValidation supports conditional validation, enabling developers to apply rules based on the state of the model.

Getting Started with FluentValidation in .NET 8

Installation

To start using FluentValidation in a .NET 8 project, you need to install the FluentValidation NuGet package. You can do this via the NuGet Package Manager or by running the following command in the .NET CLI:

dotnet add package FluentValidation

Creating a Validator

Suppose you have a simple User model and you want to validate that the Name is not empty and the Age is between 18 and 60. Here's how you can define a validator for this model:

using FluentValidation;

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Name)
            .NotEmpty().WithMessage("Name is required.");

        RuleFor(user => user.Age)
            .InclusiveBetween(18, 60).WithMessage("Age must be between 18 and 60.");
    }
}

Integrating with ASP.NET Core

To integrate FluentValidation with an ASP.NET Core application, you need to add FluentValidation's ASP.NET Core integration package:

dotnet add package FluentValidation.AspNetCore

In the Startup.cs or Program.cs file, configure FluentValidation in the ConfigureServices method:

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

With this configuration, FluentValidation will automatically validate the incoming models in your controllers.

Advanced Features in FluentValidation

Custom Validators

If the built-in validation rules are not sufficient, you can create custom validators. For example, to create a custom validator that checks if a user's name contains only alphabetic characters:

public class AlphabeticValidator<T> : PropertyValidator<T, string>
{
    public override bool IsValid(ValidationContext<T> context, string value)
    {
        return value.All(char.IsLetter);
    }

    public override string Name => "AlphabeticValidator";

    protected override string GetDefaultMessageTemplate(string errorCode) => "The {PropertyName} must contain only alphabetic characters.";
}

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Name).SetValidator(new AlphabeticValidator<User>());
    }
}

Conditional Validation

FluentValidation allows for rules to be applied conditionally. For instance, to validate a secondary email only if it is provided:

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(user => user.Name).NotEmpty();

        RuleFor(user => user.SecondaryEmail)
            .EmailAddress()
            .When(user => !string.IsNullOrEmpty(user.SecondaryEmail));
    }
}

Conclusion

FluentValidation in .NET 8 continues to be an invaluable tool for developers seeking to implement robust and maintainable validation logic. Its fluent interface, strong typing, and seamless integration with ASP.NET Core make it an essential library for any .NET developer. By leveraging FluentValidation, you can ensure that your application data is validated effectively, leading to more reliable and secure applications.

.NETValidationdotnetcoreC#