Parameter injection for injected delegate

[BigSquareHasNoEdge]

When injecting delegates, I use the below pattern:

services.AddTransient<Func<string, IMyService>>(sp => key =>
{
    var dependency = sp.GetRequiredService<IDependency>();
    return new MyService(dependency, key);
});

Is there another way to require a service like minimal api?

app.MapGet("", (Idependency depedency) => {  // ... } );

services.AddTransient<Func<string, IMyService>>( (string key, IDependency dependency) =>
{
    return new MyService(dependency, key);
});

[KalleOlaviNiemitalo]

I don't think there's anything built-in. OptionsBuilder<TOptions>.Configure<TDep>(Action<TOptions, TDep>) (docs, source) is a bit similar, though.

I was thinking of something like this (untested):

public static IServiceCollection AddTransientFunc<TArg, TDep, TService>(
    this IServiceCollection services,
    Func<TArg, TDep, TService> factory)
    where TDep : class
{
    return services.AddTransient<Func<TArg, TService>>(
        (IServiceProvider sp) => TArg arg => factory(sp.GetRequiredService<TDep>(), arg));
}

services.AddTransientFunc<string, IDependency, IMyService>( (string key, IDependency dependency) =>
{
    return new MyService(dependency, key);
});

But this has a problem: if you add more overloads with different numbers of arguments and dependencies, then how do you distinguish 2 arguments + 2 dependencies from 1 argument + 3 dependencies?

Your proposed usage, where Func<string, IMyService> is a type argument, would not have that ambiguity; but I don't see how that could detect at compile time that the factory delegate has enough parameters and returns something that can be assigned to IMyService. An analyzer could check that, though.

If this is only for creating new instances, and the constructor is public, then perhaps you can use ActivatorUtilities.CreateFactory (docs) so that the dependencies don't even need to be listed in the call. Untested:

public static IServiceCollection AddTransientFunc<TArg, TService, TImplementation>(
    this IServiceCollection services)
    where TImplementation : TService
{
    // Use the same ObjectFactory instance with every IServiceProvider.
    ObjectFactory factory = ActivatorUtilities.CreateFactory(typeof(TImplementation), new[] { typeof(TArg) });

    return services.AddTransient<Func<TArg, TService>>(
        (IServiceProvider sp) => (TArg arg) => (TService)factory.CreateInstance(sp, new object[] { arg }));
}

services.AddTransientFunc<string, IMyService, MyService>();

dotnet/runtime#111228 would simplify that a bit.