ASP.NET Core MVC yerleşik bağımlılık enjeksiyon çerçevesini kullanarak bir türü el ile nasıl çözebilirim?

Konteyneri kurmak yeterince kolaydır:

public void ConfigureServices(IServiceCollection services)
{
    // ...

    services.AddTransient<ISomeService, SomeConcreteService>();
}

Ancak ISomeServiceenjeksiyon yapmadan nasıl çözebilirim ? Örneğin, bunu yapmak istiyorum:

ISomeService service = services.Resolve<ISomeService>();

'De böyle bir yöntem yoktur IServiceCollection.

IServiceCollectionArayüzü için kullanılan yapı , bir bağımlılık enjeksiyon kap. Tamamen oluşturulduktan sonra, IServiceProviderhizmetleri çözmek için kullanabileceğiniz bir örneğe göre oluşturulur. IServiceProviderHerhangi bir sınıfa bir enjekte edebilirsiniz . IApplicationBuilderVe HttpContextsınıflar ile, hem servis sağlayıcı sağlayabilir ApplicationServicesya da RequestServicessırasıyla özellikleri.

IServiceProviderGetService(Type type)bir servisi çözmek için bir yöntem tanımlar :

var service = (IFooService)serviceProvider.GetService(typeof(IFooService));

Ayrıca, serviceProvider.GetService<IFooService>()( usingfor a ekle Microsoft.Extensions.DependencyInjection) gibi çeşitli kolaylık genişletme yöntemleri de vardır .

Başlangıç ​​sınıfı içindeki hizmetleri çözümleme

Enjeksiyon bağımlılıkları

Çalışma zamanının barındırma hizmeti sağlayıcısı yapıcı içine belirli hizmetleri enjekte Startupgibi sınıf, IConfiguration, IWebHostEnvironment( IHostingEnvironment3.0'dan sürümlerinde), ILoggerFactoryve IServiceProvider. İkincisinin barındırma katmanı tarafından oluşturulan bir örnek olduğunu ve yalnızca bir uygulamayı başlatmak için gerekli hizmetleri içerdiğini unutmayın .

ConfigureServices()Yöntem sadece bir kabul, hizmetlerini enjekte izin vermez IServiceCollectionargüman. Bu mantıklıdır çünkü ConfigureServices()uygulamanızın gerektirdiği hizmetleri kaydettiğiniz yer burasıdır. Ancak, burada başlangıç ​​yapıcısına enjekte edilen hizmetleri kullanabilirsiniz, örneğin:

public Startup(IConfiguration configuration)
{
    Configuration = configuration;
}

public IConfiguration Configuration { get; }

public void ConfigureServices(IServiceCollection services)
{
    // Use Configuration here
}

Kayıtlı herhangi bir hizmet ConfigureServices()daha sonra Configure()yönteme enjekte edilebilir ; şu IApplicationBuilderparametreden sonra isteğe bağlı sayıda hizmet ekleyebilirsiniz :

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IFooService>();
}

public void Configure(IApplicationBuilder app, IFooService fooService)
{
    fooService.Bar();
}

Bağımlılıkları elle çözme

Hizmetleri el ile çözümlemeniz gerekiyorsa, tercihen aşağıdaki yöntemle ApplicationServicessağlananları kullanmalısınız :IApplicationBuilderConfigure()

public void Configure(IApplicationBuilder app)
{
    var serviceProvider = app.ApplicationServices;
    var hostingEnv = serviceProvider.GetService<IHostingEnvironment>();
}

Sınıfınızın IServiceProvideryapıcısında bir geçmek ve doğrudan kullanmak mümkündür Startup, ancak yukarıdaki gibi bu sınırlı bir hizmet alt kümesi içerecektir ve bu nedenle sınırlı faydaya sahiptir:

public Startup(IServiceProvider serviceProvider)
{
    var hostingEnv = serviceProvider.GetService<IWebHostEnvironment>();
}

ConfigureServices()Yöntemdeki hizmetleri çözümlemeniz gerekiyorsa , farklı bir yaklaşım gerekir. Sen bir ara inşa edebilirsiniz IServiceProviderdan IServiceCollectiontescil edilmiştir hizmetlerini içeren örneğine o noktaya kadar :

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IFooService, FooService>();

    // Build the intermediate service provider
    var sp = services.BuildServiceProvider();

    // This will succeed.
    var fooService = sp.GetService<IFooService>();
    // This will fail (return null), as IBarService hasn't been registered yet.
    var barService = sp.GetService<IBarService>();
}

Lütfen dikkat: Genellikle uygulama içindeki hizmetleri yapılandırdığınızConfigureServices() yer olduğu için hizmetleri yöntem içinde çözmekten kaçınmalısınız . Bazen sadece bir örneğe erişmeniz gerekir . Bunu örnekten bir örneğe bağlayarak (esas olarak seçenekler çerçevesinin yaptığı şeydir) bunu yapabilirsiniz:IOptions<MyOptions>IConfigurationMyOptions

public void ConfigureServices(IServiceCollection services)
{
    var myOptions = new MyOptions();
    Configuration.GetSection("SomeSection").Bind(myOptions);
}

Hizmetleri manuel olarak çözümlemek (Servis Bulucu olarak da bilinir) genellikle bir anti-desen olarak kabul edilir . Kullanım durumları olsa da (çerçeveler ve / veya altyapı katmanları için) mümkün olduğunca kaçınmalısınız.

Örneklerin manuel olarak çözülmesi, IServiceProviderarayüzün kullanılmasını içerir :

Başlangıçta Bağımlılığı Çözme.ConfigureServices

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<IMyService, MyService>();

    var serviceProvider = services.BuildServiceProvider();
    var service = serviceProvider.GetService<IMyService>();
}

Başlangıçtaki Bağımlılıkları Çözme.Configure

public void Configure(
    IApplicationBuilder application,
    IServiceProvider serviceProvider)
{
    // By type.
    var service1 = (MyService)serviceProvider.GetService(typeof(MyService));

    // Using extension method.
    var service2 = serviceProvider.GetService<MyService>();

    // ...
}

ASP.NET Core 3'te Başlangıçtaki Bağımlılıkları Çözme.

public void Configure(
    IApplicationBuilder application,
    IWebHostEnvironment webHostEnvironment)
{
    app.ApplicationServices.GetService<MyService>();
}

Çalışma Zamanı Enjekte Edilmiş Hizmetlerini Kullanma

Bazı tipler yöntem parametreleri olarak enjekte edilebilir:

public class Startup
{
    public Startup(
        IHostingEnvironment hostingEnvironment,
        ILoggerFactory loggerFactory)
    {
    }

    public void ConfigureServices(
        IServiceCollection services)
    {
    }

    public void Configure(
        IApplicationBuilder application,
        IHostingEnvironment hostingEnvironment,
        IServiceProvider serviceProvider,
        ILoggerFactory loggerfactory,
        IApplicationLifetime applicationLifetime)
    {
    }
}

Denetleyici Eylemlerindeki Bağımlılıkları Çözme

[HttpGet("/some-action")]
public string SomeAction([FromServices] IMyService myService) => "Hello";

Şablon içeren bir uygulama oluşturursanız, Startupsınıfta şöyle bir şey olacaktır :

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddApplicationInsightsTelemetry(Configuration);

    services.AddMvc();
}

Daha sonra buraya bağımlılıklar ekleyebilirsiniz, örneğin:

services.AddTransient<ITestService, TestService>();

ITestServiceKontrol cihazınızdan erişmek istiyorsanız, kurucuya ekleyebilirsiniz IServiceProviderve enjekte edilir:

public HomeController(IServiceProvider serviceProvider)

Ardından eklediğiniz hizmeti çözebilirsiniz:

var service = serviceProvider.GetService<ITestService>();

Genel sürümü kullanmak için, uzantıları içeren bir ad alanı eklemeniz gerektiğini unutmayın:

using Microsoft.Extensions.DependencyInjection;

ITestService.cs

public interface ITestService
{
    int GenerateRandom();
}

TestService.cs

public class TestService : ITestService
{
    public int GenerateRandom()
    {
        return 4;
    }
}

Startup.cs (ConfigureServices)

public void ConfigureServices(IServiceCollection services)
{
    services.AddApplicationInsightsTelemetry(Configuration);
    services.AddMvc();

    services.AddTransient<ITestService, TestService>();
}

HomeController.cs

using Microsoft.Extensions.DependencyInjection;

namespace Core.Controllers
{
    public class HomeController : Controller
    {
        public HomeController(IServiceProvider serviceProvider)
        {
            var service = serviceProvider.GetService<ITestService>();
            int rnd = service.GenerateRandom();
        }

Bir bağımlılığı, kaydettirmekte olduğunuz başka bir bağımlılığın yapıcısına iletmek amacıyla çözmeniz gerekiyorsa, bunu yapabilirsiniz.

Diyelim ki bir dize ve bir ISomeService alan bir hizmetiniz var.

public class AnotherService : IAnotherService
{
    public AnotherService(ISomeService someService, string serviceUrl)
    {
        ...
    }
}

Bunu Startup.cs içine kaydettirdiğinizde bunu yapmanız gerekir:

services.AddScoped<IAnotherService>(ctx => 
      new AnotherService(ctx.GetService<ISomeService>(), "https://someservice.com/")
);

AuthorizeAttribute gibi özelliklerde bağımlılıkları bu şekilde enjekte edebilirsiniz.

var someservice = (ISomeService)context.HttpContext.RequestServices.GetService(typeof(ISomeService));

Bunun eski bir soru olduğunu biliyorum ama burada oldukça açık ve iğrenç bir hack'in bulunmadığından şaşkınım.

Siz tanımlarken hizmetlerinizden gerekli değerleri elde etmek için kendi ctor işlevinizi tanımlama yeteneğinden yararlanabilirsiniz ... bu hizmet sömürücünün ilk inşaatı içinde .

Bu yöntemin avantajı, hizmetin yapılandırılması sırasında hizmet ağacını oluşturmanızı veya kullanmamanızı gerektirmemektedir. Hala hizmetlerin nasıl yapılandırılacağını tanımlıyorsunuz.

public void ConfigureServices(IServiceCollection services)
{
    //Prey this doesn't get GC'd or promote to a static class var
    string? somevalue = null;

    services.AddSingleton<IServiceINeedToUse, ServiceINeedToUse>(scope => {
         //create service you need
         var service = new ServiceINeedToUse(scope.GetService<IDependantService>())
         //get the values you need
         somevalue = somevalue ?? service.MyDirtyHack();
         //return the instance
         return service;
    });
    services.AddTransient<IOtherService, OtherService>(scope => {
         //Explicitly ensuring the ctor function above is called, and also showcasing why this is an anti-pattern.
         scope.GetService<IServiceINeedToUse>();
         //TODO: Clean up both the IServiceINeedToUse and IOtherService configuration here, then somehow rebuild the service tree.
         //Wow!
         return new OtherService(somevalue);
    });
}

Bu modeli düzeltmenin yolu , örtük olarak ona veya yönteminin dönüş değerine bağlı olmak yerine OtherServiceaçık bir bağımlılık vermektir IServiceINeedToUse... veya bu bağımlılığı başka bir şekilde açık bir şekilde çözmektir.

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    services.AddDbContext<ConfigurationRepository>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("SqlConnectionString")));

    services.AddScoped<IConfigurationBL, ConfigurationBL>();
    services.AddScoped<IConfigurationRepository, ConfigurationRepository>();
}