DependencyInjection.SourceGenerator.Microsoft 3.0.0-alpha7

DependencyInjection.SourceGenerator.Microsoft

Register services using attributes instead of registering in code.

Usage

Add the "Register" attribute to the class you want to register. The attribute takes a type and a lifetime. The type is the type you want to register and the lifetime is the lifetime of the service. The lifetime is optional and defaults to Transient.

This library supports the following dependency injection frameworks, follow the links for more information on how to use them:

• Microsoft.Extensions.DependencyInjection

To use this library you need to install the source generator package and the contacts package. The source generator package is a development dependency and will not be exposed as a dependency to consumers of your projects, while the contracts package contains the attributes and enums used to configure the generator.

Note: The DependencyInjection.SourceGenerator.Microsoft.Contracts package has been deprecated. Please refer to the Migration Guide for more information.

Microsoft.Extensions.DependencyInjection

• DependencyInjection.SourceGenerator.Microsoft

• DependencyInjection.SourceGenerator.Microsoft.Contracts

namespace RootNamespace.Services;

public interface IExampleService
{
	string GetExample();
}

public interface IAnotherService
{
	string GetAnother();
}

[Register(ServiceName = "ServiceName", Lifetime = Lifetime.Singleton)]
public class ExampleService : IExampleService
{
	public string GetExample()
	{
		return "Example";
	}
}

[Decorate]
public class KeyedService : IExampleService
{
	public string GetExample()
	{
		return "Keyed";
	}
}

[Decorator]
public class ServiceDecorator : IExampleService
{
	private readonly IExampleService _exampleService;

	public ServiceDecorator(IExampleService exampleService)
	{
		_exampleService = exampleService;
	}

	public string GetExample()
	{
		return _exampleService.GetExample();
	}
}

[Register<IAnotherService>]
public class MultipleInterfacesService : IExampleService, IAnotherService
{
	public string GetExample()
	{
		return "MultipleInterfaces";
	}

	public string GetAnother()
	{
		return "Another";
	}
}

Generates a class ServiceCollectionExtensions Assuming the project is named MyProject, the generated method will be named AddMyProject.

// <auto-generated/>
#pragma warning disable
#nullable enable
namespace RootNamespace;
using global::Microsoft.Extensions.DependencyInjection;

[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
public static class ServiceCollectionExtensions
{
    public static global::Microsoft.Extensions.DependencyInjection.IServiceCollection AddMyProject(this global::Microsoft.Extensions.DependencyInjection.IServiceCollection services)
    {
        services.AddKeyedSingleton<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ExampleService>("ServiceName");
        services.Decorate<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ServiceDecorator>();
        services.AddTransient<global::RootNamespace.Services.IAnotherService, global::RootNamespace.Services.MultipleInterfacesService>();
        return services;
    }
}

This can then be used like this:

var services = new ServiceCollection();
services.AddMyProject();

for AspNetCore web APIs:

public void ConfigureServices(IServiceCollection services)
{
	services.AddMyProject();
}

and for minimal APIs:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMyProject();

Register all services in the project

You can also register all services in an project by adding the RegisterAll attribute to the assembly. This will register all implementations of the specified type.

using DependencyInjection.SourceGenerator.Contracts.Attributes;

[assembly: RegisterAll<IExampleService>]

namespace RootNamespace.Services;

public interface IExampleService
{
	string GetExample();
}

public class ExampleService1 : IExampleService
{
	public string GetExample()
	{
		return "Example 1";
	}
}

public class ExampleService2 : IExampleService
{
	public string GetExample()
	{
		return "Example 2";
	}
}

this will generate the following code:

public static class ServiceCollectionExtensions
{
	public static global::Microsoft.Extensions.DependencyInjection.IServiceCollection AddTestProject(this global::Microsoft.Extensions.DependencyInjection.IServiceCollection services)
	{
		services.AddTransient<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ExampleService1>();
		services.AddTransient<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ExampleService2>();
		return services;
	}
}

Lifetime

The lifetime is an enum with the following values:

• Transient
• Scoped
• Singleton

IncludeFactory

The IncludeFactory property allows you to register a service as a Func<TService>, enabling you to inject a factory method into your constructors. This is useful when you need to create multiple instances of a service.

Example

namespace RootNamespace.Services;

public interface IExampleService
{
	string GetExample();
}

[Register(IncludeFactory = true)]
public class ExampleService : IExampleService
{
	public string GetExample()
	{
		return "Example";
	}
}

This will generate the following code:

public static class ServiceCollectionExtensions
{
	public static global::Microsoft.Extensions.DependencyInjection.IServiceCollection AddMyProject(this global::Microsoft.Extensions.DependencyInjection.IServiceCollection services)
	{
		services.AddTransient<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ExampleService>();
		services.AddTransient<global::System.Func<global::RootNamespace.Services.IExampleService>>(provider => () => provider.GetRequiredService<global::RootNamespace.Services.IExampleService>());
		return services;
	}
}

You can then inject Func<IExampleService> into your constructors:

public class Consumer
{
	private readonly Func<IExampleService> _exampleServiceFactory;

	public Consumer(Func<IExampleService> exampleServiceFactory)
	{
		_exampleServiceFactory = exampleServiceFactory;
	}

	public void UseService()
	{
		var serviceInstance = _exampleServiceFactory();
		// Use the service instance
	}
}

RegisterAll with IncludeFactory

You can also use IncludeFactory with the RegisterAll attribute to register all implementations of a specified type along with their factory methods.

using DependencyInjection.SourceGenerator.Contracts.Attributes;

[assembly: RegisterAll<IExampleService>(IncludeFactory = true)]

namespace RootNamespace.Services;

public interface IExampleService
{
	string GetExample();
}

public class ExampleService1 : IExampleService
{
	public string GetExample()
	{
		return "Example 1";
	}
}

public class ExampleService2 : IExampleService
{
	public string GetExample()
	{
		return "Example 2";
	}
}

This will generate the following code:

public static class ServiceCollectionExtensions
{
	public static global::Microsoft.Extensions.DependencyInjection.IServiceCollection AddMyProject(this global::Microsoft.Extensions.DependencyInjection.IServiceCollection services)
	{
		services.AddTransient<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ExampleService1>();
		services.AddTransient<global::RootNamespace.Services.IExampleService, global::RootNamespace.Services.ExampleService2>();
		services.AddTransient<global::System.Func<global::RootNamespace.Services.IExampleService>>(provider => () => provider.GetRequiredService<global::RootNamespace.Services.IExampleService>());
		return services;
	}
}

You can then inject Func<IExampleService> into your constructors as shown in the previous example.