Net Core ve Web API: Dependency Injection (Autofac)

Merhaba arkadaşlar, bugün itibariyle çağımızın trendlerinden biri olan Microsoft’un sunduğu en önemli teknolojilerden biri olan Net Core ve Web API derslerine başlayacağız. Net Core son yıllarda fazlaca Net Framework’ün yerini almış açık kaynak kodlu ve bundan dolayı OS X, Linux ve Windows işletim sistemlerinde çalışabilen yeni nesil Framework’tür. Web API ise Http istekleri ve API geliştirmeleri oldukça kolay bir hale getiren teknolojinin kendisidir.

İlk olarak dersimize Dependency Injection tasarım şablonu, kullanımı ve avantajları ile başlıyoruz. Dependency Injection’ın en önemli sorumlulukları, sınıfların nesne bağımlılıklarını takip edip, onlara bu nesneleri sağlamaktır.

En yaygın Dependency Injection yöntemi Constructor DI’dır. Yapıcı method aracılığı ile nesne bağımlılığı sağlanır. Avantajlarından biri de tekrar eden kodların yerini almasıdır. Peki Dependency Injection kullanmanın hiç mi dezavantajı yok? Tabi ki var. Gereksiz DI kullanımı kompleksliği arttıracak ve ayrıca DI çoğunlukla bir framework’e ihtiyaç duyduğu için Framework bağımlılığına sebep olacaktır. Bütün bunlara karşın DI, kaynağın efektif kullanımı ve kaliteli kod yazımı açısından çok faydalıdır. Net Core Framework, kendi içinde DI yapısını destekleyen Frameworklerdendir.

Dependency Injection Lifetime

Scope: Uygulamaya yapılan her istek için bir bağımlılık oluşturulur. Bu bağımlılık, istek yaşam döngüsü boyunca devam eder.

Singleton: Uygulama ilk ayağa kaldırıldığında bir bağımlılık oluşturulur ve memory’de tutulur. Her zaman bu bağımlılık kullanılır. Bağımlılık seviyesi en yüksek yöntemdir.

Transient: Bağımlılık servisi her çağrıldığında, o servisin bağımlılığı tekrardan oluşturulur. En düşük seviyeli bağımlılık yöntemidir.

Şimdi Scope yöntemini kullanarak .Net Core dahili Dependecy Injection yapısında bir örnek gerçekleştirelim.

public interface ISampleService
{
    public double Sum(double Number1, double Number2);
}    

Yukarıdaki gibi Servis arayüzümüzü tanımlıyoruz.

public class SampleService : ISampleService
{
    public double Sum(double Number1, double Number2)
    {
        return Number1 + Number2;
    }
}

Bu şekilde arayüzümüzü implemente eden servis sınıfımızı ve methodumuzu yazıyoruz. Şimdi, Dependency Injection için servisimizi Startup içinde kayıt etmemiz gerekmektedir.

// This method gets called by the runtime. Use this method to add services to the container.
   public void ConfigureServices(IServiceCollection services)
   {
       services.AddScoped<ISampleService,SampleService>();
       services.AddControllersWithViews();
   }

Yukarıda scope yapısını kullanarak servisimizi register ettik. Bu şekilde her istek yapıldığında SampleService’in bir örneği alınacak. Son olarak aşağıdaki gibi Controller sınıfımıza servisimizin bağımlılığını tanımlıyoruz.

public class HomeController : Controller
{
    private readonly ISampleService _sampleService;

    public HomeController(ISampleService sampleService)
    {
        _sampleService = sampleService;
    }

    public IActionResult Index()
    {
        var total = _sampleService.Sum(2, 3);
        return View(total);
    }
}

Bu şekilde ilk DI örneğimizi gerçekleştirmiş olduk. Peki tek Dependency Injection yolu Net Core’un kendi DI mekanizması mı? Hayır. Autofac son derece güvenilir DI olanağı sağlamaktadır ve Autofac’in avantajlarından yazımızın devamında bahsedeceğim.

Autofac

Şimdi NuGet paketlerini yükleyerek işe başlayalım. İlk olarak aşağıdaki paketleri projemize ekliyoruz.

Autofac (6.3.0)

Autofac.Extras.DynamicProxy (6.0.0)

Autofac.Extensions.DependencyInjection (7.2.0)

Şimdi AutofacModule adında bir sınıf oluşturacağız. Bu sınıf Dependency Register işleminin gerçekleştirileceği sınıf olacak.

public class AutofacModule:Module
{
    protected override void Load(ContainerBuilder builder)
    {
        var assembly = System.Reflection.Assembly.GetExecutingAssembly();
        builder.RegisterAssemblyTypes(assembly)
            .Where(t => t.Name.EndsWith("Service"))
            .As(t => t.GetInterfaces()[0]);
    }
}

Sonrasında bu sınıfı Program.cs sınıfımız içerisinde Register etmemiz gerekmektedir.

.UseServiceProviderFactory(new AutofacServiceProviderFactory())
    .ConfigureContainer<ContainerBuilder>(builder =>
    {
        builder.RegisterModule(new AutofacModule());
    });

Yukarıdaki kod host builder’ımızın sonuna eklenmeli. Son durumda Program.cs sınıfımız aşağıdaki duruma geliyor.

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
                webBuilder.UseStartup<Startup>();
        })
        .UseServiceProviderFactory(new AutofacServiceProviderFactory())
        .ConfigureContainer<ContainerBuilder>(builder =>
        {
                builder.RegisterModule(new AutofacModule());
        });
}

İşte bu kadar! Artık Startup sınıfı içerisinde herhangi bir register işlemine gerek kalmadı ve Autofac DI yapısını kullanıyoruz.

Dolayısıyla daha önce yazdığımız ve Startup sınıfı içerisinde, ConfigureServices methodu içerisinde yer alan

services.AddScoped<ISampleService,SampleService>();

satırını kaldırabiliriz. Çünkü yukarıda AutofacModule sınıfında yazdığımız kod sayesinde artık sonu Service ile biten tüm Servisler otomatik olarak register olacak ve ekstradan tekrar tekrar kod yazmamız gerekmeyecek.

Özetle ilk olarak Microsoft Dependency Injection teknolojisini ve sonrasında Autofac kütüphanesini inceledik. Avantajları, Dezavantajları ve kullanımını örnek kodlarla açıklamaya çalıştık. Bir sonraki dersimizde görüşmek üzere. İyi Kodlamalar!