DI и зависимость в виде строки

private static IConfiguration GetConfiguration()
{
    IConfigurationBuilder builder = new ConfigurationBuilder()
        .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
        .AddJsonFile("appsettings.json");
 
    return builder.Build();
}

using DALibrary.DataAccess;
using DALibrary.Interfaces;
 
using Microsoft.Extensions.Configuration;
 
namespace DALibrary
{
    public class MainDA : IMainDA
    {
        private readonly IConfiguration _configuration;
        private readonly string _connectionString;
 
        public MainDA(IConfiguration configuration)
        {
            _configuration = configuration;
 
#if DEBUG
            _connectionString = _configuration.GetConnectionString("SQLConnectDebug");
#elif RELEASE || RELEASEALFA
            _connectionString = _configuration.GetConnectionString("SQLConnect");
#endif
        }
    }
}

public interface IOptions<out TOptions> where TOptions : class

public static class ConfigurationBuilderExtension
{
    public static IServiceCollection AddCustomConfiguration(
        this IServiceCollection serviceCollection,
        string[] args)
    {
        var configuration = CreateConfiguration(args);
        serviceCollection.AddSingleton(configuration);
 
        var appConfig = configuration.Get<AppConfig>() as IAppConfig;
        serviceCollection.AddSingleton(appConfig!);
        serviceCollection.AddSingleton(appConfig.ConnectionStrings);
 
        return serviceCollection;
    }
 
    public static IConfiguration CreateConfiguration(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json")
            .AddJsonFile("appsettings.Development.json", true)
            .AddCommandLine(args)
            .Build();
        return configuration;
    }
}

public interface IAppConfig
{
    IConnectionStringsConfig ConnectionStrings { get; }
}

public class AppConfig : IAppConfig
{
    public ConnectionStringsConfig ConnectionStrings { get; } = new ConnectionStringsConfig();
 
    IConnectionStringsConfig IAppConfig.ConnectionStrings => ConnectionStrings;
}

public interface IConnectionStringsConfig
{
    string Database { get; }
}

public class ConnectionStringsConfig : IConnectionStringsConfig
{
    public string Database { get; init; }
}

public class AppDbContext : DbContext
{
    private readonly IConnectionStringsConfig _connectionStringsConfig;
 
    public AppDbContext(
        DbContextOptions<AppDbContext> options,
        IConnectionStringsConfig connectionStringsConfig)
        : base(options)
    {
        _connectionStringsConfig = connectionStringsConfig;
    }
    ...

internal class Program
{
    private static void Main(string[] args)
    {
        var serviceProvider = new ServiceCollection()
            .AddCustomConfiguration(args)
            .AddCustomLogger()
            .AddAppDbContext()
            .AddScoped<App>()
            .BuildServiceProvider();
 
        using (var scope = serviceProvider.CreateScope())
        {
            var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            dbContext.Database.Migrate();
        }
 
        using (var app = serviceProvider.GetService<App>())
        {
            app.Run();
        }
    }
}

public class App : IDisposable
{
    private readonly IAppConfig _appConfig;
    private readonly AppDbContext _dbContext;
    private readonly ILogger<App> _logger;
 
    public App(
        ILogger<App> logger,
        IAppConfig appConfig,
        AppDbContext dbContext)
    {
        _logger = logger;
        _appConfig = appConfig;
        _dbContext = dbContext;
    }
 
    public void Dispose()
    {
        _webDriver.Quit();
    }
 
    public void Run()
    {
        ...

_connectionString = _configuration.GetConnectionString("SQLConnectDebug");

private async void Window_Loaded(object sender, RoutedEventArgs e)
{
#if DEBUG
    string updatePath = App.Current.Configuration["AppSettings:UpdatesDebugURI"];
#elif RELEASEALFA
    string updatePath = App.Current.Configuration["AppSettings:UpdatesAlfaURI"];
#else
    string updatePath = App.Current.Configuration["AppSettings:UpdatesURI"];
#endif
    string changeLogFile = Path.Combine(updatePath, "ChangeLog.txt");
 
    txtCurrent.Text = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion.Trim();
    txtNew.Text = _updateInfo.Version;
 
    try
    {
        using (StreamReader reader = new StreamReader(changeLogFile))
            txtChangeLog.Text = await reader.ReadToEndAsync();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Ошибка", MessageBoxButton.OK, MessageBoxImage.Error);
    }
}

TransientFaultHandlingOptions options = new();
builder.Configuration.GetSection(nameof(TransientFaultHandlingOptions))
    .Bind(options);
Console.WriteLine($"TransientFaultHandlingOptions.Enabled={options.Enabled}");

#if DEBUG
    string updatePath = App.Current.Configuration["AppSettings:UpdatesDebugURI"];
#elif RELEASEALFA
    string updatePath = App.Current.Configuration["AppSettings:UpdatesAlfaURI"];
#else
    string updatePath = App.Current.Configuration["AppSettings:UpdatesURI"];
#endif

    public static IConfiguration CreateConfiguration(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json")
            .AddJsonFile("appsettings.Development.json", true)
            .AddCommandLine(args)
            .Build();
        return configuration;
    }

// Это гуд
public MyService(Settings settings) {
   _settings = settings;
}
 
// Это не гуд - зачем в доменной логике ссылка на сборку с типом IOptions<>???
public MySerfvice(IOptions<Settings> options) {
   _settings = options.Value;
}

        serviceCollection.AddSingleton<IConnectionString, DBConfig>(appConfig);
        serviceCollection.AddSingleton<IDBTimeout, DBConfig>(appConfig);