Simple, declarative dependency injection and configuration using attributes - without all the boilerplate code.
Get Started
$ dotnet add package DigitalRuby.SimpleDiReadme
SimpleDi
Declarative Dependency Injection and Configuration for .NET
SimpleDi allows you to inject interfaces and types using attributes. No need for complex frameworks or manually adding injections to your startup code.
You can also put service configuration and web application builder setup code in classes, allowing your class libraries to automatically be part of these processes.
Setup
using DigitalRuby.SimpleDi;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSimpleDi();
// for web apps (not needed for non-web apps):
var host = builder.Build();
host.UseSimpleDi();
Implementation
Create a class, MyInterfaceImplementation
// Interface will be available in constructors
public interface IMyInterface
{
}
// bind the class to simpledi, implementing IMyInterface
[Binding(BindingType.Singleton)]
public sealed class MyInterfaceImplementation : IMyInterface
{
}
Inject the interface into the constructor of another class:
[Binding(BindingType.Singleton)]
public sealed class MyClass
{
public MyClass(IMyInterface myInterface)
{
}
}
Hosted Services
[Binding(BindingType.Singleton)]
public sealed class MyHostedClass : IHostedService
{
public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}
Select Interfaces
// only register MyClass concrete type
[Binding(BindingType.Singleton, null)]
public sealed class MyClass1 : IInterface1, IInterface2
{
}
// only register MyClass concrete type and IInterface1
[Binding(BindingType.Singleton, typeof(IInterface1))]
public sealed class MyClass2 : IInterface1, IInterface2
{
}
When using the BindingAttribute you can specify an optional conflict resolution:
public BindingAttribute(ServiceLifetime scope, ConflictResolution conflict, params Type[]? interfaces)
/// <summary>
/// What to do if there is a conflict when registering services
/// </summary>
public enum ConflictResolution
{
/// <summary>
/// Add. This will result in multiple services for an interface if more than one are added.
/// </summary>
Add = 0,
/// <summary>
/// Replace. This will make sure only one implementation exists for an interface.
/// </summary>
Replace,
/// <summary>
/// Skip. Do not register this service if another implementation exits for the interface.
/// </summary>
Skip
}