Flutter Widget Yaşam Döngüsü: Her Geliştiricinin Bilmesi Gereken Detaylar

uslame · Dün 13:29 da

Giriş

Flutter, deklaratif UI yapısıyla widget'lar üzerine inşa edilmiştir. Bir Flutter uygulamasında gördüğünüz her şey bir widget'tır. Bu widget'lar oluşturulur, güncellenir ve yok edilirken belirli bir 'yaşam döngüsü' içinden geçerler. Bu döngüyü anlamak, uygulamanızın performansını optimize etmek, hafıza sızıntılarını önlemek ve beklenmeyen davranışları gidermek için kritik öneme sahiptir. Bu yazıda, Flutter widget'larının, özellikle de StatefulWidget'ların yaşam döngüsünü derinlemesine inceleyeceğiz.

Flutter'ın resmi dokümantasyonuna göre, widget'lar uygulamanızın temel yapı taşlarıdır. Onların yaşam döngüsünü yönetmek, daha sağlam ve verimli uygulamalar geliştirmenizi sağlar.

StatelessWidget Yaşam Döngüsü: Basit ve Doğrusal

StatelessWidget'lar, herhangi bir dahili durumu olmayan widget'lardır. Bir kez oluşturulduktan sonra konfigürasyonları değişmez. Bu nedenle, yaşam döngüleri oldukça basittir:

Oluşturulma: Widget ilk kez oluşturulur.
build(): Widget'ın kullanıcı arayüzünü (UI) tanımlayan
Kod:
```
build()
```
metodu çağrılır. Bu metod, widget'ın bağımlılıkları değiştiğinde veya üst widget yeniden inşa edildiğinde tekrar çağrılabilir.
Yok Olma: Widget ağaçtan kaldırıldığında yok edilir.

Unutmayın: StatelessWidget'ların herhangi bir 'state'i olmadığı için setState() gibi bir mekanizmaya da ihtiyaç duymazlar. Verileri dışarıdan alırlar ve aldıkları verilere göre kendilerini çizerler.

StatefulWidget Yaşam Döngüsü: Detaylı Bir Bakış

StatefulWidget'lar, zamanla değişebilen bir duruma (state) sahip olan widget'lardır. Bu durum, widget'ın ömrü boyunca saklanır ve kullanıcı etkileşimleri veya diğer olaylar sonucunda değişebilir. StatefulWidget'ın kendisi değişmezken, onunla ilişkili State nesnesi yaşam döngüsünün büyük bir kısmını yönetir.

createState()
Widget ağacına bir StatefulWidget eklendiğinde, Flutter hemen
Kod:
```
createState()
```
metodunu çağırır. Bu metod, widget ile ilişkili olan State nesnesini döndürmekten sorumludur. Her widget örneği için yalnızca bir kez çağrılır.
Kod:
```
    class MyCounterWidget extends StatefulWidget {
      @override
      State<MyCounterWidget> createState() => _MyCounterWidgetState();
    }
```
initState()
State nesnesi oluşturulduktan sonra, Flutter
Kod:
```
initState()
```
metodunu çağırır. Bu metod, State nesnesinin ömrü boyunca yalnızca bir kez çağrılan ilk başlatma noktasıdır. Genellikle şu amaçlarla kullanılır:
- State değişkenlerini başlatmak.
- Controller'ları (örneğin, TextEditingController, ScrollController) başlatmak.
- Stream veya ChangeNotifier dinleyicilerini kaydetmek.
- Ağ istekleri gibi tek seferlik veri çekme işlemleri yapmak.
Kod:
```
    class _MyCounterWidgetState extends State<MyCounterWidget> {
      int _counter = 0;

      @override
      void initState() {
        super.initState();
        print('initState çağrıldı: State başlatıldı.');
        // Genellikle burada tek seferlik kurulumlar yapılır.
      }
      // ... diğer metodlar
    }
```
didChangeDependencies()
Kod:
```
initState()
```
metodundan hemen sonra çağrılır. Ayrıca, bu State nesnesinin bağımlılıkları değiştiğinde de çağrılır. Özellikle InheritedWidget kullanıyorsanız ve bu InheritedWidget'dan gelen verilere bağımlıysanız bu metot çok önemlidir. InheritedWidget'ın değeri değiştiğinde, onu kullanan tüm widget'ların
Kod:
```
didChangeDependencies()
```
metodu çağrılır. Bu metot,
Kod:
```
build
```
metodundan önce çağrıldığı için, bağımlılıklara göre State'i güncellemek için güvenli bir yerdir.

build()
Bu metot, widget'ın kullanıcı arayüzünü tanımlayan temel metottur. Widget'ın durumunda bir değişiklik olduğunda (örneğin,

Kod:

setState()

çağrıldığında) veya üst widget yeniden inşa edildiğinde tekrar çağrılır.

Kod:

build()

metodu saf olmalı, yani herhangi bir yan etki (side-effect) içermemeli ve yalnızca widget'ın güncel durumuna göre UI'yi döndürmelidir.

Kod:

    @override
    Widget build(BuildContext context) {
      print('build çağrıldı: UI güncelleniyor.');
      return Scaffold(
        appBar: AppBar(title: Text('Sayacım')),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Text('Sayacın değeri:'),
              Text(
                '$_counter',
                style: Theme.of(context).textTheme.headlineMedium,
              ),
            ],
          ),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () {
            setState(() {
              _counter++;
            });
          },
          child: Icon(Icons.add),
        ),
      );
    }

didUpdateWidget(covariant T oldWidget)
Eğer üst widget (parent) widget'ı yeniden oluşturursa ve bu widget'ın türü (runtimeType) aynı kalırsa, Flutter eski widget referansını içeren
Kod:
```
didUpdateWidget()
```
metodunu çağırır. Bu metot, yeni widget konfigürasyonuna göre State'i güncellemek için kullanılır. Örneğin, widget'a parametre olarak geçen bir ID değiştiğinde, yeni ID'ye göre veri çekmek için burayı kullanabilirsiniz. Bu metotta
Kod:
```
super.didUpdateWidget(oldWidget)
```
çağırmayı unutmayın.
Kod:
```
    @override
    void didUpdateWidget(covariant MyCounterWidget oldWidget) {
      super.didUpdateWidget(oldWidget);
      print('didUpdateWidget çağrıldı: Widget güncellendi.');
      // if (widget.someProperty != oldWidget.someProperty) {
      //   // Özellik değiştiyse ilgili State'i güncelle
      // }
    }
```
setState(VoidCallback fn)
Bu aslında bir yaşam döngüsü metodu değil, bir mekanizmadır. State nesnesinin durumunu değiştirmek istediğinizde
Kod:
```
setState()
```
metodunu çağırırsınız. Bu metod, içindeki
Kod:
```
fn
```
fonksiyonunu çalıştırır ve ardından Flutter'a bu widget'ın yeniden çizilmesi (yani
Kod:
```
build()
```
metodunun tekrar çağrılması) gerektiğini bildirir.
Kod:
```
    void _incrementCounter() {
      setState(() {
        _counter++;
        print('setState çağrıldı: Sayacın değeri $_counter oldu.');
      });
    }
```
deactivate()
Widget ağacından geçici olarak kaldırıldığında bu metot çağrılır. Bu, bir widget'ın bir subtree'den kaldırılıp başka bir yere taşınması gibi durumlarda meydana gelebilir. Eğer widget tekrar ağaca eklenirse, State nesnesi aynı kalır ve
Kod:
```
build()
```
metodu tekrar çağrılır. Aksi takdirde,
Kod:
```
dispose()
```
çağrılacaktır.
Kod:
```
    @override
    void deactivate() {
      print('deactivate çağrıldı: Widget geçici olarak kaldırıldı.');
      super.deactivate();
    }
```
dispose()
State nesnesi kalıcı olarak yok edilmek üzereyken bu metot çağrılır. Bu, widget'ın artık kullanılmadığı ve hafızadan tamamen kaldırılacağı anlamına gelir.
Kod:
```
dispose()
```
metodu,
Kod:
```
initState()
```
içinde başlatılan tüm kaynakların (controller'lar, stream abonelikleri, animasyonlar, vs.) serbest bırakılması için çok önemlidir. Aksi takdirde hafıza sızıntılarına yol açabilirsiniz.
Kod:
```
    @override
    void dispose() {
      print('dispose çağrıldı: State kalıcı olarak yok ediliyor.');
      // Tüm controller'ları ve stream'leri burada kapatın.
      // _myTextController.dispose();
      super.dispose();
    }
```

Önemli İpuçları ve En İyi Uygulamalar

initState'te setState Çağırmayın:
Kod:
```
initState()
```
içinde
Kod:
```
setState()
```
çağırmak genellikle bir kod kokusudur ve hata ayıklamayı zorlaştırabilir. Eğer bir başlangıç durumu güncellemesi gerekiyorsa, bunu
Kod:
```
initState()
```
içinde doğrudan State değişkenlerini değiştirerek yapın.
Dispose Metodunu Eksik Etmeyin:
Kod:
```
initState()
```
içinde başlattığınız her şeyi
Kod:
```
dispose()
```
içinde temizlediğinizden emin olun. Bu, özellikle TextEditingController, ScrollController gibi kaynaklar için geçerlidir.
build Metodunu Saf Tutun:
Kod:
```
build()
```
metodu, State'i doğrudan değiştirmemeli veya ağ istekleri gibi yan etkiler içermemelidir. Sadece mevcut State'e dayanarak UI'yi çizmelidir.
didUpdateWidget ve Key Kullanımı: Eğer widget'ın ağaçtaki sırası değişirse ancak aynı türde başka bir widget ile yer değiştirirse
Kod:
```
didUpdateWidget
```
işe yarar. Ancak widget tamamen farklı bir türle değiştirilirse eski State yok edilir ve yeni bir State oluşturulur. Flutter'ın widget ağacını nasıl eşleştirdiğini anlamak için Key kullanımı hakkında bilgi edinmek faydalıdır.

Flutter'da performansın anahtarlarından biri, build() metodunun gereksiz yere çağrılmasını önlemektir. Yaşam döngüsünü iyi anlamak, bu optimizasyonları yapabilmeniz için size yol gösterir.

Sonuç

Flutter widget yaşam döngüsünü anlamak, yalnızca 'sihirli' bir çerçeveyi değil, arkasındaki mantığı kavramak anlamına gelir. Bu bilgi, daha karmaşık uygulamalar geliştirirken sizi güçlü kılar, hataları daha hızlı ayıklamanıza olanak tanır ve uygulamanızın daha verimli çalışmasını sağlar. Her bir metodun ne zaman ve neden çağrıldığını bilmek, Flutter geliştirme yolculuğunuzda size önemli bir avantaj sağlayacaktır. Bu konuyu iyice özümseyerek daha bilinçli ve yetkin bir Flutter geliştiricisi olabilirsiniz.