FlatValidator 2.2.0

The FlatValidator is a validation library for .NET that delivers an high performance and memory prudence by using lambda-based and strongly-typed rules.

Quick examples

In general, there are two simple ways to validate custom data with the FlatValidator.

1. Inline mode

You can define validation rules in your code to validate object locally.

var model = new Model(Email: "email", BirthDate: DateTime.Now, Rate: -100);

// validate with _synchronous_ version here
var result = FlatValidator.Validate(model, v =>
{
    // IsEmail() is one of funcs for typical data formats like Phone, Url, CreditCard, etc.
    v.ValidIf(m => m.Email.IsEmail(), 
              m => $"Invalid email: {m.Email}", 
              m => m.Email);

    v.ErrorIf(m => m.Rate < 0, "Negative Rate", m => m.Rate);

    v.WarningIf(m => m.BirthDate.AddYears(10) >= DateTime.Now, 
                "Age looks like incorrect", m => m.BirthDate);
});
if (!result) 
{
    // ToDictionary() => Dictionary<PropertyName, ErrorMessage[]>
    return TypedResults.ValidationProblem(result.ToDictionary()) 
}

// or validate with _asynchronous_ version
var result = await FlatValidator.ValidateAsync(model, v => 
{
    v.ErrorIf(async m => await userService.IsUserExistAsync(m.Email),
              "User already registered", m => m.Email);

    // the same without `async/await`
    v.ErrorIf(m => userService.IsUserExistAsync(m.Email),
              m => $"Email {m.Email} already registered", 
              m => m.Email);
});

// possibility to inspect occured validation failures
bool success = result.IsValid;
var errors = result.Errors;
var warnings = result.Warnings;

2. Inheritance of the FlatValidator class

Another way is to inherit the FlatValidator to define custom rules in the constructor. Also you can pass dependencies into constructor to get additional functionality inside of the validation rules.

public record UserModel(string Forename, string Surname, ....);

public class UserValidator: FlatValidator<UserModel> 
{
    public UserValidator(ILogger logger, IPostalService postalService) 
    {
        logger.LogInfo("Validating...");

        ErrorIf(m => m.Forename.IsEmpty(), "Forename can not be empty.", m => m.Forename);
        ErrorIf(m => m.Surname.IsEmpty(), "Surname can not be empty.", m => m.Surname);
        
        // you can define one or more groups of preconditions
        If(m => m.ShipmentAddress.NotEmpty(), @then: m =>
        {
            ValidIf(async m => await postalService.AddressExistsAsync(m.Address),
                     "Postal address not found.", m => m.Address);

            WarningIf(m => !m.Phone.IsPhone(), "No contact phone.");
        },
        @else: m => // optionally
        {
            ValidIf(m => m.Phone.IsPhone(), "invalid phone number.", m => m.Phone);
        });
    }
}

Now lets validate some object with it

// create instance of the custom validator
var validator = new UserValidator();

// validate _asynchronously_ and get a result
var result = await validator.ValidateAsync(customer, cancellationToken);

// OR validate _synchronously_ and get a result
var result = validator.Validate(new UserModel(...)); 

if (!result) // is there any errors?
{
    return result.ToDictionary(); // Dictionary<PropertyName, ErrorMessage[]>
}

TIP - The package FlatValidator.DependencyInjection helps you to register all inherited validators in the ServiceCollection automatically.

Release Notes and Change Log

Release notes can be found on GitHub.

Supporting the project

The FlatValidator is developed and supported by @belset for free in spare time, so that financial help keeps the projects to be going successfully.

You can sponsor the project via Buy me a coffee.