ZeroAlloc.Specification 1.3.1

ZeroAlloc.Specification

Source-generated, zero-allocation specification pattern for .NET 8+.

Install

The source generator is bundled into the main package — a single PackageReference is all you need:

dotnet add package ZeroAlloc.Specification

The standalone ZeroAlloc.Specification.Generator package is still published for backwards compatibility with existing direct PackageReferences, but new consumers should reference only ZeroAlloc.Specification.

Example

using System.Linq.Expressions;
using ZeroAlloc.Specification;

[Specification]
public readonly partial struct ActiveUserSpec : ISpecification<User>
{
    public bool IsSatisfiedBy(User user) => user.IsActive;
    public Expression<Func<User, bool>> ToExpression() => u => u.IsActive;
}

[Specification]
public readonly partial struct PremiumUserSpec : ISpecification<User>
{
    private readonly decimal _minSpend;
    public PremiumUserSpec(decimal minSpend) => _minSpend = minSpend;

    public bool IsSatisfiedBy(User user) => user.TotalSpend >= _minSpend;
    public Expression<Func<User, bool>> ToExpression()
    {
        var min = _minSpend;
        return u => u.TotalSpend >= min;
    }
}

// Fluent composition — zero allocation
var spec = new ActiveUserSpec().And(new PremiumUserSpec(1000m));

// In-memory
bool result = spec.IsSatisfiedBy(user);

// EF Core — translates to SQL
var users = await dbContext.Users.Where(spec.ToExpression()).ToListAsync();

Performance

Head-to-head vs Ardalis.Specification 9.3.1 (the de-facto specification library in .NET). .NET 10.0.13, Intel Core Ultra 7 255H, BenchmarkDotNet v0.15.8.

Rows under 1 ns are below what BenchmarkDotNet can tell apart from an empty method: the JIT reduces building two empty structs to nothing, so those speedups are lower bounds. The machine was shared while measuring, so timings are approximate; the allocations are exact.

The in-memory-evaluation gap is dramatic because Ardalis pays Expression.Compile() per call. For EF Core / database queries the SQL provider dominates and the overhead is invisible; for in-memory filtering it dominates.

Full methodology + analysis: docs/performance.md.

Features

• Zero allocations — composed specs are readonly struct values, not heap objects
• EF Core compatible — every spec exposes ToExpression() returning Expression<Func<T, bool>>
• Source-generated fluent API — And<TOther>(), Or<TOther>(), Not() added by Roslyn generator
• Static builder — Spec.And(), Spec.Or(), Spec.Not() for explicit type arguments
• Compile-time safety — ZA001–ZA005 diagnostics enforce correct partial struct usage
• .NET 8+, C# 12

Documentation

License

MIT — see LICENSE.