როგორ ხორციელდება ერთპროცესიანი კონტექსტის Scoped-ის ფარგლებში ერთდროულად შესრულებული რამდენიმე მოთხოვნის დამუშავება?

ASP.NET Core-ში, ერთპროცესიან კონტექსტში, Scoped დამოკიდებულებებისათვის, თითოეული HTTP მოთხოვნა იღებს თავის საკუთრებას Scoped სერვისების ობიექტის სახით. როდესაც ერთდროულად რამდენიმე მოთხოვნა ხორციელდება ერთ პროცესში, თითო მოთხოვნისთვის ქმნიან ცალკეულ Scoped კონტეინერს, რომელიც იზოლირებულია სხვა კონტეინერებისგან.

ეს მიღწეულია DI კონტეინერის მექანიზმის საშუალებით, რომელიც ქმნის ახალ scope-ს მოთხოვნის დასაწყისში და ანადგურებს მას დასრულებისას. ასე, even ერთპროცესიანი აპლიკაციაშიც, თითოეული მოთხოვნა მუშაობს თავისი Scoped სერვისების ნაკრებით, რაც თავიდან აცილებს მონაცემთა კონფლიქტებს მოთხოვნებს შორის.

დაახლოებით ასე:

// Startup.cs-ში
services.AddScoped<IMyService, MyService>();

// ყოველი მოთხოვნის დამუშავებისას, ქმნიან ახალ scope-ს
app.Use(async (context, next) => {
    using (var scope = app.ApplicationServices.CreateScope())
    {
        var myService = scope.ServiceProvider.GetRequiredService<IMyService>();
        // myService-ის გამოყენება მოთხოვნის ფარგლებში
        await next();
    }
});

სინამდვილეში, ASP.NET Core ავტომატურად ქმნის scope-ს თითოეულ HTTP მოთხოვნაზე, ამიტომ შემქმნელს ჩვეულებრივ არ სჭირდება მას ხელით შექმნა.