Injectify.Auto 1.1.0

dotnet add package Injectify.Auto --version 1.1.0
                    
NuGet\Install-Package Injectify.Auto -Version 1.1.0
                    
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Injectify.Auto" Version="1.1.0" />
                    
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="Injectify.Auto" Version="1.1.0" />
                    
Directory.Packages.props
<PackageReference Include="Injectify.Auto" />
                    
Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add Injectify.Auto --version 1.1.0
                    
#r "nuget: Injectify.Auto, 1.1.0"
                    
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package Injectify.Auto@1.1.0
                    
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=Injectify.Auto&version=1.1.0
                    
Install as a Cake Addin
#tool nuget:?package=Injectify.Auto&version=1.1.0
                    
Install as a Cake Tool

ezgif-4d080faf903e07

Injectify

NuGet NuGet downloads Release License: MIT

⚑ Overview

This project provides a utility for automatically registering services in a .NET application using custom attributes (Singleton, Scoped, and Transient). It simplifies the process of configuring dependency injection by scanning assemblies and registering services based on their lifetime.

πŸš€ Features

  • πŸ› οΈ Custom Attributes: Use [Singleton], [Scoped], and [Transient] to define the lifetime of your services.
  • πŸ”„ Automatic Registration: Automatically scans assemblies and registers services with the appropriate lifetime in the IServiceCollection.
  • 🏷️ Interface Binding: Pass the service type to the attribute, [Scoped(typeof(IOrderService))], so only the class is marked and your interfaces stay free of attributes.
  • πŸ›‘οΈ Early Errors: Conflicting lifetimes or a wrong service type throw a clear exception at startup instead of failing silently.
  • πŸ—ΊοΈ Dependency Graph: Generates a Mermaid diagram of your services' constructor dependencies.

πŸ“¦ Installation

Install the Injectify.Auto package from NuGet:

dotnet add package Injectify.Auto

Supports .NET 8, 9 and 10. The only dependency is Microsoft.Extensions.DependencyInjection.

πŸ“– Usage

πŸ”· 1. Define your services and annotate them with the appropriate lifetime attribute:

Example 1: Scoped

using Injectify.Attributes;

public interface IScopedLogger
{
    void Log(string message);
}

[Scoped(typeof(IScopedLogger))]
public class ScopedLogger : IScopedLogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[Scoped] {message}");
    }
}

Example 2: Singleton

using Injectify.Attributes;

[Singleton]
public class GlobalConfiguration
{
    public string Environment { get; set; } = "Production";
}

Example 3: Transient

using Injectify.Attributes;

// Marking the interface with the same attribute as the class also binds them
// (the way earlier versions worked). The lifetimes must match.
[Scoped]
public interface IUserContext
{
    string GetUserId();
}

[Scoped]
public class UserContext : IUserContext
{
    public string GetUserId() => "user-123";
}

[Transient]
public class AuditService
{
    private readonly IUserContext _userContext;

    public AuditService(IUserContext userContext)
    {
        _userContext = userContext;
    }

    public void Audit(string action)
    {
        Console.WriteLine($"User {_userContext.GetUserId()} performed: {action}");
    }
}

Example 4: Generic

using Injectify.Attributes;

public interface IRepository<T>
{
    void Add(T item);
}

// Open generic class: pass the open generic service type.
// A closed class (UserRepository : IRepository<User>) uses typeof(IRepository<User>).
[Transient(typeof(IRepository<>))]
public class InMemoryRepository<T> : IRepository<T>
{
    private readonly List<T> _items = new();

    public void Add(T item)
    {
        _items.Add(item);
    }
}

πŸ”· 2. Register the services in your Startup or Program class:

using Microsoft.Extensions.DependencyInjection;

IServiceCollection services = new ServiceCollection();
services.AddInjectify(typeof(Program).Assembly);

In ASP.NET Core:

builder.Services.AddInjectify(typeof(Program).Assembly);

AddInjectify lives in the Microsoft.Extensions.DependencyInjection namespace, next to AddScoped and AddSingleton. AggregateLifeTime from earlier versions still works, but is obsolete.

Each class is registered as:

  1. the service type passed to its attribute, [Scoped(typeof(IOrderService))]; otherwise
  2. the first interface marked with the same attribute; otherwise
  3. the class itself.

Registrations that need a factory or a condition stay in code, next to AddInjectify:

builder.Services.AddInjectify(typeof(Program).Assembly);
builder.Services.AddSingleton<IConnectionMultiplexer>(_ =>
    ConnectionMultiplexer.Connect(builder.Configuration.GetConnectionString("Redis")!));

πŸ”· 3. (Optional) Draw the dependency graph

DrawAggregator builds a Mermaid graph from the annotated classes. Each edge goes from a service to a constructor parameter and is labeled with the parameter name. Like Microsoft.Extensions.DependencyInjection, it uses the public constructor with the most parameters.

using Injectify.Aggregator;

string graph = DrawAggregator.GenerateMermaidGraph(typeof(Program).Assembly);
Console.WriteLine(graph);

For a service like this:

[Scoped(typeof(IOrderService))]
public class OrderService(IRepository<Order> orders, Clock clock) : IOrderService
{
    // ...
}

it prints:

graph TD
    OrderService -->|orders| IRepository
    OrderService -->|clock| Clock

Paste the output into mermaid.live, or into a mermaid code block in any Markdown file on GitHub, and it renders as a diagram:

graph TD
    OrderService -->|orders| IRepository
    OrderService -->|clock| Clock

Attributes

[Singleton]: Registers the service with a singleton lifetime.
[Scoped]: Registers the service with a scoped lifetime.
[Transient]: Registers the service with a transient lifetime.

[Scoped(typeof(IService))]: Registers the class as IService. Works the same way for [Singleton] and [Transient].
                            Use typeof(IService<>) for open generic classes.

⚠️ Error Handling

AddInjectify checks the attributes while it scans and throws at startup, so a mistake never turns into a missing registration later. All errors derive from InjectifyException (namespace Injectify.Exceptions) and name the classes involved.

Exception When
MultipleLifetimeException A class has more than one lifetime attribute.
LifetimeMismatchException A class and its interface (or the service type passed to the attribute) have different lifetimes, e.g. a [Transient] class implementing a [Scoped] interface.
InvalidServiceTypeException The service type passed to the attribute is not implemented by the class, or mixes open and closed generics.

πŸ‘¨β€πŸ’» Contributing

Feel free to submit issues or create pull requests to enhance Injectify.

Product Compatible and additional computed target framework versions.
.NET net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 is compatible.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  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. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
1.1.0 52 11/20/2026
1.0.5 53 11/19/2026
1.0.4 47 11/19/2026
1.0.3 280 5/26/2026
1.0.2 129 5/26/2026
1.0.1 120 5/26/2026
1.0.0 120 5/26/2026