Remnant Dependency Injector

Overview

The injection is a pull pattern unlike all other DI containers which follows a push pattern.
The pull pattern has no need to declare constructor arguments for DI, and also no hierarchical DI wiring is required.
The container is globally instantiated within your current app domain.
Anywhere, any place in your code the container can be requested to resolve the object needed.
An extension method 'Resolve<>' is implemented on 'object' to allow any objects to call the container.
You can use the [Inject] attribute on fields which will automatically inject the object.
The pull pattern nullifies the need for transient objects (cause no wiring dependencies needed). So ONLY singletons need to be registered.
Injecting on methods and properties (fine grain injection) in my humble opinion is a bad pattern to follow. If you are currently using such a pattern, this solution still allows you to resolve whatever, where ever you want, be it for properties or method parameters as well.

Note: To use [Inject] attribute to decorate class fields, the class must be specified as partial.

Note: The unit tests in the Tests project must be run per DI container for testing (because only one registered container is allowed in the app domain).

Nuget packages:

Core package excluding the analyzer:

  Install-Package Remnant.Dependency.Injector -Version 1.1.0

Analyzer package to use [Inject] attribute: See https://github.com/RemnantSoftware/Remnant.Dependency.Injector.Analyzer

Adapters for other DI containers:

https://github.com/RemnantSoftware/Remnant.Dependency.Unity

https://github.com/RemnantSoftware/Remnant.Dependency.Ninject

https://github.com/RemnantSoftware/Remnant.Dependency.Autofac

https://github.com/RemnantSoftware/Remnant.Dependency.CastleWindsor

https://github.com/RemnantSoftware/Remnant.Dependency.SimpleInjector

Additional adapters for other DI solutions can be coded by implementing the interface 'IContainer'.
To access the internal container directly, you can call 'Container.Instance.InternalContainer<>()' method, please see adapters repos for examples.

Usage:

Container

Construct the container and register components:

class Program
{
    public static async Task Main()
    {
          Container
            .Create("MyContainer")
            .Register<ILog>(new MyLogger())
            .Register<IRepository>(new MyRepository());
    }
}

If you need to perform additional registrations/resolves at other places, you can access the instance of the container as follows:

class Program
{
    public static async Task Initialize()
    {
          Container.Register<IConfiguration>(new AzureAppConfig());
    }
}

Manually Resolve (not using the [Inject] attribute)

Call resolve to obtain objects from the container:

// Example: using the core base object
var logger = new object().Resolve<ILog>();

// Example: how to resolve on field declaration
public class PurchaseOrder
{
    private readonly ILog _logger = Container.Resolve<ILog>();
    private readonly IRepository _repository = Container.Resolve<IRepository>();
}

// Example: how to resolve on class constructor
public class PurchaseOrder
{
    private readonly ILog _logger;
    private readonly IRepository _repository;
    
    public PurchaseOrder()
    {
        _logger = this.Resolve<ILog>();
        _repository = this.Resolve<IRepository>();
    }
}

[Inject] Attribute

By decorating your fields with the inject attribute, you dont have to specify 'Resolve' explicitly. Remnant will use the roslyn code generator to scan fields with the attribute, and automatically generate the code. But that means you must specify your class as partial.

IMPORTANT, if your class has already a constructor method implemented:

The analyzer can't generate a constructor with the injection code because the method exists already. In that case the Analyzer generates a public 'Inject' method, as well as a static 'Create' method on the class. So you can call the static 'Create' method which will create an instance of the class and it calls the 'Inject' method to perform the injection. Or you can instantiate the class and call the 'Inject' method yourself. Keep in mind that your constructor implementation all the injected fields will be null unless you explicitly call the method 'Inject' on your constructor before accessing the fields.

// Example of specifying the type
public partial class PurchaseOrder
{
    [Inject(typeof(ILog))] private readonly ILog _logger;   
    [Inject(typeof(IRepository))] private readonly IRepository _repository;
}

The 'Type' passed to the [Inject] attribute is optional, and the underlying decorated class field's data type is inferred

// Example of using the inferred field's data type
public partial class PurchaseOrder
{
    [Inject] private readonly ILog _logger;    
    [Inject] private readonly IRepository _repository;
}

// Example of using the static 'Create', fields cannot be read only
public partial class PurchaseOrder
{
    [Inject] private ILog _logger;    
    [Inject] private IRepository _repository;
        
    public PurchaseOrder()
    {
       //...do some stuff but injected fields will be null   
    }
}
        
var purchaseOrder = PurchaseOrder.Create(); // this will instantiate the class and calls 'Inject' to resolve the fields.

// Example of calling 'Inject' explicitly on your implemented constructor before accessing the injected fields
public partial class PurchaseOrder
{
    [Inject] private ILog _logger;
    [Inject] private IRepository _repository;
    
    public PurchaseOrder()
    {
        Inject();
        
       //...do some stuff and the fields are injected to be used
    }
}

RemnantSoftware/Remnant.Dependency.Injector