SSDI 1.4.3

Super Simple Dependency Injection (SSDI)

A lightweight, high-performance dependency injection framework for .NET designed for games and console applications. No container build step required — register types at any point during your application's lifecycle.

Full Documentation — Comprehensive guides, API reference, and advanced features.

Features

• No build step — Register types dynamically at runtime
• Fast resolution — Optimized for game loops and high-frequency calls
• Thread-safe — Lock-free resolution path, safe for multi-threaded environments.
• Scoped lifetime — Per-player, per-request, or per-session instances
• Unregister support — Hot-swap implementations at runtime
• Lightweight — Minimal allocations, ideal for games

Quick Start

Basic Registration and Resolution

var container = new DependencyInjectionContainer();

container.Configure(c =>
{
    c.Export<MyService>();
    c.Export<MyRepository>().Lifestyle.Singleton();
    c.Export<PlayerData>().As<IPlayerData>().Lifestyle.Scoped();
});

var service = container.Locate<MyService>();

Eager Compilation

Enable eager compilation for maximum resolution speed at the cost of longer registration time (The Configure method will take longer to complete).

var container = new DependencyInjectionContainer() { EagerCompilation = true};

container.Configure(c =>
{
    c.Export<MyService>();
    c.Export<MyRepository>().Lifestyle.Singleton();
    c.Export<PlayerData>().As<IPlayerData>().Lifestyle.Scoped();
});

var service = container.Locate<MyService>();

Lifestyles

container.Configure(c =>
{
    c.Export<GameEngine>().Lifestyle.Singleton();
    c.Export<Enemy>();  // Transient by default
    c.Export<PlayerInventory>().Lifestyle.Scoped();
});

Scoped Services

// Create a scope (e.g., per player)
using var playerScope = container.CreateScope();

var inventory1 = playerScope.Locate<IInventory>();
var inventory2 = playerScope.Locate<IInventory>();
// Same instance within scope

// All scoped IDisposable services disposed when scope ends

Interface Registration

SSDI requires explicit interface registration:

container.Configure(c =>
{
    c.Export<SqlRepository>().As<IRepository>();

    // Multiple implementations
    c.Export<AuthHandler>().As<IPacketHandler>();
    c.Export<GameHandler>().As<IPacketHandler>();
});

// Resolve all implementations
var handlers = container.Locate<IEnumerable<IPacketHandler>>();

Constructor Parameters

container.Configure(c =>
{
    // By type
    c.Export<GameServer>().WithCtorParam<int>(8080);

    // By name
    c.Export<GameServer>().WithCtorParam("port", 8080);

    // By position
    c.Export<GameServer>().WithCtorParam(0, "MyServer");

    // Multiple positional
    c.Export<GameServer>().WithCtorPositionalParams("MyServer", 8080, true);
});

Combined Registration and Runtime Parameters

Register some parameters at configuration time, provide others at resolution:

// Register host at configuration time
container.Configure(c =>
    c.Export<GameServer>()
        .WithCtorParam(0, "game.server.com")
        .WithCtorParam(1, 443));

// Provide remaining parameter at runtime
var server = container.Locate<GameServer>(
    DIParameter.Positional(2, true)); // useSsl

Unregistered Event

Subscribe to notifications when services are unregistered:

container.Unregistered += (sender, args) =>
{
    Console.WriteLine($"Unregistered: {args.UnregisteredType.Name}");
    if (args.WasDisposed)
        Console.WriteLine("  Instance was disposed");
};

Unregistering Services

// Unregister a type (disposes singleton if IDisposable)
container.Unregister<OldService>();

// Unregister all implementations of an interface
container.UnregisterAll<IPacketHandler>();

// Check registration
if (container.IsRegistered<ILogger>()) { ... }

Pre-built Instances

var config = LoadConfiguration();
container.Configure(c =>
{
    c.ExportInstance(config).As<IConfiguration>();
});

Dynamic Registration

Perfect for plugin systems and runtime extensibility:

// Load plugin assembly
var assembly = Assembly.LoadFrom(pluginPath);

container.Configure(c =>
{
    foreach (var type in assembly.GetTypes()
        .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsAbstract))
    {
        c.Export(type).As<IPlugin>();
    }
});

var plugins = container.Locate<IEnumerable<IPlugin>>();

Performance

Benchmarks comparing SSDI against popular DI containers (Windows 11):

Singleton Resolution

Transient Resolution

Combined (Singleton + Transient)

Complex Graph Resolution

Container Setup (Registration)

Note: SSDI supports two compilation modes:

• Lazy (default) — Fast registration (~27μs), compiles factories on first Locate<T>() call. Best for hot-swapping and plugin systems.
• Eager — Factories are pre-compiled during Configure() (~10ms), but resolution speed rivals top containers (~19ns). Set EagerCompilation = true.

License

MIT License - see LICENSE for details.