Override dependency in specific service dependency tree

[Ditriksss]

Hello,

I need to change implementation of interface in old project to use new approach. The problem is that I want to change every occurence of this interface only when specific service is used.

So in the following code I want to manipulate IRepository interface.
And Service which represent the functionality I want to use.
We have two main classes which can reflected input to this functionality

• MainServiceA - which represents old way to invoke Service so here we need to leave existing implementation of IRepository'interface
• MainServiceB - which represent new way to invoke Service so we want to use new implementation of IRepository interface.

My question is how can I do that. To override implementation of IRepository in whole dependency tree only for one specific service.

public interface IRepository
{

}

public class RepositoryA : IRepository
{

}

public class RepositoryB : IRepository
{

}

public class Service
{
    public Service(IRepository repository)
    {

    }
}

public class MainServiceA
{
    public MainServiceA(Service service)
    {

    }
}

public class MainServiceB
{
    public MainServiceB(Service service)
    {

    }
}

[Fact]
public void Test()
{
    IServiceProvider serviceProvider = null;

    var host = Host.CreateDefaultBuilder()
        .ConfigureServices((hostBuilder, services) =>
        {
            serviceProvider = new Container(rules => rules
                .With(FactoryMethod.ConstructorWithResolvableArguments))
            .WithDependencyInjectionAdapter(services)
            .ConfigureServiceProvider<CompositionRoot>();
        })
        .Build();

    var withRepositoryA = serviceProvider.GetService<MainServiceA>();
    var withRepositoryB = serviceProvider.GetService<MainServiceB>();
}

public class CompositionRoot
{
    public CompositionRoot(IRegistrator registrator)
    {
        registrator.Register<IRepository, RepositoryA>();
        registrator.Register<IRepository, RepositoryB>();

        registrator.Register<Service>();

        registrator.Register<MainServiceA>(); // here I want 'RepositoryA' to be injected where applicable
        registrator.Register<MainServiceB>(); // here I want 'RepositoryB' to be injected where applicable
    }
}

[dadhi]

@Ditriksss Hi there.

You may use either registration Condition or the ScopedTo reuse.
Condition is OK if you don't want to introduce any additional lifecycle management.

registrator.Register<IRepository, RepositoryA>(
    setup: Setup.With(condition: req => req.Parent.Any(p => p.ServiceType == typeof(MainServiceA))));

registrator.Register<IRepository, RepositoryB>(
    setup: Setup.With(condition: req => req.Parent.Any(p => p.ServiceType == typeof(MainServiceB))));