Implement "WhenInjectInto" like others IoC - Feature request

[avechuche]

Hello, I do not know if there is a functionality for this (I think not because I did not find anything similar on the internet) but I think it would be useful for Autofac

Problem Statement

I want to use an interface (MyInterface) in 2 or more implementations but I want one of those implementations to inject that interface (MyInterface) with a particular implementation. It looks like a tongue twister

Desired Solution

public class MyRepositoryProxyCache : IMyRepository
{
    private readonly ICacheProvider<MyClass> _cacheProvider;

    private readonly IMyRepository _myRepository;

    public MyRepositoryProxyCache(ICacheProvider<MyClass> cacheProvider, IMyRepository myRepository)
    {
        _cacheProvider = cacheProvider;
        _myRepository = myRepository;
    }

    public Task<MyClass?> GetByIDAsync(int id)
    {
        return _cacheProvider.GetOrSetAsync("CACHE_KEY", () => _myRepository.GetByIDAsync(id));
    }
}

public class MyRepository : IMyRepository
{
    public MyRepository() { }

    public Task<MyClass?> GetByIDAsync(int id)
    {
        return CUSTOM_DB_CALL;
    }
}

public interface IMyRepository
{
    Task<MyClass?> GetByIDAsync(int id);
}

OtherIoC.Export<MyRepository>().As<IMyRepository>().When.InjectedInto<MyRepositoryProxyCache>();
OtherIoC.Export<MyRepositoryProxyCache>().As<IMyRepository>();

[tillig]

There are a lot of other ways to do these sorts of things in Autofac.

• Lambdas - you can register a lambda expression for the target (MyRepositoryProxyCache) and resolve the MyRepository directly into that rather than relying solely on fluent builder syntax.
• Named/keyed services - you can register a keyed service for the backing repository and either use a lambda or constructor filtering attributes on the proxy.

I don't think we'll be adding this feature because there are other ways to already do the same thing. We also already have #1203 for specifically supporting a proxy-oriented relationship.

[avechuche]

Thanks for the help, I already have a simple solution. I share it for the next generations.

private static void WhenUseInto<T, TProxy, TImplementation>(ContainerBuilder containerBuilder) where T : TImplementation where TProxy : TImplementation where TImplementation : notnull
{
    containerBuilder
        .RegisterType<T>()
        .Named<TImplementation>(typeof(TImplementation).Name);
    containerBuilder
        .RegisterType<TProxy>()
        .WithParameter(ResolvedParameter.ForNamed<TImplementation>(typeof(TImplementation).Name))
        .As<TImplementation>();
}

WhenUseInto<MyRepository, MyRepositoryProxyCache, IMyRepository>(containerBuilder);