Filtering.Net.Generator 0.1.2

Filtering.Net.Generator

Roslyn incremental source generator + 24-rule analyzer for Filtering.Net. Emits typed IFilterDefinition<T> implementations and a DI extension at compile time. Catches translatable-method mistakes before EF Core sees them.

This package is analyzer-only — it has no runtime DLL. Install it alongside Filtering.Net.

What it solves

Hand-rolling IFilterDefinition<T> per filter shape is repetitive and error-prone — and the moment you reach for runtime expression construction, EF Core's translatability rules become a runtime surprise. This generator turns a declarative [GenerateFilter<T>] partial into a fully-typed predicate set, and the bundled analyzer rejects shapes that would fail at runtime (e.g., a string operator wired to a numeric column, or a custom operator that calls a non-translatable method).

Install

dotnet add package Filtering.Net
dotnet add package Filtering.Net.Generator

Both are required: Filtering.Net ships the runtime types the generator's emitted code references; Filtering.Net.Generator ships the generator + analyzer.

Quickstart

Declare a partial filter class:

public sealed class User
{
    public int    Id        { get; set; }
    public string Name      { get; set; } = "";
    public int    Age       { get; set; }
    public bool   IsActive  { get; set; }
}

[GenerateFilter<User>]
public partial class UserFilter
{
    [Map(nameof(User.Id),       Sortable = true)] private static partial void MapId();
    [Map(nameof(User.Name),     Sortable = true)] private static partial void MapName();
    [Map(nameof(User.Age),      Sortable = true)] private static partial void MapAge();
    [Map(nameof(User.IsActive))]                  private static partial void MapIsActive();
}

The generator emits:

• UserFilter : IFilterDefinition<User> with Validate(...), ApplyFilter(...), ApplySorting(...) already implemented.
• A services.AddFiltering() extension method (when Microsoft.Extensions.DependencyInjection.Abstractions is referenced) that registers every generated filter class as IFilterDefinition<T>.

Wire it up:

builder.Services.AddDbContext<AppDbContext>(o => o.UseNpgsql(connectionString));
builder.Services.AddFiltering();   // <- emitted by the generator

Custom operators

A profile is a static class decorated with [FilterProfile<T>] that defines a set of operators. Built-in profiles cover common types; declare your own to add custom logic:

[FilterProfile<string>]
public static class StringFilterPlus
{
    [BasedOn(typeof(StringFilter))]
    private static void Inherit() { }

    [FilterOperator("startsWithFold")]
    public static Expression<Func<string, string, bool>> StartsWithFold() =>
        (column, value) => EF.Functions.ILike(column, value + "%");
}

Then [Map(nameof(User.Name), Profile = typeof(StringFilterPlus))] and the new operator is available on that property.

Diagnostics

24 rules total: 16 errors (FN0001–FN0016) and 8 warnings (FN1001–FN1008). The full catalogue with one-line summaries lives at the diagnostics catalogue on the docs site.

Every rule's helpLinkUri points back at the catalogue table on the docs site.

Editor / build integration

The generator integrates with Roslyn directly — no MSBuild wiring required beyond installing the NuGet. Diagnostics surface in Visual Studio, Rider, VS Code (via OmniSharp / C# Dev Kit), and dotnet build.

See also

• Documentation site — full guides, API reference, diagnostics catalogue.
• Repo on GitHub — source, issue tracker, contribution notes.
• Filtering.Net — runtime types the emitted code references.
• Filtering.Net.EntityFrameworkCore — async ApplyPagedAsync + PageResult<T>.

License

MIT.