FastValidate 1.1.0

FastValidate

Zero-reflection validation for .NET, powered by a Roslyn source generator.

Decorate your properties with validation attributes and FastValidate generates a compile-time Validate() extension method for you — no reflection, no runtime attribute scanning. That makes it safe for Native AOT and trimmed apps, where reflection-based validators typically break or need extra trimmer annotations.

Why

Most attribute-based validators (including reflection-driven ones) walk a type's properties at runtime with GetProperties() / GetCustomAttributes(). That's slow, allocates, and is exactly the kind of code Native AOT trimming can strip or fail to resolve. FastValidate moves that work to compile time: the generator reads your attributes once, at build, and emits plain, boring, fast C# that calls straight into the validation logic. Nothing to reflect over at runtime.

Measured against a reflection-based equivalent (FastValidate.Benchmarks, BenchmarkDotNet, Apple M3 Pro / .NET 10, 4 validated properties):

~3.5x faster, ~5x less memory allocated. Run it yourself: dotnet run -c Release --project FastValidate.Benchmarks.

Installation

dotnet add package FastValidate

That's it — one package. It contains both the attributes/validator library and the source generator.

Usage

using FastValidate;

public class SignupRequest
{
    [EmailValidation]
    public string Email { get; set; } = string.Empty;

    [PhoneNumberValidation(Region.Spain)]
    public string Phone { get; set; } = string.Empty;

    [PasswordValidation(MinLength = 10, RequireSpecialChar = true)]
    public string Password { get; set; } = string.Empty;

    [LengthValidation(2, 50)]
    public string DisplayName { get; set; } = string.Empty;
}

No base class, no partial keyword, no marker attribute on the class itself — just decorate the properties you want validated. At build time, FastValidate generates a Validate() extension method for SignupRequest:

var request = new SignupRequest { Email = "not-an-email", Phone = "612345678", Password = "weak", DisplayName = "A" };

List<ValidationResult> errors = request.Validate();
// errors: one entry per failing property (PropertyName + ErrorMessage),
// empty when everything is valid. Every property is checked — it doesn't
// stop at the first failure.

foreach (var error in errors)
    Console.WriteLine($"{error.PropertyName}: {error.ErrorMessage}");

You can inspect the generated code yourself: enable <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles> in your .csproj and look under obj/generated.

Attributes

Applying an attribute to an incompatible property type (e.g. [EmailValidation] on an int) is a compile error (FV001), not a silent no-op or a runtime surprise. [EqualsValidation] referencing a property that doesn't exist, or one with a different type, is likewise a compile error (FV002).

Custom rules

Prefer [RegexValidation] when the pattern is a compile-time constant — it needs no setup:

public class Product
{
    [RegexValidation(@"^[A-Z]{3}-\d{4}$")]
    public string Code { get; set; } = string.Empty;
}

Use [CustomValidation] when the pattern needs to be registered at startup (e.g. loaded from configuration):

Validator.AddCustomValidation("product-code", @"^[A-Z]{3}-\d{4}$");

public class Product
{
    [CustomValidation("product-code")]
    public string Code { get; set; } = string.Empty;
}

Cross-property and nested validation

public class AccountCreation
{
    [PasswordValidation]
    public string Password { get; set; } = string.Empty;

    [EqualsValidation(nameof(Password))]
    public string ConfirmPassword { get; set; } = string.Empty;
}

public class AddressInfo
{
    [PostalCodeValidation(Region.Spain)]
    public string PostalCode { get; set; } = string.Empty;
}

public class CustomerProfile
{
    [EmailValidation]
    public string Email { get; set; } = string.Empty;

    [ValidateObject]
    public AddressInfo Address { get; set; } = new();

    [ValidateCollection]
    public List<AddressInfo> ShippingAddresses { get; set; } = new();
}

// customerProfile.Validate() reports errors as "Address.PostalCode",
// "ShippingAddresses[1].PostalCode", etc. — one Validate() call, full graph.

Calling validators directly

Every attribute is backed by a plain static method on Validator, callable without any generated code:

ValidationResult result = Validator.IsValidEmail("user@example.com");
if (!result.IsValid)
    Console.WriteLine(result.ErrorMessage);

Requirements

• Any SDK-style .NET project (the generator targets netstandard2.0, so it works from .NET Framework 4.6.1+ through the latest .NET)

Development

git clone https://github.com/AdrianBailador/FastValidate.git
cd FastValidate
dotnet test

License

MIT — see LICENSE.