IL.AttributeBasedDI
2.11.1.1
dotnet add package IL.AttributeBasedDI --version 2.11.1.1
NuGet\Install-Package IL.AttributeBasedDI -Version 2.11.1.1
<PackageReference Include="IL.AttributeBasedDI" Version="2.11.1.1" />
<PackageVersion Include="IL.AttributeBasedDI" Version="2.11.1.1" />
<PackageReference Include="IL.AttributeBasedDI" />
paket add IL.AttributeBasedDI --version 2.11.1.1
#r "nuget: IL.AttributeBasedDI, 2.11.1.1"
#:package IL.AttributeBasedDI@2.11.1.1
#addin nuget:?package=IL.AttributeBasedDI&version=2.11.1.1
#tool nuget:?package=IL.AttributeBasedDI&version=2.11.1.1
IL.AttributeBasedDI
Control dependencies and decorators via custom attributes - extends Microsoft.Extensions.DependencyInjection.
Current targets: .NET 10 and .NET 11. The bundled Roslyn analyzer remains
netstandard2.0and uses Roslyn 5.0 APIs to support SDK 10 and SDK 11 compilers.
Build all targets with the .NET 11 SDK. Running the complete test suite also requires the .NET 10 runtime:
dotnet build --configuration Release
dotnet test --configuration Release --no-build --no-restore
How to Use
- Reference
IL.AttributeBasedDIin your project. - Use the registration extensions provided by the library to activate functionality:
services.AddServiceAttributeBasedDependencyInjection()forIServiceCollection.builder.AddServiceAttributeBasedDependencyInjection()forWebApplicationBuilder.
- Optionally, filter assemblies for reflection search using the
assemblyFiltersparameter (e.g.,"MyProject.*").
Attributes
[Service]
Use this attribute to automatically register classes in the DI container.
Parameters:
- Lifetime: Defines the service registration lifetime (
Singleton,Scoped, orTransient). - ServiceType: Specifies the service type for DI registration. If
null, the service type is automatically resolved:- From the first interface the class implements, or
- The class itself if no interfaces are implemented.
- Key (
.NET 8+): Specifies a key for keyed service registration. - Feature (optional): Specifies a feature flag to conditionally register the service.
[ServiceWithOptions]
Use this attribute to automatically register classes with options from configuration in the DI container.
Parameters:
- Lifetime: Defines the service registration lifetime (
Singleton,Scoped, orTransient). - ServiceType: Specifies the service type for DI registration. If
null, the service type is automatically resolved:- From the first interface the class implements, or
- The class itself if no interfaces are implemented.
- Key (
.NET 8+): Specifies a key for keyed service registration. - Feature (optional): Specifies a feature flag to conditionally register the service.
How it works
The ServiceWithOptions attribute requires a generic type that implements the IServiceConfiguration interface. This interface has a static abstract property ConfigurationPath that defines the path to the configuration section in appsettings.json.
Example
appsettings.json
{
"AppSettings": {
"Test": {
"Option1": "test12345"
}
}
}
ServiceTestOptions.cs
public class ServiceTestOptions : IServiceConfiguration
{
public static string ConfigurationPath => "AppSettings:Test";
public string Option1 { get; set; } = "test123";
}
TestServiceWithOptions.cs
[ServiceWithOptions<ServiceTestOptions>]
public class TestServiceWithOptions
{
private readonly ServiceTestOptions _serviceConfiguration;
public TestServiceWithOptions(IOptions<ServiceTestOptions> options)
{
_serviceConfiguration = options.Value;
}
public string GetOption1Value() => _serviceConfiguration.Option1;
}
[HostedService]
Use this attribute to register hosted services with IHostedService forwarding behavior:
- Equivalent to
services.AddHostedService(sp => sp.GetRequiredService<TImplementation>()). - If the implementation is already registered as singleton, the hosted registration reuses that singleton instance.
Parameters:
- ImplementationType (optional): hosted service concrete type. If omitted, the decorated class is used.
- Lifetime (optional): defaults to
Singleton.
Example
[HostedService<MyBackgroundService>]
public class MyBackgroundServiceRegistrationMarker;
or directly on the hosted service:
[HostedService]
public class MyBackgroundService : BackgroundService
{
protected override Task ExecuteAsync(CancellationToken stoppingToken) => Task.CompletedTask;
}
[ImplementationInstanceFor<TService, TProvider>]
Use this attribute to register singleton implementation instances in a framework-like way (no typeof(factory), nameof(method) pairs).
Provider contract
TProvider must implement:
public interface IImplementationInstanceProvider<out TService>
{
static abstract TService GetImplementationInstance();
}
Parameters:
- TService: service type to register.
- TProvider: provider type that exposes
GetImplementationInstance. - Key (optional): keyed singleton registration key.
Feature-flag variant is also available:
[ImplementationInstanceFor<TService, TProvider, TFeatureFlag>]
Example (Channel<T>)
public sealed class WorkItemChannelProvider
: IImplementationInstanceProvider<Channel<MyHostedService.WorkItem>>
{
public static Channel<MyHostedService.WorkItem> GetImplementationInstance()
=> Channel.CreateUnbounded<MyHostedService.WorkItem>();
}
[ImplementationInstanceFor<Channel<MyHostedService.WorkItem>, WorkItemChannelProvider>]
public class WorkItemChannelRegistrationMarker;
[Decorator]
Use this attribute to automatically register decorators for specific services.
Parameters:
- ServiceType: Specifies the service type to decorate. If
null, the service type is automatically resolved from the first interface the class implements. - DecorationOrder: Defines the order of decoration. Lower values are closer to the original implementation in the execution chain.
- Key (
.NET 8+): Specifies a key for keyed decorator registration. - Feature (optional): Specifies a feature flag to conditionally register the decorator.
- TreatOpenGenericsAsWildcard (optional,
bool): When set totrue, the decorator will treat open generic service types as a wildcard, allowing it to decorate any closed generic implementation of that service.
Examples
Basic Usage
IService resolves to:
DecoratorA- Wrapping
SampleService
- Wrapping
[Service]
class SampleService : IService {}
[Decorator]
class DecoratorA : IService {}
IService resolves to:
DecoratorBWrapping DecoratorAWrapping SampleService
[Service(serviceType: typeof(IService), lifetime: Lifetime.Singleton)]
class SampleService : IService {}
[Decorator(serviceType: typeof(IService), decorationOrder: 1)]
class DecoratorA : IService
{
public DecoratorA(IService service)
{
// `service` here is actually `SampleService`
}
}
[Decorator(serviceType: typeof(IService), decorationOrder: 2)]
class DecoratorB : IService
{
public DecoratorB(IService service)
{
// `service` here is actually `DecoratorA`
}
}
.NET 8 Keyed Services
[Service(Key = "randomKey")]
class SampleServiceDefault : IService {}
[Service(Key = "testKey")]
class SampleService : IService {}
[Decorator(Key = "testKey")]
class DecoratorA : IService {}
public class Test
{
public Test(
[FromKeyedServices("randomKey")] IService randomSvc,
[FromKeyedServices("testKey")] IService svc)
{
// `randomSvc` resolves to `SampleServiceDefault`
// `svc` resolves to `DecoratorA` wrapping `SampleService`
}
}
Triple-Attribute Hosted Service Pattern
Use all 3 attributes on one class to mimic:
AddSingleton<IContentRefreshWorkScheduler, ContentRefreshBatchHostedService>()AddSingleton(Channel.CreateUnbounded<WorkItem>())AddHostedService(sp => sp.GetRequiredService<ContentRefreshBatchHostedService>())
[Service(Lifetime = ServiceLifetime.Singleton, ServiceType = typeof(IContentRefreshWorkScheduler))]
[ImplementationInstanceFor<
Channel<ContentRefreshBatchHostedService.WorkItem>,
ContentRefreshBatchHostedService>]
[HostedService]
internal sealed class ContentRefreshBatchHostedService(
Channel<ContentRefreshBatchHostedService.WorkItem> channel)
: BackgroundService,
IContentRefreshWorkScheduler,
IImplementationInstanceProvider<Channel<ContentRefreshBatchHostedService.WorkItem>>
{
public sealed class WorkItem;
public static Channel<WorkItem> GetImplementationInstance()
=> Channel.CreateUnbounded<WorkItem>();
protected override Task ExecuteAsync(CancellationToken stoppingToken) => Task.CompletedTask;
}
Feature Flags
Note: Starting from version 2.0.0, you can conditionally register services and decorators based on feature flags.
Feature-flag support in this library works as follows:
- Feature enums used with
[Service<TFeatureFlag>]/[Decorator<TFeatureFlag>]must be marked with[Flags]. - You can enable multiple feature enum types in the same registration call.
AddFeature(...)merges repeated calls for the same enum type using bitwise OR.- If an attribute declares multiple flags (e.g.,
FeatureA | FeatureC), registration is enabled when at least one of those flags is active.
[Flags]
public enum SearchOptions
{
None = 0,
Azure = 1 << 0,
Elastic = 1 << 1
}
[Flags]
public enum AnotherOptionsEnum
{
None = 0,
FeatureX = 1 << 0,
FeatureY = 1 << 1
}
[Service<SearchOptions>(Feature = SearchOptions.Azure)]
class AzureSearchService : ISearchService {}
[Service<AnotherOptionsEnum>(Feature = AnotherOptionsEnum.FeatureX)]
class FeatureXService : IFeatureService {}
Enable flags in code:
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceAttributeBasedDependencyInjection(options =>
{
options.AddFeature(SearchOptions.Azure);
options.AddFeature(AnotherOptionsEnum.FeatureX);
// same enum type is merged
options.AddFeature(SearchOptions.Elastic);
});
Enable flags from appsettings (including multiple enum types):
{
"DIFeatureFlags": {
"SearchOptions": ["Azure"],
"AnotherOptionsEnum": ["FeatureX"]
}
}
builder.AddServiceAttributeBasedDependencyInjection(options =>
{
options.SetFeaturesFromConfig(new Dictionary<string, Type>
{
{ nameof(SearchOptions), typeof(SearchOptions) },
{ nameof(AnotherOptionsEnum), typeof(AnotherOptionsEnum) }
});
});
// custom root section (instead of "DIFeatureFlags")
builder.AddServiceAttributeBasedDependencyInjection(options =>
{
options.SetFeaturesFromConfig(
new Dictionary<string, Type>
{
{ nameof(SearchOptions), typeof(SearchOptions) },
{ nameof(AnotherOptionsEnum), typeof(AnotherOptionsEnum) }
},
"CustomFeatureFlagsRoot");
});
Migration to Version 2.0.0
Version 2.0.0 originally raised the minimum to .NET 8. The current build targets .NET 10 and .NET 11; use a compatible older package release if your application still targets .NET 8 or .NET 9.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. net11.0 is compatible. |
NuGet packages (3)
Showing the top 3 NuGet packages that depend on IL.AttributeBasedDI:
| Package | Downloads |
|---|---|
|
IL.UmbracoSearch
A comprehensive search solution for Umbraco, supporting both Lucene and Azure Search, with extensible indexing and flexible search parameters. |
|
|
IL.UmbracoSearch.Analytics
Optional analytics and Azure synonym management for IL.UmbracoSearch. |
|
|
IL.AttributeBasedDI.Visualizer
Extension for IL.AttributeBasedDI |
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 2.11.1.1 | 0 | 11/18/2026 |
| 2.10.1.1 | 263 | 10/15/2026 |
| 2.9.3.1 | 615 | 8/25/2026 |
| 2.9.2.1 | 160 | 8/22/2026 |
| 2.9.1.1 | 1,488 | 7/24/2026 |
| 2.9.0.3 | 862 | 5/4/2026 |
| 2.9.0.2 | 162 | 5/4/2026 |
| 2.9.0.1 | 189 | 5/3/2026 |
| 2.8.2.1 | 176 | 5/3/2026 |
| 2.8.1.1 | 178 | 5/2/2026 |
| 2.8.0.1 | 155 | 5/2/2026 |
| 2.7.1.2 | 191 | 4/21/2026 |
| 2.7.1.1 | 399 | 3/14/2026 |
| 2.7.0.1 | 1,361 | 1/5/2026 |
| 2.6.1 | 861 | 11/7/2025 |
| 2.6.0 | 644 | 10/30/2025 |
| 2.5.3 | 1,473 | 7/30/2025 |
| 2.5.2 | 1,423 | 6/10/2025 |
| 2.5.1 | 252 | 5/31/2025 |
| 2.5.0 | 418 | 5/20/2025 |