Merhaba. Bu yazımda sizlere ASP.NET CORE'da Dependency Injection ve yaşam döngülerinden bahsedeceğim. Ayrıca ASP.NET CORE ile beraber gelen Microsoft Dependency Injection yapısı ile yaşam döngülerini anlayacağımız bir örnek yapacağım.

Dependency Injection Nedir?

Dependency Injection, SOLID prensiplerinden aşina olduğumuz, Inversion of Control ve Dependency Inversion prensiplerini içerisinde bulunduran bir design pattern yani tasarım desenidir.

Dependency Injection, yazılım projelerinde bağımlılıkları azaltmak için Interface'ler ile beraber kullanılır. Bu Interface'lere bağlı somut yapılar ile lifetime yani yaşam döngüleri ayarlanır. Ayrıca bu yapı ile kodun okunabilirliği ve test edilebilirliği artarken, projelerin "gelişime açık" projeler olması sağlanır.

Yaşam Döngüleri, projede kullanmak istediğimiz yapıların ne kadar bir süre ile hayatta kalıp, yeniden oluşturulması gerektiğinin bilgisini tutar. Kullanabileceğimiz 3 farklı tipi vardır;

1. Singleton: Proje ayağa kalktığı anda sadece 1 kere instance oluşturur ve proje çalıştığı sürece aynı instance'ı sunar.
2. Scoped: Request bazlı bir instance oluşturur. Aynı request içerisinde aynı instance'ı sunar, yeni request geldiğinde instance yenilenir.
3. Transient: Geçici instance'lar oluşturur. Instance her çağırıldığında yeniden oluşur.

Biz yapacağımız örnekte, enjekte yöntemlerinden en sık olarak kullanılan Constructor Injection metodunu kullanacağız.
Hemen projemizi oluşturmaya başlayalım.

Önce bir ASP.NET CORE MVC Projesi oluşturarak interface'lerimizi tanımlıyoruz.

• IGuidManagerSingleton
• IGuidManagerScoped
• IGuidManagerTransient

Üç farklı interface oluşturduk. Üçüne de property olarak 1 adet Guid oluşturuyoruz. Hepsi aşağıdaki gibi olmalı 👇

  public interface IGuidManagerSingleton
  {
      public Guid Id { get; set; }
  }

Şimdi bu interface'leri implement edecek somut class'ları oluşturalım 👇

public class GuidManagerSingleton : IGuidManagerSingleton
{
    public Guid _id;

    public Guid Id
    {
        get { return _id; }
        set { _id = value; }
    }

    public GuidManagerSingleton()
    {
        Id = Guid.NewGuid();
    }
}

Yine bu işlemleri 3 farklı tip için de uyguladıktan sonra, Program.cs içerisinde artık inject edeceğimiz yapılarımızı ve yaşam döngülerini tanımlayabiliriz.

builder.Services.AddControllersWithViews();

builder.Services.AddSingleton<IGuidManagerSingleton, GuidManagerSingleton>();
builder.Services.AddScoped<IGuidManagerScoped, GuidManagerScoped>();
builder.Services.AddTransient<IGuidManagerTransient, GuidManagerTransient>();

var app = builder.Build();

AddSingleton, AddScoped ve AddTransient olarak classlarımızı ekledik ve artık uygulamamız içerisinde kullanmaya hazırız.

Injection işlemlerini her tip için iki kere olacak şekilde HomeController içerisinde tanımlıyoruz ve constructor içerisinde geçiyoruz.

private readonly IGuidManagerSingleton _guidManagerSingleton;
private readonly IGuidManagerSingleton _guidManagerSingleton2;

private readonly IGuidManagerScoped _guidManagerScoped;
private readonly IGuidManagerScoped _guidManagerScoped2;

private readonly IGuidManagerTransient _guidManagerTransient;
private readonly IGuidManagerTransient _guidManagerTransient2;

public HomeController(IGuidManagerSingleton guidManager, IGuidManagerScoped guidManagerScoped, IGuidManagerTransient guidManagerTransient, IGuidManagerSingleton guidManagerSingleton2, IGuidManagerScoped guidManagerScoped2, IGuidManagerTransient guidManagerTransient2)
{
    _guidManagerSingleton = guidManager;
    _guidManagerScoped = guidManagerScoped;
    _guidManagerTransient = guidManagerTransient;
    _guidManagerSingleton2 = guidManagerSingleton2;
    _guidManagerScoped2 = guidManagerScoped2;
    _guidManagerTransient2 = guidManagerTransient2;
}

Şimdi Index içerisinde fonksiyonlarımızı çağırıp View'e yollayalım. 👇

public IActionResult Index()
{
    var guidSingleton = _guidManagerSingleton.Id.ToString();
    ViewBag.guidSingleton = guidSingleton;

    var guidScoped = _guidManagerScoped.Id.ToString();
    ViewBag.guidScoped = guidScoped;

    var guidTransient = _guidManagerTransient.Id.ToString();
    ViewBag.guidTransient = guidTransient;


    var guidSingleton2 = _guidManagerSingleton2.Id.ToString();
    ViewBag.guidSingleton2 = guidSingleton2;

    var guidScoped2 = _guidManagerScoped2.Id.ToString();
    ViewBag.guidScoped2 = guidScoped2;

    var guidTransient2 = _guidManagerTransient2.Id.ToString();
    ViewBag.guidTransient2 = guidTransient2;

    return View();
}
public async Task<JsonResult> GetGuids()
{
    var guidSingleton = _guidManagerSingleton.Id.ToString();
    var guidScoped = _guidManagerScoped.Id.ToString();
    var guidTransient = _guidManagerTransient.Id.ToString();
    return await Task.Run(()=>Json(new { guidSingleton, guidScoped, guidTransient }));
}

Görüldüğü gibi Index üzerinden view'e göndermek dışında, GetGuids adında bir fonksiyon da tanımladım. Burada amaç Ajax ile bu action'a request göndererek, değişkenlerimiz üzerindeki farklılıkları test etmek.
Bunu sağlamak için Index.cshtml sayfamız üzerinde de ufak bir kod yazmamız gerekiyor. 👇

@{
    ViewData["Title"] = "Home Page";
}
<h4>Index 1</h4>
<p>
    <span>Singleton: </span>@ViewBag.guidSingleton
</p>
<p>
    <span>Scoped: </span>@ViewBag.guidScoped
</p>
<p>
    <span>Transient: </span>@ViewBag.guidTransient
</p>
<br /><br />
<h4>Index 2</h4>
<p>
    <span>Singleton2: </span>@ViewBag.guidSingleton2
</p>
<p>
    <span>Scoped2: </span>@ViewBag.guidScoped2
</p>
<p>
    <span>Transient2: </span>@ViewBag.guidTransient2
</p>
<br /><br />
<h4>Ajax</h4>
<p>
    <span>Singleton: </span><span id="singleton"></span>
</p>
<p>
    <span>Scoped: </span><span id="scoped"></span>
</p>
<p>
    <span>Transient: </span><span id="transient"></span>
</p>

<script>
    
</script>

Son olarak GetGuids fonksiyonunu çağırmak için script tagları arasına aşağıdaki Javascript komutunu ekliyorum.

$(document).ready(function () {
        getData();
    });

    function getData() {
        $.ajax({
            url: "Home/GetGuids",
            type: 'GET',
            dataType: 'json', // added data type
            success: function (res) {
                console.log(res);
                $('#singleton').text(res.guidSingleton);
                $('#scoped').text(res.guidScoped);
                $('#transient').text(res.guidTransient);
            }
        });
    }
}

Şimdi test yapmaya hazırız. Uygulamayı çalıştırıp sonuçlara bakalım;

Sonuçları beraber inceleyelim. Her sonuç için singleton'dan gelen veri aynı kaldı. Scoped verisi aynı sorgu içinde aynı kaldı fakat yeni sorguda değişti. Transient ise her bir örnek için değişti. Sayfayı yenilediğiniz taktirde değerlerin benzer şekilde oluştuğunu görebilirsiniz.

Bu yazımda sizlere ASP.NET CORE'da Dependency Injection ve Yaşam Döngülerinden bahsettim. Projenin kaynak dosyalarına buradan ulaşabilirsiniz.
Sabırla okuduğunuz için teşekkür eder keyifli kodlamalar dilerim 🤩