Extension .NET Core IServiceScopeFactory.CreateScope () et IServiceProvider.CreateScope ()

Question

D'après ce que je sais, lors de l'utilisation de l'injection de dépendance intégrée, une application de console .NET Core vous demandera de créer et de gérer toutes les étendues vous-même, tandis qu'une application ASP.NET Core créera et gérera par défaut la portée HttpRequest. via middleware (s) défini (s).

Avec ASP.NET Core, vous pouvez éventuellement créer et gérer vos propres étendues en appelant CreateScope() lorsque vous avez besoin de services résidant en dehors d'un HttpRequest.

Il est clair que l'appel de IServiceScopeFactory.CreateScope() créera un nouveau IServiceScope à chaque fois; Cependant, l'appel de la méthode d'extension IServiceProvider.CreateScope() crée-t-il également un nouveau IServiceScope à chaque fois?

Existe-t-il une différence significative entre les moyens suivants pour créer une étendue dans les applications de console ASP.NET Core et .NET Core:

public class Foo()
{
    public Foo(IServiceProvider serviceProvider)
    {
        using(var scope = serviceProvider.CreateScope())
        {   
            scope.ServiceProvider.GetServices<>();           
        }
    }
}

et

public class Bar()
{
    public Bar(IServiceScopeFactory scopeFactory)
    {
        using(var scope = scopeFactory.CreateScope())
        {   
            scope.ServiceProvider.GetServices<>();           
        }
    }
}

Answer 1

CreateScope from IServiceProvider résolvez IServiceScopeFactory et appelez CreateScope() dessus:

public static IServiceScope CreateScope(this IServiceProvider provider)
{
    return provider.GetRequiredService<IServiceScopeFactory>().CreateScope();
}

Donc, comme dit @Evk

fonctionnellement les deux méthodes sont identiques

IServiceProvider vient juste d'appeler l'appel CreateScope() de IServiceScopeFactory