Cohorts
  • Discover
  • About Us
  • Blog
  • Patika.dev
  • Web3

.Net Core

Tarihçe, .Net Framework vs .Net Core vs .Net5

.NET 5 Kurulumu
Visual Studio Code kurulumu

Http Protokolü
Restful Servisler
Restful vs Soap
JSON (JavaScript Object Notation)

Örnek Web Api Yaratmak

Startup ve Program Sınıfları
Ortam dosyaları

Controller Sınıfı
Route Kavramı
Action Methodlar
Okunabilir API tasarımı

Swagger Nedir? Nasıl Kullanılır?
Postman Nedir? Nasıl Kullanılır?
Api Debug Nasıl Yapılır?

Get ve GetById endpoint'lerinin yazılması
Put ve Post endpoint'lerinin yazılması
Delete endpoint'inin yazılması

İlişkisel ve NoSql Veritabanları
Table,Primary Key, Foreign Key Kavramları
Tablo İlişkileri

Temel SQL
ORM Nedir? ORM Araçları Nelerdir? Entity Framework Core'a Giriş
Örnek Projeye EF Core Dahil Etmek
DB Context kullanarak CRUD işlemler
Auto Increment ID kolonunun eklenmesi
Linq ile Crud İşlemler

Entity Kavramı
ViewModel ve Dto Kavramı
Ödev - Model Kullanımı
Ödev Çözümü - Model Kullanımı
AutoMapper

Modellerin Doğrulanması ve FluentValidation Kütüphanesi
Model Validasyonu - Ödev
Model Validasyonu - Ödev Çözümü

Middleware Kavramı
Custom Exception Middleware Yaratılmak

Dependency Nedir ?
Dependency Injection (DI) Kavramı
DI Container Kavramı
.NET Core DI Container (Services)
Projeye DI Container Kullanarak Logger Servis Eklemek

Pratik - Projeye Genre Controller ve Servislerin Eklenmesi

Ödev - Projeye Author Controller ve Servislerin Eklenmesi

Test Kavramı ve Çeşitleri
TDD (Test Driven Development) Nedir ?
Örnek Test Yazımı
Pratik - Command ve Validator Sınıflarının Testlerinin Yazılması

Ödev - Projenin eksik testlerinin tamamlanması

Token Bazlı Kimlik Doğrulama ve Access Token Kullanımı
Refresh Token Kullanımı

Proje Ödevi - Movie Store Uygulaması

Proje Ödevi 2 - Serbest Proje Seçimi

DI Container Kavramı


Uygulamamız büyüdükçe/değiştikçe ekleyeceğimiz bir çok yeni sınıf beraberinde yeni bağımlılıkları da getirecektir. Bu da bağımlılıkların yönetiminin zorlaşmasına ve hatta içinden çıkılmaz bir hal almasına sebep olabilir.


Bağımlılık yönetimini kolaylaştırmak için Dependency Injection Container adı verilen kütüphaneler kullanılır. Bu kütüphanelerin yardımı ile ihtiyacımız olan sınıfa ait bir nesneye; bağımlılıkları dışarıdan verilmiş kullanıma hazır bir şekilde rahatlıkla ulaşarak kullanabiliriz. Böylece ihtiyacımız olan bir nesneyi oluştururken bağımlı olduğu nesnelerin de yaratılması işlemlerinden kurtulmuş oluruz.


Container'a uygulamamız içerisindeki hangi sınıfları container aracılığı ile kullanacağımız ile ilgili bilgi veririz. Burada hem kullanacağımız sınıfları hem de bunların bağımlı olduğu diğer sınıfları containera kaydetmiş olmamız gerekir. Container tüm bu sınıfları bildiği için kayıtlı olan bir sınıfa ait bir nesne üretmesi gerektiğinde bağımlılıkları da otomatik olarak çözerek bize ihtiyacımız olan nesneyi oluşturur.


Aşağıdaki örnekte görebileceğimiz gibi hem Foo hem Bar sınıfımız önce container'a kayıt ediliyor. Daha sonra bir Foo nesnesini container'dan istediğimizde container; Foo sınıfının Bar sınıfına olan bağımlılığını görüyor ve önce Bar nesnesini üretip daha sonra Foo nesnesinin yapıcı methoduna bu nesneyi vererek (injection) bize bir Foo nesnesi üretmiş oluyor.


DIContainer container = new DIContainer();
container.Register<Foo>();
container.Register<Bar>();

Foo foo1 = container.GetObject<Foo>();
foo1.DoSomething();


Not: Yukarıdaki örnekte kullanılan DIContainer sınıfı ve metotları anlaşılabilir kılınmak adına isimlendirilmiştir. Kullanılan kütüphaneye göre gerçek method ve sınıf isimleri değişecektir.


Containerların önemini anlamak için örneğimizi biraz daha genişletelim. Bar sınıfının da yeni eklenen Baz sınıfına bağımlı hale geldiğini düşünelim. Son durumda sınıflar aşağıdaki şekilde olacaktır.


public class Baz
{
    public void ReadSomething()
    {
        //baz
    }
}

public class Bar
{
    private readonly Baz _baz; //dependency

    public Bar(Baz baz) //dependency injection
    {
        _baz = baz;
    }

    public void WriteSomething()
    {
        _baz.ReadSomething();
        //do something for Bar
    }
}

public class Foo
{
    private readonly Bar _bar; //dependency

    public Foo(Bar bar) //dependency injection
    {
        _bar = bar;
    }

    public void DoSomething()
    {
        //do something for Foo
        _bar.WriteSomething();
    }
}


Eğer ki bağımlılıkları container kullanmadan kendimiz yönetiyor olsaydık tüm uygulamamız içerisinde aşağıdaki şekilde Bar sınıfının bağımlılığını karşılamak için Baz nesnesi yaratmamız gerecekti. Uygulamamız ne kadar büyük ve Bar kullanıyorsa değişiklik yapacağımız yerler de o kadar çok olacak ve efor harcayacaktık.


Baz baz1 = new Baz();
Bar bar1 = new Bar(baz1); //dependency injected.
Foo foo1 = new Foo(bar); //dependency injected.
foo1.DoSomething();


Fakat container kullandığımız durumda bu değişikliklerin hiçbirini yapmadan, sadece yeni eklediğimiz Baz sınıfını containera kaydetmemiz yeterli olacak. Çünkü container Bar'ın Baz bağımlılığını biliyor ve Baz sınıfı için de bilgisi var. Bu nedenle uygulamamızın hiç bir yerinde başka bir değişiklik yapmamıza gerek yok. Container bizim için bunları yerine getiriyor.


DIContainer container = new DIContainer();
container.Register<Foo>();
container.Register<Bar>();
container.Register<Baz>(); //yeni class için yalnızca bir kayıt ekledik

//diğer kodlarda hiç bir değişikliğe ihtiyacımız yok
Foo foo1 = container.GetObject<Foo>();
foo1.DoSomething();


Dependency Injection Container'lardan kısaca DI Container olarak bahsedilir. Aynı zamanda DI Framework, IoC Container yada IoC Framework olarak da kullanımlarına rastlanabilinir.


.Net Core uygulamalarında kullanılabilecek bir çok farklı DI Container kütüphanesi mevcuttur. Çoğu temelde aynı işlevi sunar, fakat performans ve bazı ek yetenekler nedeniyle ihtiyaca göre bir seçim yapılabilir.


Okuma Önerisi: Dependency Injection ve Container kavramları hakkında daha detaylı bilgi almak için tıklayınız.


Inceleme Önerisi: .Net Core uygulamalarında en sık kullanılan DI Container'lar listesi için tıklayınız.

Previous
Next

Lesson discussion

Swap insights and ask questions about “.Net Core”.

Enroll to participate
Start the course to unlock the discussion. Enrolling helps us keep conversations relevant to learners.
Cohorts
WebsiteDiscoverBlogPatika.devRise In
CoursesCircleRustSoliditySolanaWeb3 FundamentalsBlockchain Basics
CompanyAbout UsTerms of UsePrivacy PolicyGDPR NoticeCookies
Don't miss any update!

Disclaimer: The information, programs, and events provided on https://cohorts.patika.dev is strictly for upskilling and networking purposes related to the technical infrastructure of blockchain platforms. We do not provide financial or investment advice, nor do we make any representations regarding the value, profitability, or future price of any blockchain or cryptocurrency. Users are encouraged to conduct their own research and consult with licensed financial professionals before engaging in any investment activities. https://cohorts.patika.dev disclaims any responsibility for financial decisions made by users based on the information provided here.

© 2026 Cohorts, All rights reserved