interface IService;

interface IService1: IService;
interface IService2: IService;

interface IRepository;

class SettingsItem
{
   .... service settings
   .... connectionString
}

class ServiceSettings
{
   SettingsItem Service1Settings
   SettingsItem Service2Settings
}

class Repository: IRepository
{   
   ctor Repository (string connectionString)
}

class ServiceBase: IService
{
  ctor Service1 (SettingsItem, IRepository)
}

class Service1: ServiceBase, IService1
{
}

class Service2: ServiceBase, IService2
{
}

 var service1 =  scope.Resolve<IService1>();
 var service2 =  scope.Resolve<IService2>();

builder.RegisterType<Service1>()
       .As<IService>()
       .WithParameter(
         new ResolvedParameter(   // тут как-то отрезолвить репозиторий с нужными сеттингами
           (pi, ctx) => ....,                 
           (pi, ctx) => ...));

IRepository1: IRepository
IRepository2: IRepository

Service1: IService1
{
   Service1 (IRepository1)   
}

public enum ServiceType (service1, service2)

...
RegisterRepository (ServiceType.service1);
RegisterRepository (ServiceType.service2);
....

public RegisterRepository (builder, ServiceType serviceType)
{
builder.RegisterType<MyRepository>()
                .WithParameter((pinfo, ctx) =>
                {
                    return
                    pinfo.Name == "connectionString" &&
                    pinfo.ParameterType == typeof(string);
                },
                (pinfo, ctx) =>
                {
                    var settings = ctx.ResolveKeyed<IMySettings>(serviceType);
                    return settings.Db.ConnectionString;
                })
                .Keyed<IMyRepository>(serviceType);
}