Pico.DI 2026.1.10

🚀 Pico.DI

Zero-reflection, AOT-native dependency injection for .NET — because your IoC container shouldn't be the bottleneck.

┌─────────────────────────────────────────────────────────────┐
│  Pico.DI: Compile-time DI that doesn't suck                │
│  ✓ Zero reflection at runtime                              │
│  ✓ Native AOT compatible                                   │
│  ✓ Up to 5x faster than Microsoft.DI                       │
│  ✓ Zero GC allocations on hot paths                        │
└─────────────────────────────────────────────────────────────┘

🎯 Why Pico.DI?

The Problem with Traditional DI

// Microsoft.DI at runtime:
// 1. Reflection to find constructors
// 2. Expression tree compilation
// 3. Dynamic delegate generation
// 4. Runtime type checking
// Result: ~700ns per transient resolution 😴

The Pico.DI Solution

// Pico.DI at compile-time:
// Source Generator scans your code → Generates static factories
// Result: ~16-45ns per resolution 🚀 (that's 3-5x faster)

⚡ Quick Start

Installation

dotnet add package Pico.DI

📦 Just install Pico.DI — it pulls in the source generator and abstractions automatically.

Package Architecture

Pico.DI ships as three NuGet packages with a clean dependency chain:

Pico.DI  →  Pico.DI.Gen  →  Pico.DI.Abs
(runtime)   (source gen)    (interfaces)

Basic Usage

using Pico.DI;
using Pico.DI.Abs;

// Define your services
public interface IGreeter { string Greet(string name); }
public class Greeter : IGreeter 
{
    public string Greet(string name) => $"Hello, {name}!";
}

// Register services - Source Generator does the heavy lifting
var container = new SvcContainer();
container.RegisterSingleton<IGreeter, Greeter>();
container.Build();

// Resolve
using var scope = container.CreateScope();
var greeter = scope.GetService<IGreeter>();
Console.WriteLine(greeter.Greet("World")); // Hello, World!

Registration Methods

var container = new SvcContainer();

// Lifetime options
container.RegisterTransient<IService, ServiceImpl>();     // New instance every time
container.RegisterScoped<IService, ServiceImpl>();        // One per scope
container.RegisterSingleton<IService, ServiceImpl>();     // One for app lifetime

// Factory registration (explicit control)
container.RegisterSingleton<IService>(sp => new ServiceImpl(
    sp.GetService<IDependency>()
));

// Instance registration
container.RegisterSingle<IConfig>(new AppConfig());

// Open generics
container.RegisterTransient(typeof(IRepository<>), typeof(Repository<>));

// Batch registration
container.RegisterRange(descriptors);

container.Build(); // Freeze & optimize

Dependency Injection

public class OrderService(
    IOrderRepository repo,      // ← Injected
    ILogger logger,             // ← Injected
    IPaymentGateway gateway)    // ← Injected
{
    public void ProcessOrder(Order order) { /* ... */ }
}

// Source Generator automatically detects constructor parameters
// and generates: sp => new OrderService(
//     sp.GetService<IOrderRepository>(),
//     sp.GetService<ILogger>(),
//     sp.GetService<IPaymentGateway>())

📊 Benchmarks

Environment: .NET 10.0 | Windows | x64 | Native AOT | 100 samples × 10,000 iterations

Overall Summary

╔═══════════════════════════════════════════════════════════════════════════════════════════════════════════════╗
║  Pico.DI wins:  18 / 18 scenarios                                                                             ║
║  Average speedup: 3.04x faster                                                                                ║
║  GC allocations: ZERO                                                                                         ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════════════════════╝

By Service Complexity

NoDependency (Simple service)

SingleDependency (Service with 1 dependency)

MultipleDependencies (Service with 2+ dependencies)

DeepChain (5-level dependency chain)

Summary by Lifetime

Summary by Service Complexity

💡 Why so fast? Pico.DI generates inlined factory chains at compile-time. No reflection, no expression trees, no runtime codegen. Just pure, static method calls with [MethodImpl(AggressiveInlining)].

🧠 How It Works

Compile-Time Magic

Your Code                    Source Generator Output
─────────────────────────    ─────────────────────────────────────
container.RegisterSingleton  [ModuleInitializer]
  <IFoo, Foo>();             static void AutoRegister() {
                               SvcContainerAutoConfiguration
container.RegisterScoped       .RegisterConfigurator(Configure);
  <IBar, Bar>();             }
                             
scope.GetService<IFoo>();    static void Configure(ISvcContainer c) {
                               c.Register(new SvcDescriptor(
                                 typeof(IFoo),
                                 static sp => new Foo(),  // ← Compiled!
                                 SvcLifetime.Singleton));
                               c.Register(new SvcDescriptor(
                                 typeof(IBar),
                                 static sp => new Bar(),
                                 SvcLifetime.Scoped));
                             }

Resolution Flow

GetService<IFoo>()
       │
       ▼
┌──────────────────────┐
│ FrozenDictionary     │  O(1) lookup
│ TryGetValue(typeof)  │
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│ SvcDescriptor        │
│ ├─ Factory: sp=>...  │  Pre-compiled static lambda
│ ├─ Lifetime: ...     │
│ └─ SingleInstance    │  For singletons
└──────────┬───────────┘
           │
           ▼
    Return instance

🔧 Advanced Usage

Open Generics

// Registration
container.RegisterTransient(typeof(IRepository<>), typeof(Repository<>));

// Usage - Source Generator detects all closed types
var userRepo = scope.GetService<IRepository<User>>();      // ✓ Generated
var orderRepo = scope.GetService<IRepository<Order>>();    // ✓ Generated

Circular Dependency Detection

// This won't compile - Source Generator catches it!
public class A(B b) { }
public class B(A a) { }  // Error PICO010: Circular dependency detected: A -> B -> A

Testing

[Test]
public async Task OrderService_Should_ProcessOrder()
{
    // Skip auto-registration, use mocks
    await using var container = new SvcContainer(autoConfigureFromGenerator: false);
    
    container.RegisterSingleton<IOrderRepository>(sp => new MockOrderRepo());
    container.RegisterSingleton<IOrderService, OrderService>();
    container.Build();
    
    using var scope = container.CreateScope();
    var service = scope.GetService<IOrderService>();
    // Assert...
}

Multiple Implementations

container.RegisterTransient<IPlugin, PluginA>();
container.RegisterTransient<IPlugin, PluginB>();
container.RegisterTransient<IPlugin, PluginC>();

// Get all implementations
var plugins = scope.GetServices<IPlugin>(); // [PluginA, PluginB, PluginC]

// Get last registered (override pattern)
var plugin = scope.GetService<IPlugin>();   // PluginC

📦 Packages

For most users: just install Pico.DI — it transitively brings in the source generator (Pico.DI.Gen) and abstractions (Pico.DI.Abs).

For library authors: reference Pico.DI.Gen if you need compile-time source generation, or Pico.DI.Abs if you only need the DI interfaces. This avoids pulling the runtime container into your library's dependency tree.

🎮 Requirements

• .NET 10.0+ (uses C# 14 extension types)
• Roslyn 4.x+ (for source generation)

⚠️ Important: Understanding autoConfigureFromGenerator

The Two Registration Modes

// Mode 1: Auto-configuration (default)
var container = new SvcContainer();  // autoConfigureFromGenerator = true

// Mode 2: Manual configuration
var container = new SvcContainer(autoConfigureFromGenerator: false);

How Registration Actually Works

Placeholder methods (depend on Source Generator):

container.RegisterTransient<IFoo, Foo>();      // ⚠️ This is a PLACEHOLDER!
container.RegisterScoped<IBar, Bar>();         // ⚠️ Actually does nothing at runtime
container.RegisterSingleton<IBaz, Baz>();      // ⚠️ Source Generator intercepts these

Factory methods (real runtime registration):

container.RegisterTransient<IFoo>(sp => new Foo());      // ✅ Real registration
container.RegisterScoped<IBar>(sp => new Bar());         // ✅ Works without Source Generator
container.RegisterSingleton<IBaz>(sp => new Baz());      // ✅ Always works
container.RegisterSingle<IConfig>(new Config());         // ✅ Instance registration

The Limitation

When to Use false

// ✅ Unit testing with mocks - use factory methods only
await using var container = new SvcContainer(autoConfigureFromGenerator: false);
container.RegisterSingleton<IRepo>(sp => new MockRepo());  // Factory method
container.RegisterSingleton<IService, MyService>();        // ❌ Won't work!
container.Build();

// ✅ Integration testing - apply generated config then override
await using var container = new SvcContainer(autoConfigureFromGenerator: false);
container.ConfigureGeneratedServices();                    // Manually apply
container.RegisterSingleton<IExternal>(sp => new Mock()); // Override specific services

TL;DR

🚨 If autoConfigureFromGenerator = false, you MUST use factory methods for registration. Placeholder methods like RegisterTransient<IFoo, Foo>() will silently do nothing.

🤝 Contributing

PRs welcome! Please ensure:

• All tests pass (dotnet test)
• Benchmarks don't regress
• AOT compatibility maintained

📄 License

MIT License - See LICENSE

<p align="center"> <b>Pico.DI</b> — Dependency Injection at the Speed of Light ⚡ </p>