C# ve .NET [3]

Giriş: Programlara Mantık ve Yön Verme Bir program sadece veri saklamakla kalmaz, aynı zamanda bu verilerle mantıksal işlemler yapar, kararlar alır ve belirli görevleri tekrarlar. C#’ta bu yetenekleri bize sağlayan temel araçlar operatörler ve kontrol akışı deyimleridir. Operatörler: Değerler (operanlar) üzerinde belirli işlemleri gerçekleştiren semboller veya anahtar kelimelerdir. Matematiksel hesaplamalar (+, -), değer atama (=), karşılaştırma (==, >), mantıksal birleştirme (&&, ||) gibi temel eylemleri gerçekleştirirler. Kontrol Akışı Deyimleri: Programın normalde yukarıdan aşağıya doğru olan doğrusal akışını değiştiren yapılardır. Belirli koşullara göre farklı kod yollarını seçmemizi (if, switch) veya belirli kod bloklarını tekrar tekrar çalıştırmamızı (for, while) sağlarlar. Bu iki temel yapı, programlarımıza karar verme yeteneği, tekrarlama gücü ve dinamizm kazandırır. Bölüm 1: C# Operatörleri C#’ta çeşitli kategorilerde birçok operatör bulunur. 1.1. Aritmetik Operatörler: Sayısal tipler ( int, double, float, decimal vb.) üzerinde temel matematiksel işlemleri yaparlar. Toplama (+): İki sayıyı toplar. String’ler için birleştirme (concatenation) yapar. int toplam = 5 + 3; // 8 double dToplam = 4.5 + 2.1; // 6.6 string mesaj = "Merhaba" + " " + "C#"; // "Merhaba C#" Çıkarma (-): İlk operandan ikinciyi çıkarır. int fark = 10 - 4; // 6 Çarpma (): İki operanı çarpar. int carpim = 6 7; // 42 Bölme (/): İlk operanı ikinciye böler. Tam Sayı Bölmesi: Eğer her iki operan da tamsayı ise, sonuç da tamsayı olur (ondalık kısım atılır). Kayan Noktalı Bölme: Operanlardan en az biri kayan noktalı ( double, float, decimal) ise, sonuç da kayan noktalı olur. int tamBolme = 10 / 3; // 3 (Ondalık kısım atıldı!) double ondalikliBolme1 = 10.0 / 3; // 3.333... double ondalikliBolme2 = 10 / 3.0; // 3.333... double ondalikliBolme3 = 10.0 / 3.0; // 3.333... // decimal decimalBolme = 10.0m / 3.0m; // 3.333... (daha hassas) // Sıfıra Bölme: Tamsayı bölmesinde DivideByZeroException hatası fırlatır. // Kayan noktalı bölmede Infinity veya NaN döndürür. Modül (Kalan) (%): İlk operanın ikinciye bölümünden kalanı verir int kalan = 10 % 3; // 1 bool ciftMi = (10 % 2 == 0); // true Artırma (++): Operanın değerini 1 artırır (prefix ++x veya postfix x++ — davranışları ifade içindeki değerleri açısından farklıdır). Azaltma ( — ): Operanın değerini 1 azaltır (prefix — x veya postfix x — ). int sayac = 5; sayac++; // sayac şimdi 6 (postfix) ++sayac; // sayac şimdi 7 (prefix) Console.WriteLine(sayac++); // 7 yazdırır, sonra sayac 8 olur Console.WriteLine(++sayac); // sayac önce 9 olur, sonra 9 yazdırır 1.2. Atama Operatörleri: Değişkenlere değer atamak için kullanılırlar. Basit Atama (=): Sağdaki değeri soldaki değişkene atar. int yas = 30; string isim = "Ahmet"; Bileşik Atama Operatörleri: Aritmetik veya bitwise bir işlemi atama ile birleştirir (+=, -=, *=, /=, %=, &=, |=, ^=, =). int skor = 100; skor += 50; // skor = skor + 50; -> skor = 150 skor /= 3; // skor = skor / 3; -> skor = 5 1.3. Karşılaştırma Operatörleri: İki değeri karşılaştırır ve sonuç olarak bool (true veya false) döndürür. Koşullu ifadelerin temelini oluştururlar. Eşitlik (==): İki operanın değeri birbirine eşitse true. Referans tipleri için referansları (adresleri) karşılaştırır, içerikleri değil ( string istisnası vardır, içerik karşılaştırır). Değer tipleri için değerleri karşılaştırır. Eşitsizlik (!=): İki operanın değeri birbirine eşit değilse true. ==’nin tersi mantıkla çalışır. Büyüktür (>): Sol operan sağdan büyükse true. Küçüktür (=): Sol operan sağdan büyük veya eşitse true. Küçük Eşittir ( b); // True Console.WriteLine(b = 18) { Console.WriteLine("Giriş yapıldı ve yaş uygun."); } // || Kullanımı if (adminYetkisi || yasOp > 65) { Console.WriteLine("Admin veya yaşlı kullanıcı."); // yasOp > 65 false olsa da çalışmaz } else { Console.WriteLine("Admin değil ve yaşlı da değil."); } // ! Kullanımı if (!adminYetkisi) { // adminYetkisi false ise true olur Console.WriteLine("Kullanıcı admin değil."); } // Kısa Devre Örneği int? sayi = null; // Eğer sayi null değilse VE değeri 5'ten büyükse... // sayi null olduğu için ilk kısım (sayi != null) false olur, // ikinci kısım (sayi.Value > 5) HİÇ DEĞERLENDİRİLMEZ ve NullReferenceException alınmaz. if (sayi != null && sayi.Value > 5) { Console.WriteLine("Sayı 5'ten büyük."); } else { Console.WriteLine("Sayı null veya 5'ten büyük değil."); } 1.5. Bitwise ve Kaydırma Operatörleri: Tamsayıların ikilik (binary) gösterimleri üzerinde işlem yaparlar (&, |, ^ (XOR), ~ (Tümleyen), > (Sağa Kaydırma)). Genellikle düşük seviyeli programlama, bayrak (flag) yönetimi, donanım etkileşimi veya bazı optimizasyonlar için kullanılırlar. Genel uygulama geliştirmede daha az yaygındırlar. 1.6. Null-Birleştirme Operatörleri: null değerleriyle çalışmayı kolaylaştıran operatörlerdir. Null-Birleştirme Operatörü (??): Sol operan null değilse sol operanın değerini, null ise sağ operanın değerini döndürür. Varsayılan d

Apr 9, 2025 - 11:27

Giriş: Programlara Mantık ve Yön Verme

Bir program sadece veri saklamakla kalmaz, aynı zamanda bu verilerle mantıksal işlemler yapar, kararlar alır ve belirli görevleri tekrarlar. C#’ta bu yetenekleri bize sağlayan temel araçlar operatörler ve kontrol akışı deyimleridir.

Operatörler: Değerler (operanlar) üzerinde belirli işlemleri gerçekleştiren semboller veya anahtar kelimelerdir. Matematiksel hesaplamalar (+, -), değer atama (=), karşılaştırma (==, >), mantıksal birleştirme (&&, ||) gibi temel eylemleri gerçekleştirirler.
Kontrol Akışı Deyimleri: Programın normalde yukarıdan aşağıya doğru olan doğrusal akışını değiştiren yapılardır. Belirli koşullara göre farklı kod yollarını seçmemizi (if, switch) veya belirli kod bloklarını tekrar tekrar çalıştırmamızı (for, while) sağlarlar.
Bu iki temel yapı, programlarımıza karar verme yeteneği, tekrarlama gücü ve dinamizm kazandırır.

Bölüm 1: C# Operatörleri

C#’ta çeşitli kategorilerde birçok operatör bulunur.

1.1. Aritmetik Operatörler:

Sayısal tipler ( int, double, float, decimal vb.) üzerinde temel matematiksel işlemleri yaparlar.

Toplama (+): İki sayıyı toplar. String’ler için birleştirme (concatenation) yapar.
int toplam = 5 + 3; // 8 double dToplam = 4.5 + 2.1; // 6.6 string mesaj = "Merhaba" + " " + "C#"; // "Merhaba C#"
Çıkarma (-): İlk operandan ikinciyi çıkarır.
int fark = 10 - 4; // 6
Çarpma (*): İki operanı çarpar.
int carpim = 6 * 7; // 42
Bölme (/): İlk operanı ikinciye böler.
Tam Sayı Bölmesi: Eğer her iki operan da tamsayı ise, sonuç da tamsayı olur (ondalık kısım atılır).
Kayan Noktalı Bölme: Operanlardan en az biri kayan noktalı ( double, float, decimal) ise, sonuç da kayan noktalı olur.
int tamBolme = 10 / 3; // 3 (Ondalık kısım atıldı!) double ondalikliBolme1 = 10.0 / 3; // 3.333... double ondalikliBolme2 = 10 / 3.0; // 3.333... double ondalikliBolme3 = 10.0 / 3.0; // 3.333... // decimal decimalBolme = 10.0m / 3.0m; // 3.333... (daha hassas) // Sıfıra Bölme: Tamsayı bölmesinde DivideByZeroException hatası fırlatır. // Kayan noktalı bölmede Infinity veya NaN döndürür.
Modül (Kalan) (%): İlk operanın ikinciye bölümünden kalanı verir
int kalan = 10 % 3; // 1 bool ciftMi = (10 % 2 == 0); // true
Artırma (++): Operanın değerini 1 artırır (prefix ++x veya postfix x++ — davranışları ifade içindeki değerleri açısından farklıdır).
Azaltma ( — ): Operanın değerini 1 azaltır (prefix — x veya postfix x — ).
int sayac = 5; sayac++; // sayac şimdi 6 (postfix) ++sayac; // sayac şimdi 7 (prefix) Console.WriteLine(sayac++); // 7 yazdırır, sonra sayac 8 olur Console.WriteLine(++sayac); // sayac önce 9 olur, sonra 9 yazdırır
1.2. Atama Operatörleri:

Değişkenlere değer atamak için kullanılırlar.

Basit Atama (=): Sağdaki değeri soldaki değişkene atar.
int yas = 30; string isim = "Ahmet";
Bileşik Atama Operatörleri: Aritmetik veya bitwise bir işlemi atama ile birleştirir (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=).
int skor = 100; skor += 50; // skor = skor + 50; -> skor = 150 skor /= 3; // skor = skor / 3; -> skor = 5
1.3. Karşılaştırma Operatörleri:

İki değeri karşılaştırır ve sonuç olarak bool (true veya false) döndürür. Koşullu ifadelerin temelini oluştururlar.

Eşitlik (==): İki operanın değeri birbirine eşitse true. Referans tipleri için referansları (adresleri) karşılaştırır, içerikleri değil ( string istisnası vardır, içerik karşılaştırır). Değer tipleri için değerleri karşılaştırır.
Eşitsizlik (!=): İki operanın değeri birbirine eşit değilse true. ==’nin tersi mantıkla çalışır.
Büyüktür (>): Sol operan sağdan büyükse true.
Küçüktür (<): Sol operan sağdan küçükse true.
Büyük Eşittir (>=): Sol operan sağdan büyük veya eşitse true.
Küçük Eşittir (<=): Sol operan sağdan küçük veya eşitse true.
int a = 10, b = 5, c = 10;
string s1 = "Merhaba";
string s2 = "Merhaba";
string s3 = "Dünya";
object obj1 = new object();
object obj2 = new object();
object obj3 = obj1;
Console.WriteLine(a == c); // True (Değerler eşit)
Console.WriteLine(a == b); // False
Console.WriteLine(a != b); // True
Console.WriteLine(a > b); // True
Console.WriteLine(b <= c); // True
Console.WriteLine(s1 == s2); // True (string için içerik karşılaştırması)
Console.WriteLine(s1 == s3); // False
Console.WriteLine(obj1 == obj2); // False (Farklı nesneler, farklı referanslar)
Console.WriteLine(obj1 == obj3); // True (Aynı nesneye referans)
1.4. Mantıksal Operatörler:

Boolean ifadeleri birleştirmek veya tersine çevirmek için kullanılırlar.

Mantıksal AND (&&): Her iki operan da true ise true döndürür. Kısa Devre (Short-circuiting): İlk operan false ise, ikinci operan değerlendirilmez ve doğrudan false döner.
Mantıksal OR (||): Operanlardan en az biri true ise true döndürür. Kısa Devre (Short-circuiting): İlk operan true ise, ikinci operan değerlendirilmez ve doğrudan true döner.
Mantıksal NOT (!): Tek bir boolean operanın değerini tersine çevirir (true ise false, false ise true).
bool kullaniciGirdi = true;
bool adminYetkisi = false;
int yasOp = 25;
// && Kullanımı
if (kullaniciGirdi && yasOp >= 18) {
Console.WriteLine("Giriş yapıldı ve yaş uygun.");
}
// || Kullanımı
if (adminYetkisi || yasOp > 65) {
Console.WriteLine("Admin veya yaşlı kullanıcı."); // yasOp > 65 false olsa da çalışmaz
} else {
Console.WriteLine("Admin değil ve yaşlı da değil.");
}
// ! Kullanımı
if (!adminYetkisi) { // adminYetkisi false ise true olur
Console.WriteLine("Kullanıcı admin değil.");
}
// Kısa Devre Örneği
int? sayi = null;
// Eğer sayi null değilse VE değeri 5'ten büyükse...
// sayi null olduğu için ilk kısım (sayi != null) false olur,
// ikinci kısım (sayi.Value > 5) HİÇ DEĞERLENDİRİLMEZ ve NullReferenceException alınmaz.
if (sayi != null && sayi.Value > 5) {
Console.WriteLine("Sayı 5'ten büyük.");
} else {
Console.WriteLine("Sayı null veya 5'ten büyük değil.");
}
1.5. Bitwise ve Kaydırma Operatörleri:

Tamsayıların ikilik (binary) gösterimleri üzerinde işlem yaparlar (&, |, ^ (XOR), ~ (Tümleyen), << (Sola Kaydırma), >> (Sağa Kaydırma)). Genellikle düşük seviyeli programlama, bayrak (flag) yönetimi, donanım etkileşimi veya bazı optimizasyonlar için kullanılırlar. Genel uygulama geliştirmede daha az yaygındırlar.

1.6. Null-Birleştirme Operatörleri:

null değerleriyle çalışmayı kolaylaştıran operatörlerdir.

Null-Birleştirme Operatörü (??): Sol operan null değilse sol operanın değerini, null ise sağ operanın değerini döndürür. Varsayılan değer atamak için kullanışlıdır.
string? kullaniciIsmi = null; // Nullable string string gosterilecekIsim = kullaniciIsmi ?? "Misafir"; // kullaniciIsmi null olduğu için "Misafir" atanır Console.WriteLine(gosterilecekIsim); // Misafir string? doluIsim = "Ayşe"; string gosterilecekIsim2 = doluIsim ?? "Misafir"; // doluIsim null olmadığı için "Ayşe" atanır Console.WriteLine(gosterilecekIsim2); // Ayşe
Null-Birleştirme Atama Operatörü (??= — C# 8+): Sol operan null ise, sağdaki değeri sol operana atar.
List? sayilarListesi = null; // Eğer sayilarListesi null ise, yeni bir boş liste ata. sayilarListesi ??= new List(); sayilarListesi.Add(10); Console.WriteLine(sayilarListesi.Count); // 1
1.7. Koşullu Null Operatörleri (?., ?[] — C# 6+):

NullReferenceException hatası almadan nesnelerin üyelerine veya dizi elemanlarına güvenli bir şekilde erişmeyi sağlar.

Null Koşullu Üye Erişimi (?.): Operatörün solundaki ifade null ise, tüm ifade null olarak değerlendirilir ve sağdaki üyeye erişilmeye çalışılmaz. Sol taraf null değilse, normal üye erişimi yapılır.
Null Koşullu İndeks Erişimi (?[]): Operatörün solundaki ifade null ise, tüm ifade null olarak değerlendirilir. Değilse, normal indeks erişimi yapılır.
public class Musteri { public Adres? Adresi { get; set; } }
public class Adres { public string? Sokak { get; set; } }
Musteri? musteri1 = new Musteri { Adresi = new Adres { Sokak = "Lale Sok." } };
Musteri? musteri2 = new Musteri { Adresi = null };
Musteri? musteri3 = null;
// Normal Erişim (Hata Riski)
// string sokak1 = musteri1.Adresi.Sokak; // Çalışır
// string sokak2 = musteri2.Adresi.Sokak; // Hata! NullReferenceException (Adresi null)
// string sokak3 = musteri3.Adresi.Sokak; // Hata! NullReferenceException (musteri3 null)
// Null Koşullu Operatör ile Güvenli Erişim
string? sokak1Guvenli = musteri1?.Adresi?.Sokak; // "Lale Sok." (Her adım null değil)
string? sokak2Guvenli = musteri2?.Adresi?.Sokak; // null (Adresi null olduğu için Sokak'a bakılmaz)
string? sokak3Guvenli = musteri3?.Adresi?.Sokak; // null (musteri3 null olduğu için Adresi'ne bakılmaz)
Console.WriteLine($"Sokak 1: {sokak1Guvenli ?? "Bilinmiyor"}");
Console.WriteLine($"Sokak 2: {sokak2Guvenli ?? "Bilinmiyor"}");
Console.WriteLine($"Sokak 3: {sokak3Guvenli ?? "Bilinmiyor"}");
// Dizi örneği
int[]? rakamlar = { 10, 20, 30 };
int? ilkEleman = rakamlar?[0]; // 10
int[]? bosRakamlar = null;
int? olmayanEleman = bosRakamlar?[0]; // null
Bu operatörler, özellikle iç içe geçmiş nesne yapılarında null kontrolleriyle dolu kod yazmaktan kurtarır.

1.8. Diğer Operatörler: typeof, sizeof, is, as, new gibi operatörler de C#’ta önemli rol oynar ancak bu metnin ana odağı dışındadır.

1.9. Operatör Önceliği ve İlişkiselliği:

Bir ifadede birden fazla operatör olduğunda, C# hangi işlemin önce yapılacağını belirlemek için öncelik (precedence) kurallarını kullanır (matematikteki gibi çarpma/bölme toplama/çıkarmadan önce gelir). Aynı önceliğe sahip operatörler için işlem yönünü ilişkisellik (associativity) belirler (genellikle soldan sağa, atama ve koşullu null gibi bazıları sağdan sola).

Kural: Şüpheye düştüğünüzde veya kodun okunabilirliğini artırmak istediğinizde parantez () kullanın. Parantezler önceliği geçersiz kılar ve ifadenin değerlendirme sırasını netleştirir.

Bölüm 2: Kontrol Akışı Deyimleri

Bu deyimler, programın yürütülme sırasını kontrol eder.

2.1. Seçim Deyimleri (Selection Statements): Koşullu Yürütme

if Deyimi: En temel koşullu deyimdir. Bir boolean koşul doğru (true) ise belirli bir kod bloğunu çalıştırır.
int puan = 75; if (puan >= 50) { Console.WriteLine("Tebrikler, geçtiniz!"); // Koşul doğruysa çalışacak birden fazla satır olabilir. }
Tek satırlık ifadelerde {} kullanmak zorunlu olmasa da, okunabilirlik ve hata önleme için her zaman kullanılması önerilir.
if-else Deyimi: if koşulu false ise çalıştırılacak alternatif bir kod bloğu sağlar.
int yasIfElse = 17; if (yasIfElse >= 18) { Console.WriteLine("Ehliyet alabilir."); } else { Console.WriteLine("Ehliyet alamaz."); // Bu çalışır }
if-else if-else Deyimi: Birden fazla koşulu sırayla kontrol etmek için kullanılır. İlk true olan koşulun bloğu çalıştırılır ve yapıdan çıkılır. Hiçbiri doğru değilse (varsa) else bloğu çalışır.
int not = 82; char harfNotu; if (not >= 90) { harfNotu = 'A'; } else if (not >= 80) // 82 >= 80 -> true { harfNotu = 'B'; // Bu çalışır ve yapıdan çıkılır } else if (not >= 70) { harfNotu = 'C'; } else { harfNotu = 'F'; } Console.WriteLine($"Harf Notu: {harfNotu}"); // Harf Notu: B
switch Deyimi: Tek bir ifadenin değerini bir dizi sabit case etiketiyle karşılaştırır. Genellikle belirli ve ayrık değerlere karşı kontrol yaparken if-else if zincirinden daha okunabilir olabilir.
case etiketleri sabit değerler olmalıdır (değişken olamaz).
Eşleşme sırayla kontrol edilir.
Eşleşen bir case bulunduğunda, o bloktaki kod çalıştırılır.
break; ifadesi genellikle her case bloğunun sonuna konulmalıdır. Bu, kontrolün switch yapısından çıkmasını sağlar. break unutulursa, kontrol bir sonraki case’e “düşer” (fall-through) ve o blok da çalışır (istenmeyen bir durum olabilir).
default: etiketi opsiyoneldir ve hiçbir case eşleşmezse çalıştırılacak kodu belirtir.
C# 7.0 ve sonrası: switch ifadeleri desen eşleştirme (pattern matching) ile daha güçlü hale gelmiştir (tür kontrolü, koşullu case’ler — case int n when n > 0: gibi).
int gunNo = 3; string gunAdi; switch (gunNo) { case 1: gunAdi = "Pazartesi"; break; case 2: gunAdi = "Salı"; break; case 3: gunAdi = "Çarşamba"; // Eşleşti break; // Çık case 4: gunAdi = "Perşembe"; break; case 5: gunAdi = "Cuma"; break; case 6: case 7: // Gruplanmış case (fall-through kasıtlı) gunAdi = "Hafta Sonu"; break; default: gunAdi = "Geçersiz Gün Numarası"; break; } Console.WriteLine(gunAdi); // Çarşamba // C# 8+ Switch İfadesi (Expression) - Daha kısa string gunAdiSwitchExpr = gunNo switch { 1 => "Pazartesi", 2 => "Salı", 3 => "Çarşamba", 4 => "Perşembe", 5 => "Cuma", 6 or 7 => "Hafta Sonu", // or deseni _ => "Geçersiz Gün Numarası" // _ discard deseni (default gibi) }; Console.WriteLine(gunAdiSwitchExpr); // Çarşamb
2.2. Döngü Deyimleri (Iteration Statements): Tekrarlanan İşlemler

Belirli bir kod bloğunu tekrar tekrar çalıştırmak için kullanılırlar.

for Döngüsü: Tekrar sayısının genellikle önceden bilindiği veya bir sayaçla kontrol edildiği durumlar için idealdir.
Sözdizimi: for (başlatıcı; koşul; yineleyici)
// 0'dan 4'e kadar yazdırma for (int i = 0; i < 5; i++) // i=0 -> i<5? Evet -> Yazdır 0 -> i++ (i=1) -> i<5? Evet -> Yazdır 1 -> ... -> i=5 -> i<5? Hayır -> Döngü biter. { Console.WriteLine($"for döngüsü i = {i}"); } // Dizinin elemanları üzerinde gezinme string[] renklerFor = { "Kırmızı", "Yeşil", "Mavi" }; for (int index = 0; index < renklerFor.Length; index++) { Console.WriteLine(renklerFor[index]);
while Döngüsü: Belirli bir boolean koşul true olduğu sürece çalışır. Koşul her iterasyonun başında kontrol edilir. Tekrar sayısı bilinmediğinde kullanışlıdır.
int sayacWhile = 0; while (sayacWhile < 3) { Console.WriteLine($"while döngüsü sayac = {sayacWhile}"); sayacWhile++; // Koşulu değiştiren kod (sonsuz döngüyü önlemek için kritik!) }
do-while Döngüsü: while’a benzer, ancak koşul her iterasyonun sonunda kontrol edilir. Bu, döngü gövdesinin koşul ne olursa olsun en az bir kez çalışmasını garanti eder.
int sayacDo = 5; do { Console.WriteLine($"do-while döngüsü sayac = {sayacDo}"); // Bu en az bir kez çalışır sayacDo++; } while (sayacDo < 5); // Koşul (5 < 5) false, döngü biter. Çıktı sadece ilk satır olur.
foreach Döngüsü: Bir koleksiyonun (dizi, List, Dictionary vb. — IEnumerable arayüzünü uygulayan herhangi bir şey) her bir elemanı üzerinde kolayca gezinmek için kullanılır. İndekslerle uğraşmaya gerek kalmaz, daha okunabilir ve daha az hataya açıktır.
List isimListesi = new List { "Can", "Ece", "Deniz" }; foreach (string adForEach in isimListesi) { Console.WriteLine($"Hoş geldin, {adForEach}!"); } // Dictionary üzerinde gezinme Dictionary yaslar = new Dictionary { {"Ali", 30}, {"Ayşe", 25} }; foreach (KeyValuePair cift in yaslar) { Console.WriteLine($"{cift.Key}, {cift.Value} yaşında."); } // veya var ile foreach (var cift in yaslar) { Console.WriteLine($"{cift.Key}: {cift.Value}"); }
Not: foreach döngüsü içinde koleksiyonun kendisini (eleman ekleyip çıkararak) doğrudan değiştiremezsiniz, bu bir çalışma zamanı hatası (InvalidOperationException) verir.
2.3. Atlama Deyimleri (Jump Statements): Akışı Yönlendirme

Döngülerin veya switch yapılarının normal akışını değiştirmek için kullanılırlar.

break;: İçinde bulunduğu en yakın switch ifadesini veya döngü deyimini (for, while, do-while, foreach) anında sonlandırır. Kontrol, ilgili yapıdan sonraki ilk ifadeye geçer.
// İlk çift sayıyı bul ve döngüyü bitir int[] sayilarBreak = { 1, 3, 5, 4, 7, 9 }; foreach (int sayi in sayilarBreak) { if (sayi % 2 == 0) { Console.WriteLine($"İlk çift sayı bulundu: {sayi}"); break; // Döngüyü sonlandır } }
continue;: İçinde bulunduğu döngünün mevcut iterasyonunun geri kalanını atlar ve döngünün bir sonraki iterasyonuna geçer. switch içinde kullanılamaz.
// 0-9 arası tek sayıları yazdırma for (int i = 0; i < 10; i++) { if (i % 2 == 0) // Eğer sayı çift ise { continue; // Bu iterasyonun geri kalanını atla (Console.WriteLine'ı atlar) } Console.WriteLine($"Tek sayı: {i}"); }
return;: Bir metodun çalışmasını sonlandırır ve kontrolü metodu çağıran yere geri döndürür. Eğer metot void değilse, return ile bir değer döndürülmelidir. Döngü içinde kullanılırsa, hem döngüyü hem de metodu sonlandırır.
goto;: Kontrolü program içinde belirli bir etikete (label) yönlendirir. Kesinlikle önerilmez, çünkü “spagetti kod” denilen anlaşılması ve bakımı çok zor kod yapılarına yol açar. Modern C#’ta neredeyse hiçbir geçerli kullanım alanı yoktur.
Bölüm 3: Sonuç — Yapı ve Mantığın İnşası

C# operatörleri ve kontrol akışı deyimleri, dilin temel mantıksal ve yapısal yeteneklerini sağlar. Operatörler, veriler üzerinde çeşitli işlemler (aritmetik, atama, karşılaştırma, mantıksal) yapmamızı sağlarken, kontrol akışı deyimleri ( if-else, switch, for, while, do-while, foreach, break, continue) programın hangi kod parçalarını, ne zaman ve hangi koşullar altında çalıştıracağını belirlememize olanak tanır.

Bu temel yapılara hakim olmak, C# ile problem çözmenin, algoritmalar geliştirmenin ve anlamlı uygulamalar oluşturmanın ilk adımıdır. Operatör önceliğini anlamak (veya parantez kullanmak), doğru karşılaştırma operatörünü seçmek (== vs === yanılgısı C#’ta yoktur, ancak referans/değer karşılaştırmasına dikkat!), kısa devre davranışını bilmek, döngü koşullarını doğru ayarlamak ve break/continue’yu yerinde kullanmak, temiz, verimli ve hatasız kod yazmak için kritik öneme sahiptir. Bu temel yapılar üzerine inşa edilen metotlar, sınıflar, arayüzler ve diğer C# özellikleri ile daha karmaşık ve güçlü uygulamalar geliştirmek mümkün hale gelir.

Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Kişisel WebSite
Abdulkadir Güngör - Özgeçmiş
Github
Github
Linkedin