Yazılım Geliştirmenin Temel Taşları: Prensipler, Desenler ve Paradigmalar

Bir sınıfın değişmek için sadece tek bir nedeni olmalıdır. Yani, bir sınıf yalnızca tek bir sorumluluğa odaklanmalıdır.

Neden Önemli? Yüksek uyum (cohesion), düşük bağlılık (coupling), anlaşılabilirlik, test edilebilirlik ve bakım kolaylığı sağlar. Değişikliklerin etkisini sınırlar.

Örnek İhlal: Hem kullanıcı veritabanı işlemlerini hem de kullanıcı arayüzü güncellemelerini yapan bir sınıf.

Çözüm: Veritabanı işlemlerini ayrı bir KullaniciRepository sınıfına, arayüz güncellemelerini ayrı bir KullaniciViewModel veya UI sınıfına taşımak.

// SRP Uygulanmış (Konsept)
public class KullaniciRepository { /* Veritabanı işlemleri */ }
public class KullaniciArayuz { /* Arayüz güncelleme */ }
public class KullaniciYonetici
{
    private KullaniciRepository _repo = new KullaniciRepository();
    private KullaniciArayuz _ui = new KullaniciArayuz();
    // Kullanıcı yönetimi mantığı burada, diğer sorumlulukları delege eder
}
                    

Yazılım varlıkları genişletilmeye açık, ancak değiştirilmeye kapalı olmalıdır. Yeni özellikler eklemek için mevcut kodu değiştirmek yerine, yeni kod ekleyerek sistemi genişletebilmeliyiz.

Neden Önemli? Değişiklik riskini azaltır, esneklik ve genişletilebilirlik sağlar, sistemin kararlılığını artırır.

Nasıl Uygulanır? Soyutlama (arayüzler, soyut sınıflar) ve polimorfizm ile. Strateji, Şablon Metot gibi tasarım desenleri yardımcı olur.

Örnek: Farklı rapor türleri (PDF, Excel, CSV) oluşturma. Yeni bir rapor türü (örn. XML) eklenmesi gerektiğinde mevcut raporlama sınıfını değiştirmek yerine, yeni bir XmlRaporOlusturucu sınıfı ekleyip ortak bir IRaporOlusturucu arayüzünü implemente etmek.

public interface IRaporOlusturucu { void Olustur(object veri); }
public class PdfRaporOlusturucu : IRaporOlusturucu { /*...*/ }
public class ExcelRaporOlusturucu : IRaporOlusturucu { /*...*/ }
// Yeni XML raporu için:
public class XmlRaporOlusturucu : IRaporOlusturucu { /*...*/ }

public class RaporlamaServisi
{
    public void RaporYarat(IRaporOlusturucu olusturucu, object data)
    {
        olusturucu.Olustur(data); // Mevcut kod değişmez
    }
}
                    

Alt tipler (subtypes), üst tiplerinin (base types) yerine, programın doğruluğunu bozmadan geçebilmelidir. Alt sınıflar, üst sınıfın beklenen davranışını ve sözleşmesini korumalıdır.

Neden Önemli? Kalıtımın doğru kullanılmasını sağlar, polimorfizmin güvenilirliğini artırır, sistem tutarlılığını korur.

İhlal Örneği: Klasik Kare/Dikdörtgen problemi. Kare, dikdörtgenin yerine geçtiğinde genişlik/yükseklik ayarlama beklentisini bozar.

Çözüm: Kalıtım hiyerarşisini gözden geçirmek, alt sınıfların üst sınıf sözleşmesine uymasını sağlamak.

İstemciler, kullanmadıkları metotları içeren arayüzleri uygulamaya zorlanmamalıdır. Büyük, "şişman" arayüzler yerine küçük, role özgü arayüzler tercih edilmelidir.

Neden Önemli? Gereksiz bağımlılıkları azaltır, uyumu (cohesion) artırır, gereksiz implementasyonları önler, esnekliği artırır.

Örnek: Tek bir IMakine arayüzü yerine IYazdirici, ITarayici, IFaksGonderici gibi ayrı arayüzler tanımlamak. Bir sınıf sadece ihtiyaç duyduğu arayüzleri uygular.

// ISP Uygulanmış (Konsept)
public interface IYazdirici { void Yazdir(string s); }
public interface ITarayici { void Tara(string s); }

public class BasitYazici : IYazdirici { /* ... */ }
public class GelismisMakine : IYazdirici, ITarayici { /* ... */ }
// BasitYazici, kullanmadığı Tara metodunu implemente etmek zorunda kalmaz.
                    

1. Üst seviye modüller, alt seviye modüllere doğrudan bağımlı olmamalıdır. Her ikisi de soyutlamalara bağımlı olmalıdır. 2. Soyutlamalar detaylara bağımlı olmamalıdır. Detaylar soyutlamalara bağımlı olmalıdır. Kısaca, somut implementasyonlara değil, soyut arayüzlere bağımlı olunmalıdır.

Neden Önemli? Gevşek bağlılık (loose coupling) sağlar, esneklik ve değiştirilebilirlik kazandırır, test edilebilirliği artırır.

Nasıl Uygulanır? Arayüzler/Soyut Sınıflar ve Bağımlılık Enjeksiyonu (Dependency Injection - DI) ile.

// DIP Uygulanmış (Konsept)
public interface IVeritabani { void Kaydet(object data); } // Soyutlama
public class SqlVeritabani : IVeritabani { /* ... */ } // Detay
public class OracleVeritabani : IVeritabani { /* ... */ } // Başka bir detay

public class IsMantigi // Üst Seviye Modül
{
    private readonly IVeritabani _db; // Soyutlamaya bağımlı
    public IsMantigi(IVeritabani db) { _db = db; } // DI ile bağımlılık alınır

    public void Calistir(object veri) { _db.Kaydet(veri); }
}

// Kullanım (Composition Root):
// IVeritabani sql = new SqlVeritabani();
// IsMantigi mantik = new IsMantigi(sql); // Bağımlılık dışarıdan verilir
// mantik.Calistir("...");
                    

Değişkenler, fonksiyonlar, sınıflar ve diğer öğeler için açıklayıcı ve niyetini belli eden isimler kullanılmalıdır.

• Kısaltmalardan veya belirsiz isimlerden (a, b, x, data, temp gibi) kaçının.
• İsim, değişkenin/fonksiyonun neyi temsil ettiğini veya ne iş yaptığını anlatmalıdır (örn: gecenSure yerine gecenSureMilisaniye, listeyiAl yerine aktifKullanicilariGetir).
• Tutarlı bir isimlendirme standardı kullanın (örn: Python için snake_case, C# için PascalCase/camelCase).
• Boolean değişkenler için isAktif, hasError gibi isimler tercih edilebilir.

Fonksiyonlar ve metotlar mümkün olduğunca kısa olmalı ve tek bir iş yapmalıdır (SRP'nin fonksiyon seviyesindeki yansıması).

• Bir fonksiyon çok uzuyorsa veya birden fazla iş yapıyorsa, onu daha küçük, odaklı fonksiyonlara ayırmayı düşünün.
• İdeal olarak bir fonksiyon bir ekrana sığmalıdır.
• İç içe geçmiş kontrol yapılarının (if, for, while) derinliğini azaltmaya çalışın.

Yorumlar kodu açıklamak için değil, kodun neden o şekilde yazıldığını veya karmaşık bir iş mantığını açıklamak için kullanılmalıdır. Kodun kendisi ne yaptığını anlatmalıdır.

• Açıklayıcı olmayan veya güncelliğini yitirmiş yorumlardan kaçının.
• Kodu açıklamak yerine, kodu daha okunabilir hale getirmeye çalışın (iyi isimlendirme, kısa fonksiyonlar).
• Yasal uyarılar, TODO notları veya karmaşık algoritmaların özeti gibi durumlar için yorumlar faydalı olabilir.
• Fonksiyon/sınıf/modül belgeleri için docstring (Python) veya XML yorumları (C#) kullanın.

# Kötü Yorum
# i'yi 1 artır
i = i + 1

# İyi Yorum (Nedenini Açıklıyor)
# Veritabanı bağlantı havuzundaki zaman aşımını önlemek için
# periyodik olarak dummy bir sorgu gönderiyoruz.
check_db_connection()
                     

Tutarlı bir kod formatı (girintileme, boşluk kullanımı, satır uzunluğu vb.) kodun okunabilirliğini önemli ölçüde artırır.

• Proje genelinde veya takım içinde ortak bir stil rehberi (PEP 8 gibi) belirleyin ve buna uyun.
• Otomatik kod formatlayıcıları (Prettier, Black, Yapf) kullanarak tutarlılığı sağlayın.

Hataları görmezden gelmeyin. Olası hataları öngörün ve try...except (Python) veya try...catch (C#) blokları ile uygun şekilde yönetin. Hata mesajlarının bilgilendirici olmasına özen gösterin.

Nesne oluşturma mekanizmalarını soyutlayarak, sistemin hangi nesnelerin nasıl oluşturulduğundan bağımsız hale gelmesini sağlarlar.

• Singleton (Tek Nesne): Bir sınıftan sadece tek bir nesne (instance) oluşturulmasını garanti eder ve bu nesneye global bir erişim noktası sağlar. Örnekler: Loglama servisi, konfigürasyon yöneticisi, veritabanı bağlantı havuzu. Dikkatli kullanılmalıdır, global durum ve test zorluğu yaratabilir.

  
  # Singleton Örneği (Basit - Thread safe değil)
  class SingletonLogger:
      _instance = None
      def __new__(cls, *args, **kwargs):
          if not cls._instance:
              cls._instance = super(SingletonLogger, cls).__new__(cls, *args, **kwargs)
              print("Logger instance oluşturuldu.")
          return cls._instance
      def log(self, message): print(f"LOG: {message}")
  
  # logger1 = SingletonLogger() # Logger instance oluşturuldu.
  # logger2 = SingletonLogger() # Tekrar oluşturulmaz
  # logger1.log("Mesaj 1")
  # print(logger1 is logger2) # True
                              

• Factory Method (Fabrika Metodu): Nesne oluşturma işini alt sınıflara delege eden bir metot tanımlar. Hangi sınıfın nesnesinin oluşturulacağına alt sınıflar karar verir. Üst sınıf sadece nesne oluşturma arayüzünü bilir.
• Abstract Factory (Soyut Fabrika): Birbiriyle ilişkili veya bağımlı nesne ailelerini, somut sınıflarını belirtmeden oluşturmak için bir arayüz sağlar.

Sınıfların ve nesnelerin daha büyük yapılar oluşturmak üzere nasıl birleştirileceğiyle ilgilenirler. Kalıtım ve kompozisyon kullanarak esnek ve verimli yapılar kurmaya odaklanırlar.

• Adapter (Adaptör): Uyumsuz arayüzlere sahip sınıfların birlikte çalışmasını sağlar. Bir sınıfın arayüzünü, istemcinin beklediği başka bir arayüze dönüştürür.
• Decorator (Dekoratör): Bir nesneye, alt sınıflama yapmadan dinamik olarak yeni sorumluluklar (davranışlar) eklemeyi sağlar. Nesneyi bir veya daha fazla sarmalayıcı (decorator) nesne ile sarmalar. Örnek: Stream sınıfları (FileInputStream'i BufferedInputStream ile sarmalamak).

  
  # Decorator Konsepti (Python Decorator'ları ile değil, OOP Decorator deseni)
  class Kahve:
      def maliyet(self): return 5
      def aciklama(self): return "Sade Kahve"
  
  class SutDekorator:
      def __init__(self, kahve_bileseni): self._kahve = kahve_bileseni
      def maliyet(self): return self._kahve.maliyet() + 2
      def aciklama(self): return self._kahve.aciklama() + ", Sütlü"
  
  class SekerDekorator:
      def __init__(self, kahve_bileseni): self._kahve = kahve_bileseni
      def maliyet(self): return self._kahve.maliyet() + 1
      def aciklama(self): return self._kahve.aciklama() + ", Şekerli"
  
  # kahvem = Kahve()
  # print(f"{kahvem.aciklama()} - {kahvem.maliyet()} TL") # Sade Kahve - 5 TL
  # sutlu_kahvem = SutDekorator(kahvem)
  # print(f"{sutlu_kahvem.aciklama()} - {sutlu_kahvem.maliyet()} TL") # Sade Kahve, Sütlü - 7 TL
  # sutlu_sekerli = SekerDekorator(sutlu_kahvem)
  # print(f"{sutlu_sekerli.aciklama()} - {sutlu_sekerli.maliyet()} TL") # Sade Kahve, Sütlü, Şekerli - 8 TL
                              

• Facade (Cephe): Karmaşık bir alt sistem için basitleştirilmiş tek bir arayüz sağlar. İstemcinin alt sistemin karmaşıklığıyla uğraşmasını engeller.
• Proxy (Vekil): Başka bir nesneye erişimi kontrol etmek için bir vekil veya yer tutucu nesne sağlar. Erişim kontrolü, tembel başlatma (lazy initialization), loglama gibi amaçlarla kullanılabilir.

Nesneler arasındaki etkileşim algoritmaları ve sorumluluk dağılımı ile ilgilenirler. Nesnelerin nasıl işbirliği yapacağını ve iletişim kuracağını tanımlarlar.

• Observer (Gözlemci): Bir nesnede (Subject/Publisher) bir değişiklik olduğunda, ona bağımlı olan diğer nesnelerin (Observers/Subscribers) otomatik olarak bilgilendirilmesini ve güncellenmesini sağlayan bir mekanizma tanımlar. Olay tabanlı sistemlerde sıkça kullanılır.
• Strategy (Strateji): Bir algoritma ailesi tanımlar, her birini ayrı bir sınıfta kapsüller ve onları birbirinin yerine kullanılabilir hale getirir. Algoritmanın istemciden bağımsız olarak değiştirilmesini sağlar. OCP'yi uygulamak için iyi bir yoldur.

  
  # Strategy Deseni Konsepti
  from abc import ABC, abstractmethod
  
  # Strategy Arayüzü
  class ISiralamaStratejisi(ABC):
      @abstractmethod
      def sirala(self, veri): pass
  
  # Somut Stratejiler
  class HizliSiralama(ISiralamaStratejisi):
      def sirala(self, veri): print("Hızlı sıralama kullanılıyor..."); return sorted(veri)
  class BaloncukSiralama(ISiralamaStratejisi):
      def sirala(self, veri): print("Baloncuk sıralama kullanılıyor..."); return sorted(veri, reverse=True) # Basit örnek
  
  # Context Sınıfı
  class VeriSiralayici:
      def __init__(self, strateji: ISiralamaStratejisi):
          self._strateji = strateji
      def set_strateji(self, strateji: ISiralamaStratejisi):
          self._strateji = strateji
      def sirala_ve_goster(self, veri):
          sirali_veri = self._strateji.sirala(veri)
          print(f"Sıralı Veri: {sirali_veri}")
  
  # Kullanım
  # data = [5, 1, 8, 3]
  # hizli = HizliSiralama()
  # baloncuk = BaloncukSiralama()
  # siralayici = VeriSiralayici(hizli) # Başlangıç stratejisi
  # siralayici.sirala_ve_goster(data)
  # siralayici.set_strateji(baloncuk) # Çalışma zamanında strateji değiştirme
  # siralayici.sirala_ve_goster(data)
                               

• Command (Komut): Bir isteği, isteğin tüm bilgilerini içeren bağımsız bir nesne olarak kapsüller. Bu sayede istekleri parametrelendirebilir, kuyruğa alabilir, loglayabilir ve geri alma (undo) işlemleri uygulayabilirsiniz.
• Template Method (Şablon Metot): Bir algoritmanın iskeletini bir üst sınıfta tanımlar, ancak bazı adımların implementasyonunu alt sınıflara bırakır. Algoritmanın genel yapısını değiştirmeden belirli adımların yeniden tanımlanmasını sağlar.

Tasarım desenleri, tecrübeli geliştiricilerin ortak bir dil konuşmasını sağlar ve karmaşık sorunlara zarif çözümler sunar.

• Diziler (Arrays): Sabit boyutlu, aynı türden elemanları ardışıl bellek bölgelerinde tutar. Index ile hızlı erişim (O(1)) sağlar, ancak ekleme/silme (özellikle ortadan) yavaş olabilir (O(n)).
• Listeler (Lists - Python Lists, C# List, Java ArrayList): Dinamik boyutlu dizilerdir. Eleman ekleme/silme dizilere göre daha esnektir, ancak bazen arka planda yeniden boyutlandırma maliyeti olabilir. Erişimi genellikle hızlıdır (ortalama O(1)).
• Bağlı Listeler (Linked Lists): Elemanların (düğümlerin) birbirine referanslarla bağlandığı yapılardır. Ekleme/silme (özellikle başa/sona veya belirli bir düğümden sonra) hızlıdır (O(1)), ancak belirli bir elemana erişim yavaştır (O(n)).
• Yığınlar (Stacks): LIFO (Last-In, First-Out) prensibiyle çalışır (push ile eklenir, pop ile çıkarılır). Fonksiyon çağrıları, geri alma işlemleri gibi senaryolarda kullanılır.
• Kuyruklar (Queues): FIFO (First-In, First-Out) prensibiyle çalışır (enqueue ile eklenir, dequeue ile çıkarılır). Görev sıralama, BFS algoritması gibi yerlerde kullanılır.
• Sözlükler / Hash Map'ler / Hash Tabloları (Dictionaries - Python dict, C# Dictionary, Java HashMap): Anahtar-değer çiftlerini saklar. Anahtarlar kullanılarak değerlere çok hızlı erişim (ortalama O(1)) sağlar. Veri arama, önbelleğe alma için idealdir.
• Kümeler (Sets - Python set, C# HashSet, Java HashSet): Benzersiz elemanları sırasız olarak tutar. Eleman varlığını kontrol etme (in / Contains) çok hızlıdır (ortalama O(1)).
• Ağaçlar (Trees): Hiyerarşik veri yapılarıdır (örn: İkili Arama Ağaçları - Binary Search Trees, AVL Ağaçları). Verimli arama, ekleme, silme (genellikle O(log n)) ve sıralı veri tutma için kullanılır. Dosya sistemleri, veritabanı indeksleri gibi yerlerde kullanılır.
• Graflar (Graphs): Düğümler (vertices) ve aralarındaki bağlantılardan (edges) oluşan yapılardır. Sosyal ağlar, harita uygulamaları, ağ topolojileri gibi ilişkisel verileri modellemek için kullanılır.

• Algoritma: Belirli bir problemi çözmek için tanımlanmış, sıralı adımlar kümesidir.
• Arama Algoritmaları:
  • Doğrusal Arama (Linear Search): Sırasız bir listede elemanı baştan sona arar (O(n)).
  • İkili Arama (Binary Search): Sıralı bir listede ortadaki elemana bakarak arama uzayını sürekli yarıya indirir (O(log n)). Çok daha verimlidir.
• Sıralama Algoritmaları:
  • Baloncuk Sıralama (Bubble Sort), Seçmeli Sıralama (Selection Sort), Eklemeli Sıralama (Insertion Sort): Basit ama genellikle yavaştır (O(n²)). Küçük veri setleri için kullanılabilir.
  • Birleştirmeli Sıralama (Merge Sort), Hızlı Sıralama (Quick Sort): Daha karmaşık ama çok daha verimlidir (ortalama O(n log n)).
• Big O Notasyonu: Bir algoritmanın girdi boyutu (n) büyüdükçe çalışma süresinin veya bellek kullanımının nasıl arttığını (büyüme oranını) ifade eden matematiksel bir gösterimdir. Algoritmaların verimliliğini karşılaştırmak için kullanılır.
  • O(1): Sabit zaman (girdi boyutundan bağımsız).
  • O(log n): Logaritmik zaman (çok verimli, girdi boyutu arttıkça süre çok az artar - örn. Binary Search).
  • O(n): Doğrusal zaman (girdi boyutuyla orantılı artar - örn. Linear Search).
  • O(n log n): Log-doğrusal zaman (verimli sıralama algoritmaları).
  • O(n²): Karesel zaman (iç içe döngülerde sık görülür, büyük n için yavaşlar).
  • O(2ⁿ): Üstel zaman (çok verimsiz, genellikle kaçınılması gerekir).

Doğru veri yapısını ve algoritmayı seçmek, özellikle büyük veri setleriyle çalışırken uygulamanın performansını önemli ölçüde etkiler.

OOP Avantajları:

• Gerçek dünya problemlerini modellemek için sezgisel olabilir.
• Kapsülleme ile veri gizliliği ve modülerlik sağlar.
• Kalıtım ile kod yeniden kullanımı sağlar (dikkatli kullanılmalı).
• Büyük, karmaşık sistemleri organize etmek için iyi yapılar sunar.

OOP Dezavantajları:

• Değiştirilebilir durum yönetimi karmaşıklaşabilir ve hatalara yol açabilir.
• Kalıtım hiyerarşileri sıkı bağlılık yaratabilir.
• Paralel programlama zor olabilir.
• Çok fazla "boilerplate" kod gerektirebilir.

FP Avantajları:

• Kod daha öngörülebilir ve test edilebilirdir (saf fonksiyonlar sayesinde).
• Paralellik ve eşzamanlılık yönetimi daha kolaydır.
• Daha az yan etki (side effect) olduğu için hata ayıklama kolaylaşabilir.
• Kod genellikle daha kısa ve öz olabilir (yüksek mertebeden fonksiyonlar sayesinde).

FP Dezavantajları:

• Bazı geliştiriciler için başlangıçta öğrenme eğrisi daha dik olabilir (rekürsiyon, monad gibi kavramlar).
• Durumun yoğun olarak değiştiği bazı problemler (örn. UI durumu) için modelleme daha az sezgisel olabilir.
• Performans (sürekli yeni veri yapıları oluşturma nedeniyle) bazı durumlarda optimize edilmelidir.

Günümüzde birçok modern dil (Python, C#, JavaScript, Scala vb.) hem OOP hem de FP özelliklerini destekler. Geliştiriciler genellikle her iki paradigmanın güçlü yanlarını birleştiren hibrit yaklaşımları benimserler.

• Karmaşık durumları ve varlıkları modellemek için OOP yapıları (sınıflar) kullanılabilir.
• Veri dönüşümleri, işlemler ve yan etkisiz hesaplamalar için FP teknikleri (saf fonksiyonlar, map/filter/reduce) tercih edilebilir.
• Değişmez veri yapıları (immutability) kullanmak, hem OOP hem de FP tarzı kodlarda hataları azaltabilir.

Problemin doğasına, takımın tecrübesine ve kullanılan dilin/ekosistemin yeteneklerine göre en uygun yaklaşım veya yaklaşım kombinasyonu seçilmelidir. Kesin sınırlar çizmek yerine, her iki paradigmanın sunduğu araçları bilmek ve duruma göre en uygun olanı kullanmak önemlidir.

• Yanıt Verebilirlik (Responsiveness): Özellikle kullanıcı arayüzü (UI) olan uygulamalarda (web, masaüstü, mobil), uzun süren bir işlem UI iş parçacığını bloke ederse arayüz donar. Asenkron işlemler UI'ın akıcı kalmasını sağlar.
• Verimlilik (Efficiency): Sunucu tarafı uygulamalarda, bir istek bir I/O işlemini beklerken, o iş parçacığı (thread) başka bir isteği işlemek için serbest bırakılabilir. Bu, daha az thread ile daha fazla isteği karşılamayı sağlar ve kaynak kullanımını optimize eder.
• Ölçeklenebilirlik (Scalability): Kaynakları daha verimli kullanan uygulamalar daha kolay ölçeklenebilir.

Asenkron işlemleri yönetmek için farklı dillerde benzer mekanizmalar kullanılır:

• Callback Fonksiyonları: Asenkron işlem bittiğinde çağrılacak bir fonksiyonu işlem başlatan fonksiyona parametre olarak geçme yöntemidir. Basit durumlar için işe yarar ancak iç içe geçmiş işlemler "Callback Hell" sorununa yol açabilir. (JavaScript'te yaygındı).
• Promise'ler / Future'lar / Task'lar: Asenkron bir işlemin gelecekteki sonucunu temsil eden nesnelerdir. İşlemin başarı (resolve) veya başarısızlık (reject) durumunu ve sonucunu taşırlar. .then(), .catch() gibi metotlarla zincirleme işlem yapmayı kolaylaştırırlar. (JavaScript Promise, C# Task/Task, Python asyncio Future/Task).
• async / await Anahtar Kelimeleri: Promise/Task tabanlı asenkron kodu, senkron koda benzer bir şekilde yazmayı sağlayan sözdizimsel kolaylıktır. Kodun okunabilirliğini ve yazımını büyük ölçüde iyileştirir. await, asenkron işlemin sonucunu beklemeden programın akışını bloke etmez, işlemin tamamlanmasını beklerken kontrolü çağırana geri verir. (JavaScript, C#, Python 3.5+).

Örnek (JavaScript - Fetch API ile):

// Promise tabanlı fetch kullanımı
function veriCekPromise() {
    fetch('https://jsonplaceholder.typicode.com/todos/1')
        .then(response => {
            if (!response.ok) { throw new Error('Ağ yanıtı sorunlu'); }
            return response.json(); // Bu da bir Promise döndürür
        })
        .then(data => {
            console.log("Veri (Promise):", data);
        })
        .catch(error => {
            console.error('Hata (Promise):', error);
        });
}

// async/await ile fetch kullanımı (daha okunabilir)
async function veriCekAsyncAwait() {
    try {
        console.log("İstek gönderiliyor...");
        const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');
        console.log("Yanıt alındı, kontrol ediliyor...");
        if (!response.ok) {
            throw new Error(`HTTP Hatası: ${response.status}`);
        }
        console.log("JSON verisi ayrıştırılıyor...");
        const data = await response.json(); // JSON ayrıştırmasını bekle
        console.log("Veri (async/await):", data);
    } catch (error) {
        console.error('Hata (async/await):', error);
    } finally {
        console.log("İşlem tamamlandı (hata olsa da olmasa da).");
    }
}

// veriCekPromise();
// veriCekAsyncAwait();
// console.log("Asenkron işlemler başlatıldı..."); // Bu satır genellikle fetch'lerden önce çalışır
                     

Örnek (C# - HttpClient ile):

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ApiIstemci
{
    private static readonly HttpClient client = new HttpClient();

    public async Task VeriAlAsync(string url)
    {
        try
        {
            Console.WriteLine($"'{url}' adresinden veri alınıyor...");
            // await ile asenkron ağ isteğinin tamamlanmasını bekle
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode(); // Başarısızsa exception fırlatır

            Console.WriteLine("İçerik okunuyor...");
            // await ile içeriğin string olarak okunmasını bekle
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine("Veri başarıyla alındı.");
            return responseBody;
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"\nİstek Hatası: {e.Message}");
            return null;
        }
    }
}

// Kullanım (Başka bir async metot içinde):
// async Task Kullan() {
//     ApiIstemci istemci = new ApiIstemci();
//     string veri = await istemci.VeriAlAsync("https://jsonplaceholder.typicode.com/posts/1");
//     if (veri != null) {
//         Console.WriteLine("\nAlınan Veri (ilk 100 karakter):");
//         Console.WriteLine(veri.Substring(0, Math.Min(veri.Length, 100)) + "...");
//     }
// }
                     

Asenkron programlama, modern, performanslı ve duyarlı uygulamalar geliştirmek için vazgeçilmez bir tekniktir.