MintPlayer.SourceGenerators 10.21.0

Dependency-Injection generators

This library contains source-generators to simplify dependency-injection in your application

Getting started

You need to install both MintPlayer.SourceGenerators and MintPlayer.SourceGenerators.Attributes packages in your project.

Service-registration

Place this class in your abstractions library:

public interface ICustomerService { }

Place this class in your implementation library:

[Register(typeof(ICustomerService), ServiceLifetime.Scoped)]
internal class CustomerService : ICustomerService { }

Now you get an extension method generated for you, which will register all services for you:

var services = new ServiceCollection()
    .AddMyCompanyServices()  // Method name derived from assembly name
    .BuildServiceProvider();

Method Name Resolution

The generated method name follows this precedence:

1. Explicit hint on [Register] attribute (e.g., "CoreServices") → AddCoreServices()
2. Assembly-level configuration via [assembly: ServiceRegistrationConfiguration]
3. Assembly name (default) - sanitized and prefixed with "Add" (e.g., MyCompany.Services → AddMyCompanyServices())

Assembly-Level Configuration

You can configure the default method name and accessibility at the assembly level:

using MintPlayer.SourceGenerators.Attributes;

[assembly: ServiceRegistrationConfiguration(
    DefaultMethodName = "MyServices",
    DefaultAccessibility = EGeneratedAccessibility.Internal
)]

This will generate AddMyServices() as an internal method for all services without an explicit method hint.

Explicit Method Hints

You can still specify a method hint on individual registrations to group services:

[Register(typeof(ICustomerService), ServiceLifetime.Scoped, "DemoServices")]
internal class CustomerService : ICustomerService { }

[Register(typeof(IProductService), ServiceLifetime.Scoped, "DemoServices")]
internal class ProductService : IProductService { }

This generates:

var services = new ServiceCollection()
    .AddDemoServices()  // Contains CustomerService and ProductService
    .BuildServiceProvider();

Registering Third-Party Types

You can register types from NuGet packages or external libraries at the assembly level:

using MintPlayer.SourceGenerators.Attributes;

// Self-registration (implementation = service type)
[assembly: Register(typeof(ThirdPartyClass), ServiceLifetime.Singleton)]

// Interface + implementation registration
[assembly: Register(typeof(IExternalService), typeof(ExternalServiceImpl), ServiceLifetime.Scoped)]

This generates:

public static IServiceCollection AddMyAssembly(this IServiceCollection services)
{
    return services
        .AddSingleton<ThirdPartyClass>()
        .AddScoped<IExternalService, ExternalServiceImpl>();
}

Registration Patterns Summary

Registration Diagnostics

Dependency Injection

Inject a registered service anywhere:

public partial class CustomerController {
    [Inject] private readonly ICustomerService customerService;
}

The source-generator will generate the constructor for you. It supports DI when using inheritance too.

Post-Construction Initialization

If you need to run initialization logic after all dependencies are injected, use the [PostConstruct] attribute:

public partial class CustomerController {
    [Inject] private readonly ICustomerService customerService;
    [Inject] private readonly ILogger<CustomerController> logger;

    [PostConstruct]
    private void OnInitialized()
    {
        logger.LogInformation("CustomerController initialized with {Service}", customerService.GetType().Name);
    }
}

The [PostConstruct] method will be called automatically at the end of the generated constructor, after all field assignments are complete.

Rules:

• The method must be parameterless
• Only one [PostConstruct] method is allowed per class
• The method cannot be static
• Each class in an inheritance hierarchy can have its own [PostConstruct] method (base class method runs first)
• Nested classes each have their own scope for [PostConstruct]

Diagnostics: | Rule ID | Severity | Description | |---------|----------|-------------| | INJECT001 | Error | PostConstruct method must be parameterless | | INJECT002 | Error | Only one PostConstruct method allowed per class | | INJECT003 | Error | PostConstruct method cannot be static | | INJECT004 | Warning | PostConstruct method in class without [Inject] members |

Configuration Binding

Simplify reading configuration values with [Config], [ConnectionString], and [Options] attributes:

public partial class DatabaseService
{
    // Required config values (throws if missing)
    [Config("Database:Type")]
    private readonly DatabaseType databaseType;

    // Optional with default value
    [Config("Database:MaxRetries", DefaultValue = 3)]
    private readonly int maxRetries;

    // TimeSpan parsing
    [Config("Database:Timeout")]
    private readonly TimeSpan timeout;

    // Connection string
    [ConnectionString("DefaultConnection")]
    private readonly string connectionString;

    // Nullable = optional (won't throw if missing)
    [ConnectionString("OptionalDb")]
    private readonly string? optionalConnection;
}

IOptions Pattern

public partial class EmailService
{
    [Options("Email")]
    private readonly IOptions<EmailSettings> emailOptions;

    [Options("Customer")]
    private readonly IOptionsSnapshot<CustomerConfig> customerOptions;

    [Options("Features")]
    private readonly IOptionsMonitor<FeatureFlags> featureFlags;
}

IConfiguration Deduplication

When you inject IConfiguration explicitly, the generator reuses it:

public partial class ConfigAwareService
{
    [Inject] private readonly IConfiguration configuration;

    [Config("App:Name")]
    private readonly string appName;  // Uses 'configuration' field

    public string GetCustomValue(string key) => configuration[key];
}

Supported Types

Configuration Diagnostics

Interface Implementation

There's also an analyzer that will check if all public class members are known on the implemented interface. The analyzer provides a code-fix to add the missing members.

public interface ICustomerService { }

[Register(typeof(ICustomerService), ServiceLifetime.Scoped)]
internal class CustomerService : ICustomerService {
    public Task<Customer> GetCustomer(int id) => throw new NotImplementedException();
}

This also works when the interface resides in an abstractions-library and the class resides in an implementation-library. Which is why this analyzer is so powerful.