ASP.NET Core ile REST API Kurulumu: Routing, DI ve Middleware Mantığı

ASP.NET Core, Microsoft tarafından geliştirilen açık kaynaklı bir web framework'üdür ve REST API kurulumu için istek karşılama, yönlendirme, veri doğrulama ve yanıt üretme gibi tekrar eden görevleri hazır bir altyapı üzerinden yönetmeyi sağlar. Bir REST API'nin temelinde HTTP istekleri karşılanır, bu istekler ilgili iş mantığına yönlendirilir, gerekli veri işlemleri yapılır ve sonuç istemciye standart bir formatta (genellikle JSON) döndürülür. ASP.NET Core bu döngüyü routing, dependency injection ve middleware adı verilen üç temel mekanizma üzerinden kurar. Bu yazıda, C#'a yeni başlayan veya backend dili seçmeye çalışan bir geliştiricinin bu mimariyi sıfırdan nasıl kuracağını ve benzer mantığın Java ile Python dünyasında nasıl karşılık bulduğunu adım adım göreceksiniz.

ASP.NET Core ile REST API Nedir? Temel Yapı Taşları

Bir REST API, istemci ile sunucu arasında HTTP protokolü üzerinden veri alışverişini standart kurallara bağlayan bir mimari yaklaşımdır. ASP.NET Core, bu yaklaşımı .NET platformu üzerinde uygulamak için gereken tüm bileşenleri (sunucu, yönlendirme motoru, model bağlama, serileştirme) bir arada sunar. Herhangi bir web framework'ünün temel görevi aslında değişmez: gelen isteği karşılamak, isteğin hangi işleve ait olduğunu belirlemek, gerekli veriyi işlemek ve uygun bir yanıt üretmek. ASP.NET Core bu görevleri katmanlı bir yapıda gerçekleştirir.

Bu katmanlı yapının merkezinde birkaç kavram bulunur:

• Routing (yönlendirme): Gelen bir HTTP isteğinin URL ve metoduna bakarak hangi kod bloğunun çalışacağını belirler.
• Dependency Injection (bağımlılık enjeksiyonu): Bir sınıfın ihtiyaç duyduğu servisleri kendisi oluşturmak yerine dışarıdan almasını sağlar, böylece kod parçaları birbirinden bağımsız test edilebilir hale gelir.
• Middleware pipeline: İstek sunucuya ulaştığında ve yanıt istemciye dönmeden önce sırayla çalışan, kimlik doğrulama, günlükleme veya hata yakalama gibi işlemleri yürüten bir zincirdir.

Bu üç mekanizmanın birlikte çalışması, bir isteğin sunucuya giriş yaptığı andan yanıtın döndüğü ana kadar geçen süreci öngörülebilir ve genişletilebilir kılar. Önemli olan nokta şudur: bu mimari mantık yalnızca ASP.NET Core'a özgü değildir. Java ekosisteminde Spring, Python ekosisteminde FastAPI gibi framework'ler de aynı temel soruna, yani gelen HTTP isteğini doğru iş mantığına ulaştırma sorununa, kendi araçlarıyla çözüm üretir. Routing bir framework'te açıklama (annotation) tabanlı çalışırken bir diğerinde fonksiyon dekoratörleri üzerinden ilerleyebilir; ama altta yatan mantık, isteği doğru koda yönlendirmek, her yerde aynıdır. Bu benzerlik, bir dilde öğrenilen mimari düşünme biçiminin diğer dillere de taşınabilir olduğunu gösterir ve backend dili seçimi yaparken sadece sözdizimine değil, bu kavramsal örtüşmeye de bakmak gerektiğini ortaya koyar.

dotnet CLI ile Proje Oluşturma: Adım Adım Kurulum

ASP.NET Core projeleri genellikle dotnet CLI adı verilen komut satırı aracıyla oluşturulur. Bu araç, proje iskeletini hazırlamaktan bağımlılık yönetimine kadar birçok işlemi tek bir komut arayüzünden yürütmeyi sağlar. Bir REST API kurulumuna başlarken izlenecek adımlar genel hatlarıyla şu şekildedir:

1. Proje şablonu seçimi: dotnet CLI üzerinden bir web API şablonu belirtilerek proje türü seçilir; bu şablon, gerekli klasör yapısını ve başlangıç dosyalarını otomatik oluşturur.
2. Proje dizininin oluşturulması: Seçilen şablon çalıştırıldığında, proje adını taşıyan bir klasör içinde kaynak kodu dosyaları, yapılandırma dosyaları ve bağımlılık tanım dosyası üretilir.
3. Gerekli paketlerin eklenmesi: Veritabanı erişimi, kimlik doğrulama veya serileştirme gibi ek işlevler gerekiyorsa, paket yöneticisi üzerinden ilgili kütüphaneler projeye eklenir.
4. Bağımlılıkların geri yüklenmesi: Proje dosyasında tanımlı paketlerin indirilip yerel ortama kurulması sağlanır; bu adım proje derlenmeden önce tamamlanmalıdır.
5. Projenin çalıştırılması: Derleme ve çalıştırma komutu tetiklendiğinde yerleşik sunucu ayağa kalkar ve API belirlenen bir portta istek karşılamaya başlar.

Bu adımların her biri, aslında herhangi bir backend projesinde karşılaşılan evrensel bir akışı yansıtır: iskeleti kur, bağımlılıkları tanımla, bağımlılıkları yükle, çalıştır. Java dünyasında Maven veya Gradle ile proje oluşturmak, Python dünyasında sanal ortam kurup paket yöneticisiyle kütüphane eklemek de kavramsal olarak aynı sırayı izler. dotnet CLI'ı farklı kılan, bu adımların tek bir birleşik komut satırı aracı altında toplanmış olmasıdır; bu da yeni başlayan bir geliştiricinin proje kurulumu sırasında farklı araçlar arasında geçiş yapma zorunluluğunu azaltır. Kurulum tamamlandıktan sonra proje çalışır duruma geldiğinde, geliştiricinin asıl odaklanması gereken kısım proje dosyalarının içeriği ve bu dosyaların birbiriyle nasıl konuştuğudur; bu da bizi bir sonraki başlıkta ele alınacak Program.cs mantığına taşır.

Minimal API ve Controller Tabanlı Yapı: Program.cs Mantığı

ASP.NET Core projelerinde uygulamanın giriş noktası Program.cs dosyasıdır ve bu dosya üzerinden iki farklı organizasyon yaklaşımı benimsenebilir. Birincisi minimal API yaklaşımıdır; burada endpoint tanımları doğrudan Program.cs içinde, kısa fonksiyon ifadeleriyle yazılır. Bir istek geldiğinde hangi kodun çalışacağı, uzun bir sınıf hiyerarşisi kurmadan, tek bir dosya içinde okunabilir şekilde tanımlanır. Bu yaklaşım küçük servisler veya hızlı prototipler için sade bir başlangıç noktası sunar.

İkinci yaklaşım ise controller tabanlı yapıdır. Burada her kaynak (örneğin kullanıcılar, ürünler) kendi sınıfında toplanır ve bu sınıf içindeki metotlar belirli HTTP metodlarına karşılık gelir. Proje büyüdükçe, ilgili iş mantığının belirli bir sınıf altında gruplanması, kod tabanının okunabilirliğini ve bakımını kolaylaştırır. Bu iki yaklaşım arasındaki seçim aslında bir olgunluk meselesidir: küçük ölçekli bir API minimal yapıyla hızlıca ayağa kaldırılabilirken, çok sayıda kaynağı yöneten bir sistemde controller tabanlı organizasyon karmaşayı daha kontrollü hale getirir.

Bu controller mantığı, aslında Java ekosisteminde Spring framework'ünün de temel çalışma biçimidir; orada da her kaynak kendi sınıfında tanımlanır ve HTTP metodları bu sınıf içindeki metotlara açıklamalar (annotation) aracılığıyla bağlanır. Bir geliştirici ASP.NET Core'daki controller yapısını kavradığında, Spring'deki benzer sınıf-metot ilişkisini tanımak için ekstra bir zihinsel sıçrama yapmasına gerek kalmaz; çünkü kaynak bazlı organizasyon fikri dilden bağımsız bir tasarım prensibidir. Bu nedenle backend mimarisini bir dilde sağlam öğrenen bir geliştirici, ikinci bir dile geçtiğinde sözdiziminden çok kavramları eşlemekle uğraşır. Bu geçişi somut bir eğitim yoluyla deneyimlemek isteyenler için Java özel ders programı kapsamındaki 1-1 çalışma, controller tabanlı düşünme biçimini sıfırdan pekiştirmek isteyenlere yapılandırılmış bir alıştırma alanı sunar.

Routing Mantığı: Endpoint Eşleme ve HTTP Metodları

Routing, bir web isteğinin URL yolunu belirli bir kod bloğuyla eşleştirme mantığıdır. Kullanıcı tarayıcıdan veya bir istemci uygulamadan /urunler gibi bir adrese istek gönderdiğinde, ASP.NET Core bu isteği hangi metodun karşılayacağına routing katmanında karar verir. Bu eşleme, hem klasik controller tabanlı yapıda [Route] ve [HttpGet] gibi öznitelikler (attribute) ile hem de minimal API'de doğrudan app.MapGet(...) gibi çağrılarla tanımlanabilir. Her iki durumda da mantık aynıdır: gelen isteğin yolu ve HTTP metodu, tanımlı endpoint'lerle karşılaştırılır ve eşleşen kod çalıştırılır.

HTTP metodları, bir kaynağa ne yapılmak istendiğini belirtir ve routing kararının ikinci bileşenidir. Aynı URL yoluna gönderilen bir GET isteği ile bir POST isteği, tamamen farklı iki koda yönlendirilebilir. Bu ayrım, REST API tasarımının temel prensiplerinden biridir; çünkü aynı kaynak üzerinde farklı işlemler, farklı metodlarla ifade edilir:

• GET: Var olan bir kaynağı veya kaynak listesini okumak için kullanılır, veri üzerinde değişiklik yapmaz.
• POST: Yeni bir kaynak oluşturmak veya sunucuya işlenmek üzere veri göndermek için kullanılır.
• PUT: Var olan bir kaynağın tamamını güncellemek için kullanılır.
• DELETE: Belirtilen kaynağı sistemden kaldırmak için kullanılır.

Endpoint tanımlarında sıkça karşılaşılan iki kavram, route parametreleri ve query string'lerdir. Route parametresi, URL yolunun kendisine gömülü bir değişkendir; örneğin /urunler/{id} tanımında {id} kısmı istek geldiğinde gerçek bir değerle (/urunler/5 gibi) doldurulur ve doğrudan ilgili kaynağı hedef alır. Query string ise URL'nin sonuna ? işaretiyle eklenen anahtar-değer çiftleridir; genellikle filtreleme, sayfalama veya sıralama gibi opsiyonel parametreleri taşımak için kullanılır. Route parametresi "hangi kaynak" sorusuna, query string ise "bu kaynak nasıl listelensin" sorusuna cevap verir denebilir. Bu ayrımı doğru kurmak, hem okunabilir bir API tasarımı hem de tutarlı bir hata yönetimi için önemlidir.

Dependency Injection ve Middleware Pipeline Nasıl Çalışır?

Dependency Injection (bağımlılık enjeksiyonu, kısaca DI), bir sınıfın ihtiyaç duyduğu nesneleri kendisi oluşturmak yerine dışarıdan hazır şekilde alması mantığıdır. Örneğin bir sipariş servisinin veritabanı bağlantısına ihtiyacı varsa, bu bağlantıyı sınıfın içinde new ile üretmek yerine, framework'ün merkezi bir konteynerden (container) sağladığı hazır bir örneği kullanır. Bu yaklaşım, kodun test edilebilirliğini artırır çünkü test sırasında gerçek veritabanı yerine sahte (mock) bir bağımlılık kolayca enjekte edilebilir. ASP.NET Core'da bu kayıt işlemi builder.Services.AddScoped<T>() gibi çağrılarla yapılır ve ihtiyaç duyan her sınıfa, yapıcı metod (constructor) üzerinden otomatik olarak sağlanır.

Middleware pipeline ise gelen her HTTP isteğinin, uygulamaya ulaşana kadar sırayla geçtiği bir işlem hattıdır. Her middleware, isteği alır, kendi görevini yapar (kimlik doğrulama, loglama, hata yakalama, statik dosya sunma gibi) ve isteği bir sonraki middleware'e devreder. Bu sıralı yapı, isteğin önce güvenlik kontrolünden geçmesini, ardından loglanmasını, sonra da asıl endpoint koduna ulaşmasını sağlar. Pipeline'daki sıralama önemlidir; örneğin kimlik doğrulama middleware'i, yetkilendirme kontrolünden önce çalışmalıdır, aksi halde mantık hatalı işler.

Bu iki kavram birbirinden bağımsız görünse de aslında aynı felsefeyi paylaşır: sorumlulukları ayırmak ve bağımlılıkları merkezi bir mekanizmadan yönetmek. Bu mantık, ASP.NET Core'a özgü değildir; Python ekosisteminde FastAPI'nin kendi Depends() mekanizması da kavramsal olarak oldukça benzer bir amaca hizmet eder, bir endpoint fonksiyonunun ihtiyaç duyduğu veritabanı oturumu veya doğrulama nesnesi dışarıdan enjekte edilir. Backend mimarisini bir dilde kavrayan bir geliştirici, aynı prensipleri başka bir dilde de tanıyarak öğrenme sürecini kısaltabilir; nitekim birebir Python dersleri kapsamında bu tür mimari kavramlar da somut kod örnekleriyle ele alınır. Dolayısıyla DI ve middleware mantığını bir kez iyi kavramak, farklı framework'ler arasında geçiş yaparken önemli bir zaman kazandırır.

Çalışan Bir Minimal API Örneği: GET ve POST Endpoint

Önceki bölümlerde anlatılan routing ve HTTP metod mantığını somutlaştırmak için basit bir ürün listesi üzerinden çalışan bir minimal API örneği kurulabilir. Aşağıdaki kod, bellekte tutulan bir liste üzerinde bir GET endpoint'i ile mevcut ürünleri döndürür, bir POST endpoint'i ile de yeni ürün ekler:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var urunler = new List<Urun>();

app.MapGet("/urunler", () => urunler);

app.MapPost("/urunler", (Urun urun) =>
{
    urunler.Add(urun);
    return Results.Created($"/urunler/{urun.Id}", urun);
});

app.Run();

record Urun(int Id, string Ad, decimal Fiyat);

Bu örnekte app.MapGet("/urunler", ...) satırı, /urunler yoluna gelen bir GET isteğini bellekteki listeyi döndüren fonksiyona bağlar; bu da bir önceki bölümde anlatılan endpoint eşleme mantığının doğrudan uygulamasıdır. app.MapPost("/urunler", ...) satırı ise aynı yola gelen ama farklı bir HTTP metoduyla (POST) gönderilen isteği, gövdesindeki JSON verisini otomatik olarak Urun tipine dönüştürüp listeye ekleyen ayrı bir fonksiyona yönlendirir. Burada dikkat edilmesi gereken nokta, aynı URL yolunun (/urunler) iki farklı HTTP metoduyla iki farklı işleve karşılık gelmesidir; bu, routing'in HTTP metoduyla birlikte çalıştığının somut kanıtıdır.

Results.Created çağrısı, REST prensiplerine uygun şekilde yeni oluşturulan kaynağın adresini ve verisini istemciye döndürür, bu da API'yi kullanan tarafın yeni ürüne nasıl erişeceğini bilmesini sağlar. Bu küçük örnek gerçek bir projede genellikle bir veritabanı bağlamı (DbContext) ile birlikte, DI üzerinden enjekte edilerek genişletilir; ancak mimari mantık, isteğin doğru endpoint'e yönlenmesi ve ilgili işlemi yapıp bir sonuç döndürmesi, burada gösterilen yapıdan farklı değildir.

ASP.NET Core, Java Spring ve Python FastAPI: Mimari Kavram Karşılaştırması

Bir backend çatısını öğrenmenin en kalıcı yolu, onu tek başına değil başka çatılarla yan yana koyarak anlamaktır. ASP.NET Core, Java dünyasındaki Spring ve Python tarafındaki FastAPI, birbirinden bağımsız gibi görünse de aynı mimari sorunlara çok benzer çözümler üretir: gelen isteği doğru koda yönlendirmek, bağımlılıkları yönetmek ve isteği işlemeden önce/sonra ortak işlemleri uygulamak. Bu üçünü karşılaştırmak, sadece C# öğrenen birine değil, dil bağımsız mimari okuryazarlığı kazanmak isteyen herkese fayda sağlar.

Aşağıdaki tablo, önceki bölümlerde ASP.NET Core özelinde incelediğimiz routing, dependency injection ve middleware kavramlarının diğer iki ekosistemdeki karşılıklarını özetler. Amaç birini diğerine üstün göstermek değil, aynı problemin farklı sözdizimleriyle nasıl çözüldüğünü görünür kılmaktır.

Tablodan çıkarılacak en önemli sonuç, üç çatının da aynı üç yapı taşını (yönlendirme, bağımlılık yönetimi, ara katman) farklı sözdizimleriyle çözdüğüdür. Kod yazımı değişse de mantık aynı kalır: bir istek geldiğinde önce ara katmanlardan geçer, sonra doğru uç noktaya yönlendirilir, o uç nokta da ihtiyaç duyduğu servisleri dışarıdan alır. Hangi dilde çalışırsanız çalışın bu üçlü mantığı kavramış olmak, yeni bir çatıya geçişi hızlandırır. Bu tür kavramsal karşılaştırmalarda kendi seviyenizi görmek isterseniz ücretsiz kodlama bilgisi testi ile hangi konularda daha fazla pratiğe ihtiyacınız olduğunu kısa sürede öğrenebilirsiniz.

Backend Dili Seçerken Hangi Ölçütlere Bakılmalı?

ASP.NET Core, Spring ve FastAPI arasında yapılan bu karşılaştırma, doğal olarak "hangi dili öğrenmeliyim" sorusunu gündeme getirir. Bu sorunun tek doğru cevabı yoktur; çünkü karar dilin kendisinden çok geliştiricinin hedeflerine, çalışmak istediği sektöre ve mevcut deneyimine bağlıdır. Aşağıdaki ölçütler, popülerlik sıralamasına bakmadan objektif bir karar vermenize yardımcı olabilir.

• Öğrenme eğrisi: Python'ın sade söz dizimi genellikle ilk aylarda daha az sürtünme yaratırken, C# ve Java'nın statik tip sistemi baştan disiplin kazandırır ve büyük projelerde hata ayıklamayı kolaylaştırır.
• Ekosistem olgunluğu: Bir dilin kütüphane, framework ve topluluk desteği ne kadar geniş ve uzun soluklu olduğu, uzun vadeli proje sürdürülebilirliğini doğrudan etkiler.
• İş piyasası ihtiyacı: Hedeflediğiniz sektörde (kurumsal yazılım, finans, girişim, veri odaklı sistemler) hangi dilin daha sık talep edildiğini incelemek, öğrenme yatırımınızı doğru yöne kanalize eder.
• Proje ölçeği ve ekip yapısı: Küçük ve hızlı prototipler için hafif çatılar tercih edilirken, çok katmanlı kurumsal sistemlerde daha katı mimari kurallar getiren çatılar tercih sebebi olabilir.
• Araç ve tooling desteği: Geliştirme ortamı, hata ayıklama araçları ve yapay zeka destekli kod tamamlama araçlarıyla uyumluluk, günlük üretkenliği doğrudan etkiler.
• Kişisel ilgi ve motivasyon: Nesne yönelimli, tip güvenli bir yapıyı mı yoksa daha esnek ve hızlı yazılabilen bir sözdizimini mi tercih ettiğiniz, uzun vadede hangi dilde daha istikrarlı ilerleyeceğinizi belirler.

Bu ölçütlerin hiçbiri tek başına "kesin doğru" cevabı vermez; asıl önemli olan sizin kariyer hedefinizle örtüşen dili seçmektir. Henüz hangi yöne ilerlemek istediğinizden emin değilseniz, ücretsiz kariyer keşif testi ile ilgi alanlarınıza uygun yazılım yönünü belirlemek, dil seçimini de kolaylaştıran bir ilk adım olabilir.

Sık Sorulan Sorular

ASP.NET Core ile REST API kurmak için hangi araçlar gereklidir?

Temel olarak .NET SDK, bir kod editörü ve komut satırı erişimi yeterlidir. Proje oluşturma, paket yönetimi ve çalıştırma işlemleri dotnet CLI üzerinden yapılabildiği için ağır bir kurulum sürecine ihtiyaç yoktur.

Minimal API ile controller tabanlı API arasındaki temel fark nedir?

Minimal API, uç noktaları doğrudan Program.cs içinde tanımlayarak daha az kod ve daha az dosya ile hızlı sonuç almayı hedefler. Controller tabanlı yapı ise uç noktaları ayrı sınıflara böler ve büyüyen, çok sayıda kaynak içeren projelerde daha düzenli bir organizasyon sağlar.

Dependency Injection neden bu kadar önemli bir mimari kavramdır?

Dependency Injection, bir sınıfın ihtiyaç duyduğu servisleri kendisi oluşturmak yerine dışarıdan almasını sağlar. Bu sayede kodlar birbirinden gevşek bağlı (loosely coupled) olur, test edilebilirliği artar ve servislerin yaşam süresi merkezi bir noktadan yönetilebilir.

ASP.NET Core'daki middleware pipeline, Spring'deki filter mantığıyla aynı mı?

Kavramsal olarak çok benzerler; her ikisi de isteğin işlenmeden önce ve sonra sırayla belirli katmanlardan geçmesini sağlar. Ancak tanımlanma biçimleri farklıdır: ASP.NET Core'da app.Use() çağrıları ile sıralı bir hat kurulurken, Spring'de bu iş Servlet Filter ve Interceptor mekanizmalarıyla yapılır.

FastAPI'deki dependency injection, ASP.NET Core'a göre nasıl farklılaşır?

FastAPI'de bağımlılıklar merkezi bir konteynerde kayıt altına alınmak yerine, doğrudan fonksiyon parametresinde Depends() ile tanımlanır. ASP.NET Core'da ise servisler önce Program.cs içinde bir konteynere kaydedilir, ardından ihtiyaç duyan sınıflara otomatik olarak enjekte edilir.

Backend dili seçerken öğrenme eğrisi mi iş piyasası mı önceliklendirilmeli?

İkisi de tek başına yeterli bir ölçüt değildir; birlikte değerlendirilmelidir. Kısa vadede hızlı ilerlemek istiyorsanız öğrenme eğrisi daha belirleyici olabilirken, uzun vadeli kariyer planı yapıyorsanız hedeflediğiniz sektörün ihtiyaçlarını da göz önünde bulundurmak daha sağlıklı bir tercih sağlar.

Java veya Python öğrenmek isteyenler bu mimari mantığı nasıl pekiştirebilir?

Routing, dependency injection ve middleware gibi kavramlar dilden bağımsız evrensel mimari prensiplerdir; bu nedenle bu mantığı Java veya Python üzerinden öğrenmek, ileride başka bir çatıya geçişi de kolaylaştırır. Bu kavramları uygulamalı örneklerle pekiştirmek isteyenler, birebir ilerleyen bir eğitim sürecinden fayda görebilir.

ASP.NET Core'un routing, dependency injection ve middleware pipeline mantığını kavramak, yalnızca C# öğrenenler için değil, backend mimarisini genel hatlarıyla anlamak isteyen her geliştirici için değerli bir temel oluşturur. Bu kavramları Python veya Java üzerinden uygulamalı biçimde pekiştirmek isterseniz birebir Python ve Java özel ders programı ile kendi hızınızda ve hedefinize uygun bir öğrenme yolu izleyebilirsiniz.