NuGet Package Information

Package	Downloads	License

Repository

You can find the source code and contribute on GitHub

FlowValidate

FlowValidate is a lightweight, fluent-style validation library for .NET.
It provides an intuitive API for validating models, making it easy to add and enforce rules while reducing boilerplate code.

Features

• Property Validation: Validate standard properties, nested objects, and collections.
• Nested & Collection Support: Automatically validates complex types and lists.
• Custom Rules: Use Should, Must, IsNotEmpty, IsEqual or define your own logic.
• Multi-error per Rule: Single property rules can produce multiple error messages.
• Reusable & Property-specific Validators: Create modular validators like UserNameValidator and apply them to properties.
• Async / Task-based Validation: Rules can run asynchronously,
• DI Support: Easy integration with dependency injection.
• Clear Error Messages: Provides detailed validation feedback.
• Detailed Error Messages: Provides rich validation feedback with property name, attempted value, and optional error code.
• Lightweight & Fast: Optimized for high performance.
• Middleware Ready: Can validate models automatically on each request.

Installation

You can install FlowValidate via NuGet Package Manager

dotnet add package FlowValidate

Injection

var builder = WebApplication.CreateBuilder(args);

builder.Services.FlowValidationService(AssemblyReference.Assembly); 

var app = builder.Build();

app.FlowValidationApp();

app.Run();

For example, we create a uservalidator

Reusable Registry Rule

public class UserNameValidator : BaseValidator<string>
{
    public UserNameValidator()
    {
        RuleFor(name => name).IsNotEmpty().WithMessage("Name cannot be empty.")
                             .Length(3, 100).WithMessage("Name must be at least 3 characters.");

    }
}

Nested Validator

public class UserDetailsValidator : BaseValidator<UserDetails>
{
    public UserDetailsValidator()
    {
        RuleFor(x => x.Email).IsEmail().WithMessage("Email is invalid.");
        RuleFor(x => x.Phone).MatchesRegex(@"^\d{10}$").WithMessage("Phone must be 10 digits.");
    }
}

Collection Validator

public class UserBasketValidator : BaseValidator<UserBasket>
{
    public UserBasketValidator()
    {
        RuleFor(x => x.Name).IsNotEmpty();
        RuleFor(x => x.Count).IsGreaterThan(0);
    }
}

Main User Validator

public class UserValidator : BaseValidator<User>
{
    public UserValidator()
    {
        // Registry rule
        ValidateRegistryRules(u => u.Name, new UserNameValidator());

        // Nested validator
        ValidateNested(u => u.Details, new UserDetailsValidator());

        // Collection validator
        ValidateCollection(u => u.Baskets, new UserBasketValidator(), item => item);

        // Custom validation with Should
        RuleFor(u => u.Nickname)
            .Should((nickname, addError) =>
            {
                if (!string.IsNullOrEmpty(nickname))
                {
                    if (nickname.Length < 3)
                        addError("Nickname must be at least 3 characters long.");
                    if (nickname.Contains(" "))
                        addError("Nickname cannot contain spaces.");
                }
            });
    }
}

Using the Validator

var user = new User
{
    Name = "Jo",
    Age = 25,
    Details = new UserDetails { Email = "invalid-email", Phone = "12345" },
    Baskets = new List<UserBasket>
    {
        new UserBasket { Name = "", Count = 0 },
        new UserBasket { Name = "Apple", Count = 3 }
    }
};

var validator = new UserValidator();
var result = validator.Validate(user);

For more examples and unit tests, check the FlowValidate.Test project in the repository.

• API Examples
• Console Examples