ZeroAlloc.Inject.Generator 1.11.3

ZeroAlloc.Inject

Compile-time DI registration for .NET. A Roslyn source generator that auto-discovers services via attributes and generates IServiceCollection extension methods and a Native AOT-compatible IServiceProvider. No reflection, no runtime scanning — misconfigured dependencies surface as build errors before the application ever starts.

Install

For ASP.NET Core and Generic Host projects (MS DI runtime):

dotnet add package ZeroAlloc.Inject
dotnet add package ZeroAlloc.Inject.Generator

For standalone or hybrid container mode (no separate attribute package needed):

dotnet add package ZeroAlloc.Inject.Container

ZeroAlloc.Inject.Container bundles the generator, attributes, and the container base classes in a single package.

30-Second Example

// 1. Annotate your service with a lifetime attribute
using ZeroAlloc.Inject;

[Transient]                                    // registered as IOrderService + OrderService
public class OrderService : IOrderService
{
    private readonly IProductRepository _repo;

    public OrderService(IProductRepository repo) => _repo = repo;

    public Order PlaceOrder(int productId) => /* ... */
}

// 2. Register all attributed services in one generated call
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMyAppServices();           // generated at compile time from assembly name

// 3. Resolve the service — or let the framework inject it for you
var app = builder.Build();
var service = app.Services.GetRequiredService<IOrderService>();

The generator derives the method name from the assembly name: MyApp → AddMyAppServices(), MyApp.Domain → AddMyAppDomainServices(). Override with [assembly: ZeroAllocInject("AddDomainServices")].

Performance

.NET 10 host / .NET 9.0.15 runtime, BenchmarkDotNet v0.15.8, Intel Core i9-12900HK. Compared against MS DI (reflection) and Jab (the other source-gen DI library).

¹ Jab is constructor-only. ² Jab decorator wired via factory. ³ Jab 0.10.x requires closed types. The ZA Container now resolves open generics from its own type switch instead of delegating to MS DI, and its benchmark has not been run yet. ⁴ One resolve per fresh scope, so it measures the first, creating resolve; the scope is created outside the measurement. The 120 B is the benchmark's ScopedService itself, a 24 B object plus its 96 B Guid string: ZA and Jab add nothing to it, MS DI adds 184 B. ⁵ The steady state: a service already resolved in a scope created in setup. Every container returns its cached instance without allocating.

ZA wins where the generator's domain knowledge matters: property injection (2× MS DI), decorators (2.1× MS DI), open generics (1.8× MS DI). Jab wins on scope creation and cached scoped resolves; ZA Standalone is fastest on the first resolve in a new scope. MS DI wins on IEnumerable<T> (its cached multi-registration enumeration is excellent).

In v1.6 the ZA Container scope creation dropped 50% on allocation (216 B → 96 B) and 2× faster — the MS DI fallback scope is no longer eagerly created; it materializes on first fallback resolution. For ZA-owned registrations (the common case), it never materializes at all, and when every registration is ZA-owned, creating a scope does not build the MS DI fallback provider either. The IEnumerable row above shows the all-Transient registration path; all-Singleton IEnumerable<T> resolutions are now cached: repeat resolutions allocate 0 B in both modes, asserted with AllocationGate in ResolutionAllocationTests.

Full methodology, all scenarios, and analysis: docs/performance.md.

Features

• Compile-time registration — [Transient], [Scoped], [Singleton] attributes; the generator emits all IServiceCollection.Add* calls
• Zero reflection — generated code uses direct new ClassName(...) constructor calls and typeof(T) type switches
• Native AOT compatible — standalone container is 100% AOT-safe including open generics
• Three container modes — MS DI extension method, Hybrid (wraps MS DI), and Standalone (no runtime MS DI dependency)
• Decorators — [Decorator] / [DecoratorOf] with ordering, conditional application (WhenRegistered), and optional dependencies
• Keyed services — Key = "redis" on any lifetime attribute (.NET 8+)
• Open generics — single attribute covers all closed forms; standalone mode enumerates closed usages at compile time
• Compile-time diagnostics — ZAI001–ZAI021 reported as build errors/warnings, including circular dependency detection
• TryAdd by default — prevents duplicate registrations; opt in to AllowMultiple = true for IHostedService scenarios
• Multi-assembly — each assembly generates its own extension method; call them in sequence at the composition root

Documentation

How It Compares to Scrutor

Requirements

• .NET 8.0, .NET 9.0, or .NET 10.0
• C# 12+

License

MIT