Futurum.Microsoft.Extensions.DependencyInjection 2.0.0

Futurum.Microsoft.Extensions.DependencyInjection

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

• 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 registrations, modules and startables, using best practices
• Tested solution

Attribute based registration

You can 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

NOTE - There is a Roslyn Analyser that will provide information on exactly what registration is taking place. Just hover over the class.

RegisterAs{Lifetime} attribute

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

NOTE - There is a Roslyn Analyser that will warn you if you use this attribute and the class does not implement exactly 1 interface.

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

[RegisterAsSingleton]
public class Service : IService
{
}

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

[RegisterAsScoped]
public class Service : IService
{
}

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

[RegisterAsTransient]
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 Singleton lifetime.

[RegisterAsSingleton.AsSelf]
public class Service
{
}

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

[RegisterAsScoped.AsSelf]
public class Service
{
}

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

[RegisterAsTransient.AsSelf]
public class Service
{
}

RegisterAs{Lifetime}.As{ServiceType} attribute

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

NOTE - There is a Roslyn Analyser that will warn you if you use the class does not implement the specified interface.

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

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

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

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

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

[RegisterAsTransient.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 Singleton lifetime.

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

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

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

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

[RegisterAsTransient.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 Singleton lifetime.

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

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

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

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

[RegisterAsTransient.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 Singleton lifetime.

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

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

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

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

DuplicateRegistrationStrategy

All registration attributes allow you to 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

Try

NOTE - This is the default behaviour.

e.g. This will register Service against IService with a Singleton lifetime via Try.

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

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

[RegisterAsScoped(DuplicateRegistrationStrategy = DuplicateRegistrationStrategy.Try)]
public class Service : IService
{
}

e.g. This will register Service against IService with a Transient lifetime via Try.

[RegisterAsTransient(DuplicateRegistrationStrategy = DuplicateRegistrationStrategy.Try)]
public class Service : IService
{
}

Replace

e.g. This will register Service against IService with a Singleton lifetime via Replace.

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

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

[RegisterAsScoped(DuplicateRegistrationStrategy = DuplicateRegistrationStrategy.Replace)]
public class Service : IService
{
}

e.g. This will register Service against IService with a Transient lifetime via Replace.

[RegisterAsTransient(DuplicateRegistrationStrategy = DuplicateRegistrationStrategy.Replace)]
public class Service : IService
{
}

Add

e.g. This will register Service against IService with a Singleton lifetime via Add.

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

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

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

e.g. This will register Service against IService with a Transient lifetime via Add.

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

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

If you use the IModule interface, you must manually register the module using the 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.

NOTE - The main difference is that using IStartable interface allows you to inject dependencies into the startable, whereas the attribute based approach does not.

IStartable interface and AddStartable extension method

If you use the IStartable interface, you must manually register the startable using the 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 StartAsync()
    {
        // Do something
    }
}

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

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