Asp.Net Core Using Fluentvalidation Complete Guide

1. What is FluentValidation and why should you use it in ASP.NET Core?

Answer:
FluentValidation is a lightweight, unobtrusive, and highly extensible library designed for building strongly-typed validation logic in .NET applications, including those built with ASP.NET Core. It allows developers to define complex validation rules in a fluent API manner, making the validation process more maintainable and easier to understand than traditional data annotations.

2. How do you install FluentValidation in an ASP.NET Core project?

Answer:
You can install FluentValidation via NuGet Package Manager. Use one of the following commands:

• Visual Studio: Right-click on your project → Manage NuGet Packages → Search for “FluentValidation.AspNetCore” → Install.
• Powershell Command Line: Install-Package FluentValidation.AspNetCore.
• Dotnet CLI: dotnet add package FluentValidation.AspNetCore.

Once installed, you need to integrate it into your application's startup configuration.

3. How do you set up FluentValidation in your ASP.NET Core application?

Answer:
To set up FluentValidation in an ASP.NET Core app, follow these steps:

1. Create a Validator class by inheriting from AbstractValidator<T>.

   public class PersonValidator : AbstractValidator<Person>
   {
       public PersonValidator()
       {
           RuleFor(p => p.Name).NotEmpty().WithMessage("Name cannot be empty");
           RuleFor(p => p.Email).NotEmpty().EmailAddress();
       }
   }
   

2. Register the validator in the Startup.cs or Program.cs (for .NET 6 and later) file within the ConfigureServices method.

   services.AddFluentValidation(fv =>
   {
       fv.RegisterValidatorsFromAssemblyContaining<PersonValidator>();
   });
   

3. Ensure that model binding uses DataAnnotations and FluentValidation validators. ASP.NET Core uses both by default after integrating FluentValidation.

4. Can you validate nested objects in FluentValidation?

Answer:
Yes, validating nested objects is straightforward in FluentValidation. You can use the SetValidator method to apply another validator to a child object.

public class AddressValidator : AbstractValidator<Address>
{
    public AddressValidator()
    {
        RuleFor(address => address.City).NotEmpty();
        RuleFor(address => address.Postcode).Length(6, 8);
    }
}

public class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor(p => p.Name).NotEmpty();
        RuleFor(p => p.Email).NotEmpty().EmailAddress();
        RuleFor(p => p.Address).SetValidator(new AddressValidator());
    }
}

5. How do you handle custom validation rules in FluentValidation?

Answer:
FluentValidation supports custom validation methods through Custom() or Must(). Here’s an example using CustomAsync() for async operations:

public class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor(person => person.Age)
            .GreaterThan(0)
            .CustomAsync(async (age, context, cancellationToken) =>
            {
                var db = context.GetService<MyDbContext>();
                var isValidAge = await IsValidAge(age);
                if (!isValidAge)
                {
                    context.AddFailure("Invalid age");
                }
            });
    }

    private async Task<bool> IsValidAge(int age)
    {
        // some async operation to check the age
        return await Task.FromResult(age > 18);
    }
}

6. How can you specify different rule sets for different validation scenarios?

Answer:
You can create multiple named rule sets within your validator class and then select which one to use at runtime.

public class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleSet("Create", () =>
        {
            RuleFor(p => p.Name).NotEmpty();
        });

        RuleSet("Update", () =>
        {
            RuleFor(p => p.Email).NotEmpty().EmailAddress();
        });
    }
}

In your controller, specify the rule set:

public IActionResult Save(Person person)
{
    var validationResult = _validator.Validate(person, options =>
    {
        options.IncludeRuleSets("Create");
    });

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

        return BadRequest(ModelState);
    }

    // save logic here
    return Ok();
}

7. How do you display validation errors in a Razor page or View?

Answer:
ASP automatically binds validation errors to the model, making them available in Razor views.

@using FluentValidation.AspNetCore

<form method="post">
    <input type="text" asp-for="Person.Name" />
    <span asp-validation-for="Person.Name"></span>

    <button type="submit">Submit</button>
</form>

@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

In your action method, FluentValidation's results are added to ModelState which you should check before proceeding.

[HttpPost]
public IActionResult AddPerson(Person person)
{
    var validationResult = _personValidator.Validate(person);

    if (!validationResult.IsValid)
    {
        validationResult.AddToModelState(ModelState);
        
        return View(modelState: ModelState);
    }

    // add to database etc.
    return RedirectToAction(nameof(Index));
}

8. What is the difference between Data Annotations and FluentValidation?

Answer:

• Data Annotations: These are attributes added directly to the model classes. They are easy to use but can clutter the model with validation logic and make it harder to maintain, especially for complex validation rules.

• FluentValidation: Separates validation rules entirely from your model classes into dedicated validator classes. This enhances modularity, readability, and maintainability, allowing complex validation logic to be constructed through a fluent API.

9. How do you perform validation manually in FluentValidation outside of ASP.NET Core’s MVC system?

Answer:
You can instantiate and use validators manually anywhere within your application, not just in MVC controllers.

public class PersonService
{
    private readonly IValidator<Person> _validator;

    public PersonService(IValidator<Person> validator)
    {
        _validator = validator;
    }

    public async Task<string> CreatePersonAsync(Person person)
    {
        var validationResult = await _validator.ValidateAsync(person);

        if (!validationResult.IsValid)
        {
            // Handle invalid state
            return string.Join(", ", validationResult.Errors.Select(e => e.ErrorMessage));
        }

        // Proceed with creating person
        return "Person Created successfully!";
    }
}

10. How do you extend FluentValidation to include global validation behaviors like logging all validation failures?

Answer:
You can extend FluentValidation by implementing a custom IValidatorInterceptor. This interceptor can add pre- or post-validation behaviors, such as logging.

public class LoggingValidatorInterceptor : IValidatorInterceptor
{
    private readonly ILogger<LoggingValidatorInterceptor> _logger;

    public LoggingValidatorInterceptor(ILogger<LoggingValidatorInterceptor> logger)
    {
        _logger = logger;
    }

    public IValidationContext BeforeValidation(IValidationContext context)
    {
        // Log before validation
        _logger.LogInformation($"Validating {context.InstanceToValidate}");

        return context;
    }

    public ValidationResult AfterValidation(IValidationContext context, ValidationResult result)
    {
        // Log all validation errors
        if (!result.IsValid)
        {
            var errors = result.Errors.Select(e => $"{e.PropertyName}: {e.ErrorMessage}");
            _logger.LogWarning($"Validation failed for {string.Join("; ", errors)}");
        }

        return result;
    }
}

Register the interceptor in Startup.cs or Program.cs: