https://github.com/devlooped/DependencyInjection
Provides compile-time discovery and code generation of service registrations from attributed types and conventions
https://github.com/devlooped/DependencyInjection
Last synced: about 1 year ago
JSON representation
Provides compile-time discovery and code generation of service registrations from attributed types and conventions
- Host: GitHub
- URL: https://github.com/devlooped/DependencyInjection
- Owner: devlooped
- License: mit
- Created: 2022-09-23T06:23:05.000Z (almost 4 years ago)
- Default Branch: main
- Last Pushed: 2025-03-29T00:27:49.000Z (about 1 year ago)
- Last Synced: 2025-04-05T23:43:57.071Z (about 1 year ago)
- Language: C#
- Homepage:
- Size: 329 KB
- Stars: 53
- Watchers: 1
- Forks: 3
- Open Issues: 2
-
Metadata Files:
- Readme: readme.md
- Changelog: changelog.md
- License: license.txt
Awesome Lists containing this project
README
 .NET DependencyInjection via [Service] Attribute
============
[](https://www.nuget.org/packages/Devlooped.Extensions.DependencyInjection.Attributed)
[](https://www.nuget.org/packages/Devlooped.Extensions.DependencyInjection.Attributed)
[](https://github.com//devlooped/DependencyInjection.Attributed/blob/main/license.txt)
[](https://github.com/devlooped/DependencyInjection.Attributed/actions)
Automatic compile-time service registrations for Microsoft.Extensions.DependencyInjection with no run-time dependencies.
## Usage
After [installing the nuget package](https://www.nuget.org/packages/Devlooped.Extensions.DependencyInjection.Attributed),
a new `[Service(ServiceLifetime)]` attribute will be available to annotate your types:
```csharp
[Service(ServiceLifetime.Scoped)]
public class MyService : IMyService, IDisposable
{
public string Message => "Hello World";
public void Dispose() { }
}
public interface IMyService
{
string Message { get; }
}
```
The `ServiceLifetime` argument is optional and defaults to [ServiceLifetime.Singleton](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.servicelifetime?#fields).
> NOTE: The attribute is matched by simple name, so you can define your own attribute
> in your own assembly. It only has to provide a constructor receiving a
> [ServiceLifetime](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.servicelifetime) argument.
A source generator will emit (at compile-time) an `AddServices` extension method for
[IServiceCollection](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.iservicecollection)
which you can call from your startup code that sets up your services, like:
```csharp
var builder = WebApplication.CreateBuilder(args);
// NOTE: **Adds discovered services to the container**
builder.Services.AddServices();
// ...
var app = builder.Build();
// Configure the HTTP request pipeline.
app.MapGet("/", (IMyService service) => service.Message);
// ...
app.Run();
```
> NOTE: the service is available automatically for the scoped request, because
> we called the generated `AddServices` that registers the discovered services.
And that's it. The source generator will discover annotated types in the current
project and all its references too. Since the registration code is generated at
compile-time, there is no run-time reflection (or dependencies) whatsoever.
### Keyed Services
[Keyed services](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-8.0#keyed-services)
are also supported by a separate generic `[Service]` attribute, like:
```csharp
public interface INotificationService
{
string Notify(string message);
}
[Service("sms")]
public class SmsNotificationService : INotificationService
{
public string Notify(string message) => $"[SMS] {message}";
}
[Service("email")]
public class EmailNotificationService : INotificationService
{
public string Notify(string message) => $"[Email] {message}";
}
```
Services that want to consume a specific keyed service can use the
`[FromKeyedServices(object key)]` attribute to specify the key, like:
```csharp
[Service]
public class SmsService([FromKeyedServices("sms")] INotificationService sms)
{
public void DoSomething() => sms.Notify("Hello");
}
```
In this case, when resolving the `SmsService` from the service provider, the
right `INotificationService` will be injected, based on the key provided.
## How It Works
The generated code that implements the registration looks like the following:
```csharp
static partial class AddServicesExtension
{
public static IServiceCollection AddServices(this IServiceCollection services)
{
services.AddScoped(s => new MyService());
services.AddScoped(s => s.GetRequiredService());
services.AddScoped(s => s.GetRequiredService());
return services;
}
```
Note how the service is registered as scoped with its own type first, and the
other two registrations just retrieve the same (according to its defined
lifetime). This means the instance is reused and properly registered under
all implemented interfaces automatically.
> NOTE: you can inspect the generated code by setting `EmitCompilerGeneratedFiles=true`
> in your project file and browsing the `generated` subfolder under `obj`.
If the service type has dependencies, they will be resolved from the service
provider by the implementation factory too, like:
```csharp
services.AddScoped(s => new MyService(s.GetRequiredService(), ...));
```
## MEF Compatibility
Given the (more or less broad?) adoption of
[MEF attribute](https://learn.microsoft.com/en-us/dotnet/framework/mef/attributed-programming-model-overview-mef)
(whether [.NET MEF, NuGet MEF or VS MEF](https://github.com/microsoft/vs-mef/blob/main/doc/mef_library_differences.md)) in .NET,
the generator also supports the `[Export]` attribute to denote a service (the
type argument as well as contract name are ignored, since those aren't supported
in the DI container).
In order to specify a singleton (shared) instance in MEF, you have to annotate the
type with an extra attribute: `[Shared]` in NuGet MEF (from [System.Composition](http://nuget.org/packages/System.Composition.AttributedModel))
or `[PartCreationPolicy(CreationPolicy.Shared)]` in .NET MEF
(from [System.ComponentModel.Composition](https://www.nuget.org/packages/System.ComponentModel.Composition)).
Both `[Export("contractName")]` and `[Import("contractName")]` are supported and
will be used to register and resolve keyed services respectively, meaning you can
typically depend on just `[Export]` and `[Import]` attributes for all your DI
annotations and have them work automatically when composed in the DI container.
## Advanced Scenarios
### `Lazy` and `Func` Dependencies
A `Lazy` for each interface (and main implementation) is automatically provided
too, so you can take a lazy dependency out of the box too. In this case, the lifetime
of the dependency `T` becomes tied to the lifetime of the component taking the lazy
dependency, for obvious reasons. The `Lazy` is merely a lazy resolving of the
dependency via the service provider. The lazy itself isn't costly to construct, and
since the lifetime of the underlying service, plus the lifetime of the consuming
service determine the ultimate lifetime of the lazy, no additional configuration is
necessary for it, as it's always registered as a transient component. Generated code
looks like the following:
```csharp
services.AddTransient(s => new Lazy(s.GetRequiredService));
```
A `Func` is also automatically registered, but it is just a delegate to the
actual `IServiceProvider.GetRequiredService`. Generated code looks like the
following:
```csharp
services.AddTransient>(s => s.GetRequiredService);
```
Repeatedly invoking the function will result in an instance of the required
service that depends on the registered lifetime for it. If it was registered
as a singleton, for example, you would get the same value every time, just
as if you had used a dependency of `Lazy` instead, but invoking the
service provider each time, instead of only once. This makes this pattern
more useful for transient services that you intend to use for a short time
(and potentially dispose afterwards).
### Your Own ServiceAttribute
If you want to declare your own `ServiceAttribute` and reuse from your projects,
so as to avoid taking a (development-only, compile-time only) dependency on this
package from your library projects, you can just declare it like so:
```csharp
[AttributeUsage(AttributeTargets.Class)]
public class ServiceAttribute : Attribute
{
public ServiceAttribute(ServiceLifetime lifetime = ServiceLifetime.Singleton) { }
}
```
Likewise for the keyed service version:
```csharp
[AttributeUsage(AttributeTargets.Class)]
public class ServiceAttribute : Attribute
{
public ServiceAttribute(TKey key, ServiceLifetime lifetime = ServiceLifetime.Singleton) { }
}
```
> NOTE: since the constructor arguments are only used by the source generation to
> detemine the registration style (and key), but never at run-time, you don't even need
> to keep it around in a field or property!
With this in place, you only need to add this package to the top-level project
that is adding the services to the collection!
The attribute is matched by simple name, so it can exist in any namespace.
If you want to avoid adding the attribute to the project referencing this package,
set the `$(AddServiceAttribute)` to `true` via MSBuild:
```xml
false
```
### Choose Constructor
If you want to choose a specific constructor to be used for the service implementation
factory registration (instead of the default one which will be the one with the most
parameters), you can annotate it with `[ImportingConstructor]` from either NuGet MEF
([System.Composition](http://nuget.org/packages/System.Composition.AttributedModel))
or .NET MEF ([System.ComponentModel.Composition](https://www.nuget.org/packages/System.ComponentModel.Composition)).
### Customize Generated Class
You can customize the generated class namespace and name with the following
MSBuild properties:
```xml
MyNamespace
MyExtensions
```
They default to `Microsoft.Extensions.DependencyInjection` and `AddServicesExtension`
respectively.
# Sponsors
[](https://github.com/clarius)
[](https://github.com/KirillOsenkov)
[](https://github.com/MFB-Technologies-Inc)
[](https://github.com/decriptor)
[](https://github.com/torutek-gh)
[](https://github.com/drivenet)
[](https://github.com/AshleyMedway)
[](https://github.com/Keflon)
[](https://github.com/tbolon)
[](https://github.com/kfrancis)
[](https://github.com/twenzel)
[](https://github.com/Giorgi)
[](https://github.com/MikeCodesDotNET)
[](https://github.com/dansiegel)
[](https://github.com/rbnswartz)
[](https://github.com/jfoshee)
[](https://github.com/Mrxx99)
[](https://github.com/eajhnsn1)
[](https://github.com/mackayn)
[](https://github.com/certifytheweb)
[](https://github.com/IxTechnologies)
[](https://github.com/davidjenni)
[](https://github.com/Jonathan-Hickey)
[](https://github.com/okyrylchuk)
[](https://github.com/akunzai)
[](https://github.com/jakobt)
[](https://github.com/seanalexander)
[](https://github.com/tinohager)
[](https://github.com/ploeh)
[](https://github.com/angelobelchior)
[](https://github.com/KenBonny)
[](https://github.com/SimonCropp)
[](https://github.com/agileworks-eu)
[](https://github.com/sorahex)
[](https://github.com/arsdragonfly)
[](https://github.com/vezel-dev)
[](https://github.com/georg-jung)
[](https://github.com/sponsors/devlooped)
[Learn more about GitHub Sponsors](https://github.com/sponsors)