Hasim.Injectify 0.1.4

Injectify

A modular dependency injection system for ASP.NET Core applications. Automatically discovers modules across all projects in a solution — no manual registration needed.

Concept

Each project in your solution (Application, Core, EF Core, UI, etc.) defines its own module that registers its own dependencies. The host project (UI) discovers and initializes all modules automatically with just two calls:

// Program.cs — only 2 lines needed
var builder = WebApplication.CreateBuilder(args);
builder.InjectifyApplication();
// ...
var app = builder.Build();
app.InjectifyInitializer();
app.Run();

Features

Installation

dotnet add package Injectify

Quick Start

1. Create a module in each project (optional for DI-only services)

using Injectify.Modules;

[ModuleInfo("My Module", "1.0.0", "Description of the module")]
[ModuleOrder(10)]
public class MyModule : BaseInjectifyModule
{
    public override void ConfigureService(IServiceCollection services, IConfiguration configuration)
    {
        services.AddScoped<IMyService, MyService>();
    }

    public override void ConfigureApplication(WebApplication app)
    {
        app.Logger.LogInformation("MyModule initialized");
        app.UseMiddleware<MyMiddleware>();
    }
}

2. In the UI project — 2 lines (discovers modules + auto-registers services)

var builder = WebApplication.CreateBuilder(args);
builder.InjectifyApplication();    // Scans all assemblies, discovers all IModule + auto-registers IAddSingleton/IAddScoped/IAddTransient

var app = builder.Build();
app.InjectifyInitializer();            // Calls ConfigureApplication on each module
app.Run();

3. Auto-register services with marker interfaces (new!)

Instead of manually registering services in ConfigureService, implement the appropriate marker interface on your service implementation:

using Injectify.Abstractions;

// Automatically registered as Scoped
public interface IUserService : IAddScoped { }
public class UserService : IUserService { }

// Automatically registered as Singleton
public interface ICacheService : IAddSingleton { }
public class CacheService : ICacheService { }

// Automatically registered as Transient
public interface IEmailService : IAddTransient { }
public class EmailService : IEmailService { }

No manual services.AddScoped<>() calls needed — builder.InjectifyApplication() handles it automatically.

3. Module lifecycle

public class MyModule : BaseInjectifyModule
{
    public override void OnInit(IServiceCollection services) { /* before registration */ }
    public override void OnStart(WebApplication app)        { /* after build, before run */ }
    public override void OnStop()                           { /* on shutdown */ }
}

4. Module dependencies

[DependsOn(typeof(CoreModule))]
[DependsOn(typeof(EFCoreModule))]
public class UIModule : BaseInjectifyModule { }

Packages

Project structure

Injectify/
├── Abstractions/          # Marker interfaces: IAddSingleton, IAddScoped, IAddTransient
├── Attributes/            # [DependsOn], [ModuleInfo], [ModuleOrder]
├── Exceptions/            # InjectifyException, DependencyCycleException
├── Extensions/            # Fluent DI extensions (InjectifyApplication, InjectifyInitializer, DependencyInjectionExtensions)
├── Modules/               # IModule, IModuleLifecycle, BaseInjectifyModule
├── Setup/                 # IModuleLoader, ModuleLoader (assembly scanning, topological sort)
└── Injectify.Tests/       # Unit tests (xUnit)

Documentation

• README.fr.md — Documentation en français
• AUDIT.md — Audit findings & technical debt

License

MIT