ValidationModules.Runtime 1.2.0

ValidationModules

ValidationModules writes the validators for your .NET types at build time. You declare rules with attributes on a model, or in a rules class. A source generator turns them into a validator class made of ordinary C# checks. The validators read members directly instead of through reflection, so they work in trimmed and Native AOT applications.

Documentation: https://ipjohnson.github.io/ValidationModules/

Install

dotnet add package ValidationModules.Runtime
dotnet add package ValidationModules.SourceGenerator

The runtime targets .NET 8 and .NET 10.

Example

using ValidationModules.Constraints;

public sealed class SignUp
{
    [Required, EmailAddress]
    public string? Email { get; init; }

    [Required, StringLength(40, Min = 3)]
    public string? DisplayName { get; init; }

    [Range(18, 120)]
    public int Age { get; init; }
}

The generator writes a class named SignUpValidator that checks these rules. It also writes one extension method that registers every validator in the project. The method is named after the assembly, so a project named Shop gets AddShopValidators().

using Microsoft.Extensions.DependencyInjection;
using ValidationModules;

var services = new ServiceCollection();
services.AddShopValidators();

using var provider = services.BuildServiceProvider();
var validator = provider.GetRequiredService<IValidatorFor<SignUp>>();

var result = validator.Validate(
    new SignUp
    {
        Email = "not-an-email",
        DisplayName = "",
        Age = 12,
    }
);

foreach (var error in result.Errors)
{
    Console.WriteLine($"{error.Field}: {error.Code}: {error.Message}");
}

email: email: email is not a valid email address.
displayName: required: displayName is required.
age: range: age must be between 18 and 120.

Every error has a Field path, a Code, a Message, and a Severity. The codes are stable, so application logic and translations should key on Code rather than on the message text.

Rules that span members

An attribute sees one member. A rules class can compare several:

using ValidationModules;

public sealed class BookingRules : IValidationRulesFor<Booking>
{
    public static void Describe(ValidationRules<Booking> rules, Booking x)
    {
        rules.Require(x.Guest).Length(1, 80);
        rules.Range(x.Guests, 1, 8);
        rules.Ensure(x.End > x.Start, message: "The stay must end after it starts.");
    }
}

The generator reads Describe at build time and writes its rules into BookingValidator. The method itself is never called.

Compared with DataAnnotations

• Most attributes share their names with System.ComponentModel.DataAnnotations, such as [Required], [StringLength], [Range] and [EmailAddress].
• DataAnnotations finds and runs the attributes with reflection when you validate. Here the checks are compiled into the validator.
• An attribute on the wrong kind of member is a build error. [Range] on a member whose type has no ordering reports VM1003.
• A model that already uses DataAnnotations attributes can be compiled as it is.
• [StringLength(50)] is a maximum here too. DataAnnotations names the minimum MinimumLength, and this library names it Min.

Packages

Documentation

• Getting started
• Constraint attributes
• Rules classes
• ASP.NET Core
• Diagnostics reference

Contributing

AGENTS.md describes how to build and test the repository, and the conventions the code follows.

License

MIT. See LICENSE.txt.