AutoInjectRegister 1.10.0

AutoInjectRegister

Auto register classes and interfaces for dependency injection. Add the auto inject attribute to the top of any class file to be marked for auto injection helping you identify the scope of each class just by looking at the class file.

Adding Auto Inject to DI

Add to your program or startup file

 builder.Services.AutoInjectRegisterServices();

Alternatively, if you would like to be more specific with which assembly you would like added, add a type from an assembly you want added. This will only register files in that assembly, so be aware that it won't take everything plus that assembly. It will only take the assembly specified.

  builder.Services.AutoInjectRegisterServices(typeof(IDbReader), typeof(ICache), typeof(IProxy));

If you would like to use exclude specific types you can pass in an options class into the register services method. You can use the InclusionType enum to specify you want to ONLY use the types passed into types to scan.

public class AutoInjectorOptions
{
    public IEnumerable<Type> TypesToScan { get; set; } = [];
    public IEnumerable<Type> TypesToExclude { get; set; } = [];
    public InclusionType InclusionType { get; set; } = InclusionType.AllAutoAttributes;
    public ServiceLifetime DefaultLifetime { get; set; } = ServiceLifetime.Transient;
}

You can then pass the options in as function.

builder.Services.AutoInjectRegisterServices(options =>
    {
        options.TypesToScan = [typeof(MyClass), typeof(YourClass)];
        options.InclusionType = InclusionType.TypesToScanOnly;
    });

Or create the object yourself.

builder.Services.AutoInjectRegisterServices(
    new AutoInjectorOptions 
    {
        TypesToScan = [typeof(MyClass), typeof(YourClass)],
        TypesToExclude = [typeof(ExclusionClass), typeof(ExclusionClass)] 
    }
);

Register your classes

You can register your classes in two different ways. You can add the auto inject attribute to your classes or use the inclusion type NoAttributeRegister.

No attribute register

If you would like to leave most of the heavy lifting to the package, simply set or your inclusion type to NoAttributeRegister. It should pick up all your classes for you and register them to the default lifetime (which you can update aswell). It will also make sure if you have attributes set to use them first before defaulting.

 builder.Services.AutoInjectRegisterServices(options => { options.InclusionType = InclusionType.NoAttributeRegister; });

Attributes

There are two different ways of using attributes. Parameterless or the base attribute.

No paramter attribute

You will have access to seven attributes, including the base.

[AutoInjectsSingleton]
[AutoInjectScoped]
[AutoInjectTransient]

[AutoInjectTryAddSingleton]
[AutoInjectTryAddScoped]
[AutoInjectTryAddTransient]

[AutoInject] // Defaults to transient and add

You can implement them like so.

[AutoInjectTransient]
internal class ExampleTransientClass : IExampleTransientInterface
{
    ...
}

[AutoInjectTryAddScoped]
internal class ExampleScopedClass : IExampleScopedInterface
{
    ...
}
    
[AutoInject]
internal class SingletonClassOnly
{
    ...
}

Whilst you can implement multiple attributes of different lifetimes, avoid doing so as it could cause confusion of the lifetime of the service. If a class does have multiple attributes it will be registered in the order of the enum, ServiceLifetime.

[AutoInjectScoped]
[AutoInjectsSingleton] // This should be what it is registered as
[AutoInjectTransient]
internal class ExampleMultipleServiceClass : IExampleMultipleServiceInterface
{
    ...
}

Base attribute with a parameter

You can use the base class, the benefit being you will get compiler issues if you use the attribute multiple times.

[AutoInject(ServiceLifetime.Scoped, AddType.TryAdd)]
internal class ScopedTestClass : ScopedTestInterface
{
    ...
}

// class only
[AutoInject] // Defaults to transient and add
internal class TransientTestClassOnly
{
    ...
}

Using TryAddService instead of AddService

In the case you want to try add the service instead of add, you can use the addtype enum as a parameter for the base attribute.

[AutoInject(ServiceLifetime.Scoped, AddType.TryAdd)]
internal class ScopedTestClass : ScopedTestInterface
{
    ...
}

Enums Types Available

Service lifetimes

This is just from the microsoft enum, ServiceLifetime.

Transient,
Scoped,
Singleton

AddTypes

Add,
TryAdd

InclusionTypes

AllAutoAttributes,
TypesToScanOnly,
NoAttributeRegister