Futurum.Microsoft.Extensions.DependencyInjection 1.0.11

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 modules, startables and registrations, using best practices
• Integration with Futurum.Core

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.

The attributes have been created is a discoverable way. They take the following form:

• RegisterAs{Lifetime}
• RegisterAs{Lifetime}.AsSelf
• RegisterAs{Lifetime}.As{ServiceType}
• RegisterAs{Lifetime}.AsImplementedInterfaces
• RegisterAs{Lifetime}.AsImplementedInterfacesAndSelf
• RegisterAs{Lifetime}.AsOpenGeneric

There are 3 lifetimes available:

• Singleton
• Scoped
• Transient

RegisterAs{Lifetime} attribute

This will register the class against the 1 interface the class implements, for the specified lifetime.

e.g. This will register Service against IService with a Scoped lifetime.

[RegisterAsScoped]
public class Service : IService
{
}

RegisterAs{Lifetime}.AsSelf attribute

This will register the class against itself, for the specified lifetime.

e.g. This will register Service against Service with a Scoped lifetime.

[RegisterAsScoped.AsSelf]
public class Service
{
}

RegisterAs{Lifetime}.As{ServiceType} attribute

This will register the class against the specified interface, for the specified lifetime.

e.g. This will register Service against IService1 with a Scoped lifetime.

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

RegisterAs{Lifetime}.AsImplementedInterfaces attribute

This will register the class against all the interfaces it implements directly, for the specified lifetime.

e.g. This will register Service against IService1 and IService2 with a Scoped lifetime.

[RegisterAsScoped.AsImplementedInterfaces]
public class Service : IService1, IService2
{
}

RegisterAs{Lifetime}.AsImplementedInterfacesAndSelf attribute

This will register the class against all the interfaces it implements directly and itself, for the specified lifetime.

e.g. This will register Service against Service, IService1 and IService2 with a Scoped lifetime.

[RegisterAsScoped.AsImplementedInterfacesAndSelf]
public class Service : IService1, IService2
{
}

RegisterAs{Lifetime}.AsOpenGeneric attribute

This will register the an open generic class against an open generic interface, for the specified lifetime.

e.g. This will register Service<T> against IService<T> with a Scoped lifetime.

[RegisterAsScoped.AsOpenGeneric(ImplementationType = typeof(Service<>), ServiceType = typeof(IService<>))]
public class Service<T> : IService<T>
{
}

DuplicateRegistrationStrategy

You can also specify how to handle duplicate registrations.

• 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
{
}

TryGetService

Try to get the service object of the specified type.

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

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
• FMEDI0008 - Registration, must only have 1 interface
• FMEDI1000 - Registration information