Փոխեք կախվածության լուծաչափը միայն կոնկրետ շրջանակի համար

Ընդհանրապես, հավելվածի գործարկման ընթացքում գրանցված օբյեկտների գրաֆիկների կառուցվածքը փոխելը լավ գաղափար չէ: Սա ոչ միայն դժվար է հասնել բեռնարկղերի մեծ մասի հետ, այլև հակված է նուրբ խնդիրների, որոնք դժվար է հայտնաբերել: Հետևաբար, ես առաջարկում եմ ձեր դիզայնի մի փոքր փոփոխություն, որը շրջանցում է ձեր առջև ծառացած խնդիրը:

Կախվածությունն ամբողջությամբ փոխելու փորձի փոխարեն, փոխարենը նախապես համալրեք գոյություն ունեցող կախվածությունը այլ շղթայի վրա բեռնված տվյալների հետ:

Դա կարելի է անել՝ օգտագործելով հետևյալ վերացական/իրականացման զույգը.

public interface IConfigurationProvider
{
    Task<Configuration> GetConfigurationAsync();
}

public sealed class DatabaseConfigurationProvider : IConfigurationProvider
{
    private readonly DbContext _dbContext;

    public DatabaseConfigurationProvider(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public Configuration Configuration { get; set; }

    public async Task<Configuration> GetConfigurationAsync()
    {
         if (Configuration is null)
         {
             await // read configurations
         }

         return Configuration;
    }
}

Ուշադրություն դարձրեք DatabaseConfigurationProvider-ի կատարման հանրային Configurationին, որը ոչ IConfigurationProvider ինտերֆեյսի վրա:

Սա է իմ ներկայացրած լուծման առանցքը: Թույլատրել ձեր Կոմպոզիցիայի արմատը արժեքը սահմանելու համար՝ առանց ձեր հավելվածի աբստրակցիաները աղտոտելու, քանի որ հավելվածի կոդը կարիք չունի վերագրանցելու Configuration օբյեկտը. միայն Composition Root-ին է պետք:

Այս աբստրակցիա/իրականացում զույգով ֆոնային ծառայությունը կարող է այսպիսի տեսք ունենալ.

class MyBackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory; // set in ctor

    public Task DoStuff()
    {
        var itens = GetItens();

        // Create a scope for the root operation.
        using (var scope = _scopeFactory.CreateScope())
        {
            // Resolve the IConfigurationProvider first to load
            // the configuration once eagerly.
            var provider = scope.ServiceProvider
                .GetRequiredService<IConfigurationProvider>();

            var configuration = await provider.GetConfigurationAsync();

            Parallel.ForEach(itens, (item) => Process(configuration, item));
        }
    }

    private void Process(Configuration configuration, Item item)
    {
        // Create a new scope per thread
        using (var scope = _scopeFactory.CreateScope())
        {
            // Request the configuration implementation that allows
            // setting the configuration.
            var provider = scope.ServiceProvider
                .GetRequiredService<DatabaseConfigurationProvider>();

            // Set the configuration object for the duration of the scope
            provider.Configuration = configuration;

            // Resolve an object graph that depends on IConfigurationProvider.
            var service = scope.ServiceProvider.GetRequiredService<ItemService>();

            service.Process(item);
        }    
    }
}

Դա անելու համար ձեզ հարկավոր է հետևյալ DI կոնֆիգուրացիան.

services.AddScoped<DatabaseConfigurationProvider>();
services.AddScoped<IConfigurationProvider>(
    p => p.GetRequiredService<DatabaseConfigurationProvider>());

Այս նախորդ կոնֆիգուրացիան գրանցում է DatabaseConfigurationProvider երկու անգամ՝ մեկ անգամ իր կոնկրետ տեսակի համար, մեկ անգամ՝ իր ինտերֆեյսի համար: Ինտերֆեյսի գրանցումը փոխանցում է զանգը և ուղղակիորեն լուծում կոնկրետ տեսակը: Սա հատուկ «հնարք» է, որը դուք պետք է կիրառեք MS.DI կոնտեյների հետ աշխատելիս՝ կանխելու երկու առանձին DatabaseConfigurationProvider օրինակներ մեկ շրջանակի ներսում: Դա լիովին կտապալի այս իրականացման ճիշտությունը:

Ստեղծեք ինտերֆեյս, որը ընդլայնում է IDependency-ը և կկիրառվի միայն ավելի արագ իրականացման համար, որը դուք պետք է պահանջեք, օրինակ՝ IFasterDependency: Այնուհետև գրանցվեք IFasterDependency-ի համար: Այսպիսով, ձեր ավելի արագ դասը դեռևս IDependency օբյեկտ է, և դուք չեք խաթարի գոյություն ունեցող ծածկագիրը, բայց այժմ կարող եք ազատորեն պահանջել այն:

public interface IDependency
{
    // Actual, useful interface definition
}

public interface IFasterDependency : IDependency
{
    // You don't actually have to define anything here
}

public class SlowClass : IDependency
{

}

// FasterClass is now a IDependencyObject, but has its own interface 
// so you can register it in your dependency injection
public class FasterClass : IFasterDependency
{

}