Bölüm 10 — Konu 47: `Stream` Temelleri, `async*`, `yield`

#Future ile Stream Arasındaki Temel Fark

Bir önceki derste Future'ın "gelecekte bir kere gelecek bir değeri" temsil ettiğini öğrenmiştik. Peki ya bir kaynaktan zamanla, birden fazla değer gelecekse? İşte bunun için Stream kullanılır.

Basit bir benzetme:

• Future = bir paket kargo (bir kere gelir, elinde tutarsın)
• Stream = bir haber bülteni aboneliği (zamanla, birden fazla haber gelir)

Stream<int> sayiUret() async* {
  for (int i = 1; i <= 5; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i; // her saniyede bir değer "yayınla"
  }
}

void main() {
  sayiUret().listen((sayi) {
    print("Alınan sayı: $sayi");
  });
}

Çıktı (her biri 1 saniye arayla):

Alınan sayı: 1
Alınan sayı: 2
Alınan sayı: 3
Alınan sayı: 4
Alınan sayı: 5

#async* — Stream Üreten Fonksiyon

Bölüm 10'da async fonksiyonların Future döndürdüğünü öğrenmiştik. async* (yıldızlı versiyon), bunun yerine bir Stream döndüren bir fonksiyon tanımlar:

Stream<int> sayac() async* {
  // fonksiyon gövdesi, zamanla birden fazla değer "yayınlayabilir"
}

Dönüş tipi her zaman Stream<T>'dir — tıpkı async'in her zaman Future<T> döndürmesi gibi.

#yield — Bir Değer "Yayınlamak"

yield, bir Stream'e yeni bir değer eklemenin yoludur — return gibi fonksiyonu sonlandırmaz, sadece bir değeri "dışarı gönderir" ve fonksiyon çalışmaya devam eder:

Stream<String> mesajUret() async* {
  yield "Birinci mesaj";
  await Future.delayed(Duration(seconds: 1));
  yield "İkinci mesaj";
  await Future.delayed(Duration(seconds: 1));
  yield "Üçüncü mesaj";
}

void main() {
  mesajUret().listen((mesaj) {
    print(mesaj);
  });
}

Bu, Bölüm 5'te öğrendiğimiz return'den temelde farklıdır: return, fonksiyonu bir kere sonlandırıp tek bir değer döndürür; yield, fonksiyonu sonlandırmadan art arda birden fazla değer gönderebilir.

#.listen() — Stream'i "Dinlemek"

void main() {
  Stream<int> stream = sayiUret();

  stream.listen(
    (veri) {
      print("Veri geldi: $veri");
    },
    onError: (hata) {
      print("Hata: $hata");
    },
    onDone: () {
      print("Stream tamamlandı!");
    },
  );
}

.listen(), bir Stream'e abone olmanın yoludur. Üç önemli callback (geri çağırma fonksiyonu) alabilir:

• İlk parametre (zorunlu): her yeni veri geldiğinde çalışır.
• onError: stream içinde bir hata oluşursa çalışır.
• onDone: stream tamamen bittiğinde (artık yeni veri gelmeyeceğinde) çalışır.

#Stream'i await for ile Dinleme — async/await Tarzı

.listen() yerine, async/await'e benzer, daha okunabilir bir sözdizimi de kullanılabilir:

Stream<int> sayiUret() async* {
  for (int i = 1; i <= 3; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

void main() async {
  await for (var sayi in sayiUret()) {
    print("Sayı: $sayi");
  }
  print("Stream bitti");
}

await for, Bölüm 3'te öğrendiğimiz for-in döngüsünün asenkron versiyonudur — her yeni değer geldiğinde döngü gövdesi çalışır, stream bitene kadar bu devam eder. Bu, .listen()'e göre genelde daha okunabilir bulunur, özellikle stream'den gelen her değeri sırayla işlemen gerektiğinde.

#Gerçek Dünya Senaryoları — Stream Ne Zaman Kullanılır?

Future, "bir kerelik" asenkron işlemler için uygundur (bir API isteği, bir dosya okuma). Stream ise zamanla tekrar tekrar gelen veriler için kullanılır:

• Kullanıcının yazdığı her karakteri anlık dinlemek (arama kutusu)
• Bir sensörden (konum, ivmeölçer) sürekli veri almak
• Bir sohbet uygulamasında gelen her yeni mesajı dinlemek
• Bir dosyanın, parça parça (chunk chunk) okunması

// Kavramsal örnek — gerçek bir sohbet uygulamasının basitleştirilmiş hali
Stream<String> mesajlariDinle() async* {
  // Gerçek bir uygulamada bu, bir sunucudan gelen WebSocket verisi olurdu
  await Future.delayed(Duration(seconds: 1));
  yield "Ahmet: Merhaba!";
  await Future.delayed(Duration(seconds: 2));
  yield "Ayşe: Selam, nasılsın?";
}

void main() async {
  print("Sohbete katılındı, mesajlar dinleniyor...");
  await for (var mesaj in mesajlariDinle()) {
    print(mesaj);
  }
}

#Stream Hata Yönetimi — try/catch ile

Stream<int> riskliStream() async* {
  yield 1;
  yield 2;
  throw Exception("Stream içinde hata oluştu");
}

void main() async {
  try {
    await for (var deger in riskliStream()) {
      print(deger);
    }
  } catch (e) {
    print("Hata yakalandı: $e");
  }
}

Çıktı:

1
2
Hata yakalandı: Exception: Stream içinde hata oluştu

Bölüm 8'de öğrendiğimiz try/catch, await for ile de tutarlı bir şekilde çalışır — stream içinde bir hata fırlatılırsa, await for döngüsü durur ve hata catch bloğuna düşer.

#Sonlu vs Sonsuz Stream

// Sonlu stream — belirli sayıda değer üretip biter
Stream<int> sonluStream() async* {
  yield 1;
  yield 2;
  yield 3;
} // fonksiyon bittiğinde stream de "tamamlanır" (onDone tetiklenir)

// Sonsuz stream — teorik olarak hiç bitmez (dikkatli kullanılmalı!)
Stream<int> sonsuzStream() async* {
  int sayac = 0;
  while (true) {
    await Future.delayed(Duration(seconds: 1));
    yield sayac++;
  }
}

Bölüm 3'te while (true) için verdiğimiz uyarı burada da geçerli — sonsuz bir stream oluşturursan, onu dinleyen tarafın bir noktada dinlemeyi durdurması (.cancel() ile, bir sonraki konuda değinebiliriz) veya uygulamanın yaşam döngüsüyle yönetilmesi gerekir, aksi halde kaynak sızıntısına (resource leak) yol açabilir.

#🎯 Bu Dersten Çıkarılması Gerekenler

• Stream, zamanla birden fazla değer üreten bir asenkron kaynağı temsil eder (Future'ın aksine, tek bir değer değil).
• async*, bir Stream<T> döndüren fonksiyon tanımlar; yield, fonksiyonu sonlandırmadan bir değer "yayınlar".
• .listen(), bir stream'e abone olmanın temel yoludur; onError ve onDone callback'leri alabilir.
• await for, stream'i for-in'e benzer, okunabilir bir şekilde dinlemenin yoludur.
• try/catch, stream içindeki hataları da senkron kod gibi yakalayabilir.

#📝 Ödevler

• [ ] async* ve yield kullanarak, 1'den 5'e kadar sayıları birer saniye arayla üreten bir Stream yaz, .listen() ile dinle.
• [ ] Aynı Stream'i await for ile dinle, iki yaklaşımı karşılaştır.
• [ ] .listen()'in onDone callback'ini kullanarak, stream tamamlandığında özel bir mesaj yazdır.
• [ ] Bir stream içinde throw ile hata fırlat, try/catch (await for ile) kullanarak yakala.
• [ ] Kendi senaryonu düşün (örn. bir sipariş takip sistemi, sırayla durum güncellemeleri yayınlayan) ve bunu bir Stream ile modelle.

Sıradaki konu: Bölüm 10 — Konu 48: StreamController, Broadcast Stream