👁 Image
ZeroAlloc.Inject.Generator 1.7.1

ZeroAlloc.Inject

👁 NuGet
👁 Build
👁 AOT
👁 GitHub Sponsors

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.

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 pure scoped lifecycle. 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. The IEnumerable row above shows the all-Transient registration path; all-Singleton IEnumerable<T> resolutions are now cached (0 B on subsequent calls — verified by tests).

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–ZAI018 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