C# Döngüler: for, while ve do-while ile Tekrarlı İşlemler

Programlamada, belirli bir işlemi birden fazla kez tekrarlamak sıkça karşılaşılan bir ihtiyaçtır. Bir listenin tüm elemanlarını işlemek, kullanıcıdan geçerli bir giriş alana kadar beklemek veya belirli bir koşul sağlanana kadar bir dizi komutu çalıştırmak gibi senaryolarda döngüler devreye girer. Bu makalede, C# döngüler konusunu derinlemesine inceleyeceğiz: for, while ve do-while döngülerinin ne işe yaradığını, nasıl kullanıldığını, pratik ipuçlarını, yaygın hataları ve performans etkilerini öğreneceksiniz.

C# Döngüler Nedir?

Programlamanın temel taşlarından olan C# döngüler, belirli bir kod bloğunu, tanımlanmış bir koşul doğru olduğu sürece veya belirli bir sayıda tekrarlamak için kullanılır. Bu sayede, aynı kod satırlarını tekrar tekrar yazmak yerine daha düzenli, okunabilir ve verimli kodlar oluşturabiliriz. C# dilinde başlıca üç tür döngü bulunur: for, while ve do-while.

for Döngüsü

for döngüsü, genellikle bir işlemi belirli bir sayıda tekrarlamanız gerektiğinde en uygun seçimdir. Döngünün kaç kez çalışacağını önceden bildiğiniz durumlarda idealdir.

for Döngüsü Yapısı

for (başlatma; koşul; artırma/azaltma)
{
    // Döngü içinde çalışacak kod bloğu
}

• Başlatma (Initialization): Döngü başlamadan önce bir kez çalışan kısımdır. Genellikle döngü değişkeni burada tanımlanır ve başlangıç değeri atanır (örn: int i = 0;).
• Koşul (Condition): Her iterasyonun başında kontrol edilen mantıksal ifadedir. Koşul true olduğu sürece döngü devam eder. false olduğunda döngü sona erer.
• Artırma/Azaltma (Iterator): Her iterasyon sonunda çalışan kısımdır. Genellikle döngü değişkeninin değerini artırmak veya azaltmak için kullanılır (örn: i++, i--).

for Döngüsü Örneği

0’dan 4’e kadar sayıları ekrana yazdıran bir for döngüsü:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Sayı: " + i);
}
/* Çıktı:
Sayı: 0
Sayı: 1
Sayı: 2
Sayı: 3
Sayı: 4
*/

while Döngüsü

while döngüsü, belirli bir koşul doğru olduğu sürece kod bloğunu tekrarlar. Döngünün kaç kez çalışacağını önceden bilmediğiniz, ancak bir koşulun sağlanmasını beklediğiniz durumlarda kullanışlıdır.

while Döngüsü Yapısı

while (koşul)
{
    // Döngü içinde çalışacak kod bloğu
    // Koşulu etkileyecek bir değişiklik burada yapılmalı
}

• Koşul (Condition): Döngüye girmeden önce ve her iterasyonun başında kontrol edilen mantıksal ifadedir. Koşul true olduğu sürece döngü devam eder.

while Döngüsü Örneği

Kullanıcı ‘çıkış’ yazana kadar giriş almaya devam eden bir while döngüsü:

string giris = "";
while (giris != "çıkış")
{
    Console.WriteLine("Bir şeyler yazın ('çıkış' yazarak çıkın): ");
    giris = Console.ReadLine();
    Console.WriteLine("Yazdınız: " + giris);
}
Console.WriteLine("Döngüden çıkıldı.");

do-while Döngüsü

do-while döngüsü de bir koşul doğru olduğu sürece çalışır, ancak while döngüsünden önemli bir farkı vardır: Kod bloğu, koşul kontrol edilmeden önce en az bir kez çalıştırılır. Bu, döngüye her zaman en az bir kez girilmesi gereken durumlar için idealdir.

do-while Döngüsü Yapısı

do
{
    // Döngü içinde çalışacak kod bloğu
    // Koşulu etkileyecek bir değişiklik burada yapılmalı
} while (koşul);

do-while Döngüsü Örneği

Kullanıcı geçerli bir sayı girene kadar sormaya devam eden bir do-while döngüsü:

int secim;
do
{
    Console.WriteLine("Lütfen 1 ile 3 arasında bir sayı girin:");
    string girilenDeger = Console.ReadLine();
    int.TryParse(girilenDeger, out secim);
} while (secim < 1 || secim > 3);
Console.WriteLine("Geçerli bir sayı girdiniz: " + secim);

Döngü Kontrol Deyimleri: break ve continue

C# döngüler içinde akışı kontrol etmek için break ve continue anahtar kelimelerini kullanabiliriz.

• break: İçinde bulunduğu döngüyü anında sonlandırır ve döngüden sonraki ilk komuta atlar.
• continue: Mevcut iterasyonu atlar ve döngünün bir sonraki iterasyonuna geçer (döngü koşulu tekrar kontrol edilir).

break ve continue Örneği

for (int i = 0; i < 10; i++)
{
    if (i == 3)
    {
        Console.WriteLine("3'ü atla (continue)");
        continue; // 3'ü yazmadan bir sonraki iterasyona geçer
    }
    if (i == 7)
    {
        Console.WriteLine("7'de döngüyü bitir (break)");
        break; // Döngüyü tamamen sonlandırır
    }
    Console.WriteLine("Sayı: " + i);
}
/* Çıktı:
Sayı: 0
Sayı: 1
Sayı: 2
3'ü atla (continue)
Sayı: 4
Sayı: 5
Sayı: 6
7'de döngüyü bitir (break)
*/

Pratik İpuçları

Bu bölümde, C# döngüler ile çalışırken işinize yarayacak bazı pratik ipuçlarına değineceğiz.

1. Sonsuz Döngülerden Kaçının

Döngü koşulunun her zaman true kalması, programınızın kilitlenmesine neden olan bir sonsuz döngü oluşturur. while ve do-while döngülerinde, döngü içinde koşulu false yapacak bir mekanizmanın olduğundan emin olun. for döngülerinde ise iteratörün doğru çalıştığını kontrol edin.

// KÖTÜ ÖRNEK: Sonsuz döngü
// int i = 0;
// while (i < 5)
// {
//     Console.WriteLine(i);
//     // i++ unutuldu!
// }

2. Hangi Döngüyü Ne Zaman Kullanmalı?

• for: Döngünün kaç kez çalışacağını (iterasyon sayısını) kesin olarak bildiğinizde kullanın. (Örn: bir dizinin tüm elemanlarını gezmek).
• while: Döngünün ne zaman biteceğini belirli bir koşulun sağlanmasına bağlı olarak bilmediğinizde kullanın. (Örn: kullanıcıdan doğru giriş alana kadar beklemek).
• do-while: Döngü kod bloğunun en az bir kez çalışmasını garantilemeniz gerektiğinde kullanın. (Örn: menü seçimi veya ilk doğrulama).
• foreach (Bonus İpucu): Koleksiyonlar (diziler, listeler vb.) üzerinde kolayca gezinmek için tasarlanmıştır. Çoğu durumda, bir koleksiyonun tüm elemanlarını işlemek için for yerine foreach kullanmak daha okunabilir ve güvenlidir.

// foreach örneği
string[] isimler = { "Ali", "Ayşe", "Veli" };
foreach (string isim in isimler)
{
    Console.WriteLine("Merhaba, " + isim);
}

3. İç İçe Döngüler

Bazen bir döngü içinde başka bir döngü kullanmanız gerekebilir. Bu, özellikle iki boyutlu diziler (matrisler) veya karmaşık desenler oluştururken faydalıdır.

for (int i = 0; i < 3; i++) // Dış döngü (satırlar)
{
    for (int j = 0; j < 3; j++) // İç döngü (sütunlar)
    {
        Console.Write($"({i},{j}) ");
    }
    Console.WriteLine(); // Her satır bitiminde yeni satıra geç
}
/* Çıktı:
(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)
(2,0) (2,1) (2,2)
*/

İç içe döngüler performans açısından dikkatli kullanılmalıdır, çünkü iterasyon sayısı katlanarak artar (örn: N x M).

Yaygın Hatalar ve Çözümleri

Her programlama konusunda olduğu gibi, C# döngüler kullanırken de bazı yaygın hatalar yapılabilir. İşte bunlardan bazıları ve çözümleri:

1. Sonsuz Döngü

Hata: while veya do-while döngüsünde koşulun asla false olmaması, ya da for döngüsünde iteratörün yanlış ayarlanması.
Çözüm: Döngü koşulunu dikkatlice kontrol edin ve döngü içinde koşulu false yapacak bir mekanizma (örn: değişken güncelleme, break) olduğundan emin olun.

2. Döngü Değişkenini Güncellememek (while/do-while)

Hata: while veya do-while döngülerinde, döngü koşulunu etkileyen değişkenin döngü içinde güncellenmemesi sonsuz döngüye yol açar.
Çözüm: Döngü içindeki kod bloğunda, döngü koşulunu bir noktada false yapacak değişken güncellemelerini eklediğinizden emin olun.

3. Off-by-One Hatası

Hata: Döngünün bir fazla veya bir eksik çalışması. Genellikle < yerine <= (veya tam tersi) kullanmaktan ya da başlangıç/bitiş değerlerinde hata yapmaktan kaynaklanır.
Çözüm: Döngü sınırlarını ve koşullarını dikkatlice test edin. Özellikle dizilerle çalışırken 0 tabanlı indekslemeyi unutmayın (Length - 1).

4. Yanlış Kapsam (Scope)

Hata: Döngü içinde tanımlanan bir değişkeni döngü dışında kullanmaya çalışmak.
Çözüm: Döngü dışında erişmeniz gereken değişkenleri döngüden önce tanımlayın.

// Hata örneği:
// for (int i = 0; i < 5; i++) { /* ... */ }
// Console.WriteLine(i); // Hata: 'i' mevcut kapsamda yok

// Doğru kullanım:
int i;
for (i = 0; i < 5; i++) { /* ... */ }
Console.WriteLine(i); // Çalışır (i değeri 5 olur)

Performans ve Optimizasyon Notları

C# döngülerin performansı, özellikle büyük veri kümeleri veya yoğun işlemlerle uğraşırken önemlidir.

• Gereksiz İşlemlerden Kaçının: Döngü içinde her iterasyonda tekrarlanan ve döngüden önce hesaplanabilecek pahalı işlemleri döngü dışına taşıyın. Örneğin, bir koleksiyonun Length veya Count özelliğini her iterasyonda tekrar tekrar almak yerine, döngüden önce bir değişkene atayın.
• Koleksiyon Boyutunu Önceden Belirleme: Dinamik koleksiyonlar (List<T> gibi) kullanırken, eğer son boyutu biliyorsanız, başlangıçta kapasiteyi belirtmek (new List<T>(kapasite)) yeniden boyutlandırma maliyetlerini azaltabilir.
• for vs foreach: Çoğu modern C# senaryosunda foreach, for kadar performanslıdır ve genellikle daha okunabilirdir. Ancak, performansın kritik olduğu ve özellikle eski .NET sürümlerinde veya değer tipleriyle çalışırken for döngüsü bazen mikro-optimizasyon sağlayabilir. Genel olarak, okunabilirlik ve güvenilirlik için foreach tercih edin, ancak performans profilinizde darboğaz tespit ederseniz for döngüsünü deneyebilirsiniz.
• LINQ ve Performans: LINQ (Language Integrated Query) ifadeleri döngüleri daha deklaratif bir şekilde ifade etmenizi sağlar. Ancak, bazı LINQ sorguları ek yük getirebilir ve büyük koleksiyonlarda doğrudan döngülere göre daha yavaş olabilir. Performans kritik senaryolarda LINQ kullanmadan önce test etmek faydalıdır.

Sonuç

for, while ve do-while döngüleri, C# programlamanın temel yapı taşlarından olup, tekrarlı işlemleri yönetmek için güçlü araçlardır. Her birinin kendine özgü kullanım senaryoları vardır ve doğru döngüyü seçmek kodunuzun okunabilirliğini, verimliliğini ve doğruluğunu artırır. Bu makalede ele alınan ipuçları ve yaygın hatalara dikkat ederek, daha sağlam ve performanslı C# uygulamaları geliştirebilirsiniz. Umarız bu kapsamlı rehber, C# döngüler konusundaki bilginizi pekiştirmenize yardımcı olmuştur.