Futurum.Microsoft.Extensions.DependencyInjection 1.0.6

Futurum.Microsoft.Extensions.DependencyInjection

A dotnet library that extends Microsoft.Extensions.DependencyInjection by adding support for modules, startables and attribute based registration.

• Autodiscovery of DependencyInjection registrations, based on attributes and Source Generators
• Autodiscovery of DependencyInjection modules, based on attributes and Source Generators
• Autodiscovery of DependencyInjection startables, based on attributes and Source Generators
• Roslyn Analysers to help build your WebApiEndpoint(s), using best practices
• Integration with Futurum.Core]

TryGetService

Try to get the service object of the specified type.

var result = serviceProvider.TryGetService<ITestService>();

Modules

A module allows you to break up registration into logical units.

Module can either be registered using IModule interface and AddModule extension method, or by using the RegisterAsDependencyInjectionModule attribute.

IModule interface and AddModule extension method

IModule interface

Implements this interface to create a module.

public class TestModule : IModule
{
    public void Load(IServiceCollection services)
    {
        services.AddSingleton<ITestService, TestService>();
    }
}

AddModule extension method

Allows you to register a module.

services.AddModule<TestModule>();

services.AddModule(new TestModule());

Attribute based module

You can also register modules using attributes.

• RegisterAsDependencyInjectionModule attribute

public class Module
{
    [RegisterAsDependencyInjectionModule]
    public void Load(IServiceCollection services)
    {
    }
}

public static class Module
{
    [RegisterAsDependencyInjectionModule]
    public static void Load(IServiceCollection services)
    {
    }
}

Startables

A startable is resolved at the start of the application lifecycle and is a place to perform actions as soon as the DependencyInjection container is built.

Startable can either be registered using IStartable interface and AddStartable extension method, or by using the RegisterAsDependencyInjectionStartable attribute.

IStartable interface and AddStartable extension method

IStartable interface

Implements this interface to create a startable.

public class TestStartable : IStartable
{
    public Task Start()
    {
        // Do something
    }
}

AddStartable extension method

Allows you to register a startable.

services.AddStartable<TestStartable>();

services.AddStartable(new TestStartable());

Attribute based startable

You can also register modules using attributes.

• RegisterAsDependencyInjectionStartable attribute

public class Startable
{
    [RegisterAsDependencyInjectionStartable]
    public Task Start()
    {
        // Do something
    }
}

public static class Startable
{
    [RegisterAsDependencyInjectionStartable]
    public static Task Start()
    {
        // Do something
    }
}

BuildServiceProviderWithStartables extension method

If you are manually building the IServiceProvider, then you need to use BuildServiceProviderWithStartablesAsync extension method. This will build the container as usual, but also starts all IStartable instances.

var serviceProvider = await services.BuildServiceProviderWithStartablesAsync();

Attribute based registration

You can also register services using attributes.

There are generic attributes available allowing you to specify the ServiceType, if your service implements multiple interfaces.

RegisterAsSingleton attribute

[RegisterAsSingleton]
public class Service : IService
{
}

[RegisterAsSingleton<IService2>]
public class Service : IService1, IService2
{
}

RegisterAsScoped attribute

[RegisterAsScoped]
public class Service : IService
{
}

[RegisterAsScoped<IService2>]
public class Service : IService1, IService2
{
}

RegisterAsTransient attribute

[RegisterAsTransient]
public class Service : IService
{
}

[RegisterAsTransient<IService2>]
public class Service : IService1, IService2
{
}

DuplicateRegistrationStrategy

• Try - Adds the new registration, if the service hasn't already been registered
• Replace - Removes any existing registration and then adds the new registration
• Add - Adds the new registration, irrespective of if its previously been registered

NOTE - This defaults to Try

[RegisterAsSingleton(DuplicateRegistrationStrategy = DuplicateRegistrationStrategy.Add)]
public class Service : IService
{
}

InterfaceRegistrationStrategy

• Self - Registers the service as itself
• ImplementedInterfaces - Registers the service as each its implemented interfaces
• SelfWithInterfaces - Registers the service as itself and each its implemented interfaces

NOTE - This defaults to SelfWithInterfaces

[RegisterAsSingleton(InterfaceRegistrationStrategy = InterfaceRegistrationStrategy.ImplementedInterfaces)]
public class Service : IService
{
}

Roslyn Analysers

• FMEDI0001 - Invalid Module Parameter
• FMEDI0002 - Missing Module Parameter
• FMEDI0003 - Non empty constructor found on Module
• FMEDI0004 - Non empty constructor found on Startable
• FMEDI0005 - Non async method found on Startable
• FMEDI0006 - Non void method found on Module
• FMEDI0007 - Register ServiceType not implemented by class