RValidator 1.0.0

RValidator

Fluent validation library for .NET inspired by FluentValidation. Define strongly-typed validation rules using a fluent, readable, and maintainable API.

Features

• Fluent API with RuleFor and RuleForEach
• Built-in validators (NotEmpty, EmailAddress, Length, GreaterThan, etc.)
• Conditional validation with When and Unless
• Cascade mode (Continue / Stop)
• Child validators with SetValidator
• Async validation with MustAsync
• Custom messages and error codes
• Partial property validation
• Dependency injection integration
• Full XML documentation

Requirements

• .NET 8.0 or later

Installation

Add a project reference:

dotnet add reference src/RValidator/RValidator.csproj

Or, after NuGet publication:

dotnet add package RValidator

Quick start

1. Define the model

public class Customer
{
    public string? Name { get; set; }
    public string? Email { get; set; }
    public int Age { get; set; }
}

2. Create the validator

using RValidator;

public class CustomerValidator : AbstractValidator<Customer>
{
    public CustomerValidator()
    {
        RuleFor(x => x.Name)
            .NotEmpty()
            .MinimumLength(2)
            .MaximumLength(100);

        RuleFor(x => x.Email)
            .NotEmpty()
            .EmailAddress()
            .WithMessage("Please provide a valid email address.");

        RuleFor(x => x.Age)
            .InclusiveBetween(18, 120);
    }
}

3. Run validation

var customer = new Customer { Name = "John", Email = "john@example.com", Age = 30 };
var validator = new CustomerValidator();
var result = validator.Validate(customer);

if (!result.IsValid)
{
    foreach (var error in result.Errors)
    {
        Console.WriteLine($"{error.PropertyName}: {error.ErrorMessage}");
    }
}

Validation with exceptions

validator.ValidateAndThrow(customer);

// or async
await validator.ValidateAndThrowAsync(customer);

Throws ValidationException containing the full ValidationResult.

Async validation

RuleFor(x => x.Email)
    .MustAsync(async (email, cancellation) =>
    {
        await Task.Delay(100, cancellation);
        return !await EmailExistsInDatabase(email);
    })
    .WithMessage("Email is already registered.");

Conditional validation

RuleFor(x => x.Discount)
    .NotEqual(0m)
    .When(x => x.HasDiscount);

RuleFor(x => x.MiddleName)
    .NotEmpty()
    .Unless(x => x.UseSingleName);

Child validators

public class CustomerValidator : AbstractValidator<Customer>
{
    public CustomerValidator()
    {
        RuleFor(x => x.Address)
            .SetValidator(new AddressValidator());
    }
}

Collection validation

RuleForEach(x => x.Orders)
    .SetValidator(new OrderLineValidator());

RuleFor(x => x.Orders)
    .NotEmpty();

Cascade mode

RuleFor(x => x.FirstName)
    .Cascade(CascadeMode.Stop)
    .NotEmpty()
    .MinimumLength(2);

With Stop, execution stops after the first failure in the chain.

Dependency injection

using RValidator.DependencyInjection;

builder.Services.AddValidatorsFromAssemblyContaining<CustomerValidator>();

// Resolution
var validator = serviceProvider.GetRequiredService<IValidator<Customer>>();

Built-in validators

Project structure

rvalidator/
├── src/RValidator/
│   ├── Abstractions/          # Public contracts (IValidator, IRuleBuilder)
│   ├── Enums/                 # CascadeMode, Severity
│   ├── Extensions/            # Built-in validator extensions
│   ├── DependencyInjection/   # DI registration helpers
│   └── Internal/              # Internal implementation
├── tests/RValidator.Tests/  # Unit tests (xUnit)
├── docs/                      # Detailed documentation
└── RValidator.slnx          # Solution

Run tests

dotnet test

Additional documentation

• Getting started
• Built-in validators
• Advanced features

License

See LICENSE.