8. BÖLÜM : BLOK KONTROL DEYİMLERİ

if Deyimi 

if deyimi, programın akışını verilen koşula bağlı olarak “{ }” işaretleri ile oluşturulan bloktaki satırların işletilmesini veya söz konusu bloğun işletilme­yip atlanılmasını sağlar. 

         if (ifade) 
              { 
                  ....... 
              }        

if deyimine parametre olarak verilen "ifade" mantıksal doğru değerini içeriyorsa “{“ ile “}” arasında yer alan satırlar işletilir. "ifade" false ise bu kez “{“ ile “}”arasında yer alan satırlar atlanıp programın işletimi “}” işaretinden sonra gelen ilk satıra geçer. Parantezin arasına yazılan ifade bool bir sonuç üretmiyorsa hata meydana gelir. Örneğin “if” deyimi aşağıdaki gibi kullanılırsa hata meydana gelir. 

     int Sayi = 100; 
     if (Sayi = 100)  // hata meydana gelir. 
      { 
      } 

‘{‘ ve ‘}’ ile sınırlanan blokta tek satır varsa blok başını ve sonunu belirtmeye gerek kalmaz. Aşağıda verilen örnekte if deyimi ile kurulan blokta 1 satır olma­sına rağmen blok başını ve sonucu işaret ettik. 

    DialogResult onay = MessageBox.Show("Projeden Çıkılsın mı?", 
             "Onay Kutusu", MessageBoxButtons.YesNo); 
    if (onay == DialogResult.Yes) 
     { 
       Application.Exit();  
     } 

Bu kodda önce DialogResult tipinde bir değişken tanımlanıp kullanıcıdan programdan çıkılıp çıkılmayacağı konu­sunda onay alındı. Show() metodu ile ekrana getirilen diyalog kutusundaki Evet düğmesi tıklanırsa “onay” değişkenine “DialogResult.Yes”, Hayır düğmesi tıkladığında ise “DialogResult.No” bilgisi aktarılır. “onay” değişkenine "DialogResult.Yes" sabiti aktarılmışsa if deyimine parametre olarak verilen karşı­laştır­manın sonucu doğru olur ve “{“ ile “}” işaretleri ile bloklanan satırlar işletilir. if deyimi için parantezlerin içinde “==” operatörü ile eşitlik aramak yerine Equal() metodunu kullanabilirsiniz. 

    DialogResult onay = MessageBox.Show("Projeden Çıkılsın mı?", 
              "Onay Kutusu", MessageBoxButtons.YesNo); 
    if (onay.Equals(DialogResult.Yes)) 
      { 
        Application.Exit();  
      } 

“onay” değişkeni ""DialogResult.Yes" değerini içermi­yorsa if ile bloklanan satır işletilmeyip prog­ramın işletimi if bloğundan sonra gelen ilk satıra geçer. Bazen if’e parametre olarak verilen karşılaştırmanın sonucuna bağlı olarak yapılmak istenen birden fazla işlem olabilir. 

    int Puan = Convert.ToInt32(textBox1.Text); 
    if (Puan < 50) 
     {   
        MessageBox.Show("Bu öğrenci zayıf not aldı"); 
     } 
    if (Puan >= 50) 
     { 
       MessageBox.Show("Bu öğrenci geçer not aldı"); 
     } 

Bu kodda kullanılan ilk if deyiminde “Puan” değişke­nin içeriğinin 50’den küçük olup olma­dığı araştırılmak­tadır. if deyimine parametre olarak verilen bu karşılaştırmanın sonucu doğru iken yani “Puan” değişkeni 50’den küçükse bloktaki MessageBox sınıfı ile alınan notun Zayıf olduğunu belirten bir mesaj ekrana verilir. 

Bu örnekteki blokların sayısı istenildiği gibi arttırılıp geçer not alan öğrencinin Orta, İyi ve Pekiyi not alıp almadığını araştırmak mümkündür. Ancak içeriği araştırılan değişke­nin alma olasılığı olan her değer için ayrı bir if bloğu hazırlamak pratik değildir. Şimdi yukarıda verilen ve 2 “if” deyimin kullanıldığı metotla aynı işleve sahip başka bir metot vereceğiz. Bu metotta 2. bir blok hazırlamak yerine else deyiminden yararlandık. 

      if (Puan < 50) 
       { 
         MessageBox.Show("Bu öğrenci zayıf not aldı"); 
       } 
      else 
       { 
         MessageBox.Show("Bu öğrenci geçer not aldı"); 
        } 

Yapılan karşılaştırmada ikiden fazla olasılık varsa birden fazla else deyimi kullanılabilir. Aşağıda verilen blok kalıbında toplam 3 olasılık için karşılaştırma ve karşılaştırmanın sonu­cuna göre işlem görecek 3 blok var. 

         if  (ifade1) 
           { 
             ......... 
           } 
         else if (ifade2) 
           { 
              ........... 
           } 
         else if (ifade3) 
           { 
           }      

Birinci karşılaştırma(ifade1) doğru ise ilk “{“ işaretinin bulunduğu satır ile ilk “}” işaretinin bulunduğu satıra kadar olan satırlar işletilir. Ardından programın işletimi blok sonunu işaret eden “}” işaretinden sonraki satıra geçer. Bu durumda bloktaki else deyimleri ile hazırlanan karşılaştırmaların sonucuna bakılmaz. if deyimine parametre olarak verilen ifade1 yanlış değerine sahipse, bu kez ilk else’ye parametre olarak verilen ifade2’nin sonucuna bakılır. ifade2 doğru değere sahipse, ilk else ile 2. else deyimleri arasında kalan satırlar işletilir. 

? Operatörü 

2 olasılığın söz konusu olduğu karşılaştırmalarda ? operatöründen yararlanabilirsiniz. Bu operatörün nasıl kullanıldığını anlatmak için “if” deyimi ile aşağıda verilen kodu hazırladık. 

    int Borc = Convert.ToInt32(textBox1.Text); 
    if(Borc > 0) 
      MessageBox.Show("Borçlusunuz"); 
    else 
      MessageBox.Show("Borçlu değilsiniz");  

Bu şekilde 2 ihtimalin söz konusu olduğu karşılaştırma işlemleri için “if” yerine aşağıda yapıldığı gibi ? operatörünü kullanabilirsiniz. Karşılaştırmadan sonra önce ? işareti, ardından karşılaştırma doğru olduğunda yapılacak işlem veya işletilecek satır yazılır. Karşılaş­tırma yanlış ise “:” işaretinden sonra yazılan kodlar işletilir. 

    int Borc = Convert.ToInt32(textBox1.Text); 
    stringsonuc=Borc>0 ?"Borçlusunuz":"Borçlu değilsiniz"; 
    MessageBox.Show(sonuc); 

Bu “?” kullanımında “Borc” değişkeni 0’dan büyük ise “Borçlu­sunuz” mesajı verilir. “Borc” değişkeni 0’dan büyük değilse ekrana “Borçlu değilsiniz” mesajı verilir

Switch Case Deyimi 

switch case işlev bakımından if deyimine benzemektedir. Çok sayıda iç içe “if”  bloğu kullanıldığı zaman programın okunurluğu azalır. Bu gibi durumlarda switch case deyi­minden yararlanılması önerilmektedir. İsterseniz if deyimi ile switch case’i birlikte kulla­nabilirsiniz. Switch Case bloklarında break deyiminin kullanılması zorunludur. 

    switch (Kontrol Değişkeni) 
       { 
         case ifade 1 : 
            { 
               ........... 
               break; 
             } 
         case ifade 2 : 
             { 
              ........... 
               break; 
             } 
       } 

Blok başlatan switch deyiminden sonra karşılaştırmalarda kullanılan kontrol değişkeni bulunmaktadır. Bu değişkenin içeriği "ifade1" olarak verilen değerle aynı ise birinci ifadenin içeriğini araştıran case deyiminden sonraki “{“ ve “}” işaretleri arasında kalan satırlar işleti­lir ve programın akışı case ile başlatılan bloğun sonunu işaret eden }’ni izleyen satıra geçer. 

Kontrol değişkeni İfade2’ye eşitse bu kez İfade2'den “{“ ve “}” deyimleri arasındaki satır­lar işletilir. case deyimi ile döngü başlatıldıktan sonra sıra ile bütün "ifade" bulunan satırlar taranır. “ifade” olarak belirtilen bilgi veya bilgiyi temsil eden değişkenin içeriği ile kontrol değişkenin içeriği birbirine eşitse "ifade 2" bulunan satıra kadar olan satırlar işle­tilir. 

int puan = Convert.ToInt32(textBox1.Text);
switch (puan) 
 { 
   case 1: MessageBox.Show("zayıf"); break; 
   case 2: MessageBox.Show("orta"); break; 
   case 3: MessageBox.Show("iyi"); break; 
   case 4: MessageBox.Show("pekiyi"); break; 
   default :MessageBox.Show("Yanlış bilgi girişi");break; 
} 

Kontrol değişkeni case deyiminin yanına yazılanlardan farklı bir değer aldığında yapılmasını istediğiniz işlemler varsa default deyiminden yararlanmalısınız. break deyimi switch bloğun­dan çıkışı sağlayıp programın akışını switch bloğundan sonraki satıra atlatmaktadır. break yerine return deyimini kullanabilirsiniz ama bu durumda metottan çıkılır ve switch bloğunda sonraki satırlar işletilmez. Yukarıda switch deyimine int değişkeni parametre olarak verdik. Kontrol değişkeni olarak string veya başka bir tipte değişkeni kullanabilirsiniz. 

string secim = textBox1.Text;
switch (secim)
{ 
  case "Çıkış" : 
    Application.Exit(); 
    break; 
  case "devam": 
    break;
} 

while Deyimi 

while deyimi, verilen şarta bağlı olarak bloklanan satırların bir döngü halinde tekrar tekrar işletilmesini sağlar. while deyimi ile tekrar tekrar işletilecek satırlar birden fazla ise işletile­cek satırların başına “{”, sonuna ise “}” işaretinin konulması gerekir. 

   while(Koşul) 
     { 
        break 
        ....... 
     } 

breakdeyiminin kullanılması isteğe bağlıdır. while deyimine parametre olarak verilen "koşul" doğru değerine sahip olduğu sürece while ile işaret edilen satırlar tekrar tekrar işletilir. "koşul" yerine mantıksal bir karşılaştırma bir değişken veya tek başına mantıksal doğru(true) veya mantıksal yanlış(false) kullanılabi­lir. while deyiminin genel kullanış biçiminde bulunan ve kullanılması isteğe bağlı olan break deyimi, döngüden "koşul" ile belirtilen şarta bağlı kalmadan çıkmayı sağlar. Genel alışkan­lıkla yalnızca break deyimi ile çıkılacak şekilde oluşturulan do-while döngülerinde "ifade" olarak mantıksal sabit bir değer veya değişken kullanılır. 

         while (True) 
          { 
            if (koşul) 
              break; 
          } 

Bu döngünün her turunda if ile "koşul" test edilir. Koşul yanlış değerini içeriyorsa, dön­güden çıkılarak blok sonunu işaret eden “}” işare­tini izleyen satıra geçilir. Döngü kontrol ifadesi olarak true kullanılması halinde döngüden break deyimi ile çıkılma­dığı sürece döngü sonsuz olur. Bu nedenle yukarıdaki gibi döngülerde mutlaka döngüden çıkabilmek için belirli şartlara bağlı olarak break deyiminin işletilmesi sağlanmalıdır. 

   string takim; 
   while (true) 
    { 
     takim = Microsoft.VisualBasic.Interaction.InputBox("Takim adı girin", "Bilgi girişi", "", 20, 20); 
     if (takim == "Beşiktaş") 
        break; 
    } 

Yukarıda verilen blokta while deyimi ile koşul döngünün başında kontrol edilmektedir. Bu şekilde kullanılan while deyiminden başka C#’ın koşulun döngünün sonunda test edildiği do-while adında bir deyimi daha bulunmaktadır. do-while bloklarında koşul döngü­nün sonunda test edildiği için söz konusu blok en az bir kez işletilir. 

 string takim; 
 do 
  { 
   takim = Microsoft.VisualBasic.Interaction.InputBox("Takim adı girin", "Bilgi girişi", "", 20, 20); 
   if (takim == "Beşiktaş") 
      break; 
  } 
 while (true); 

while veya do-while deyimleri ile kurulan bloktaki satırların sıra ile işletilmesini istemi­yorsa­nız continue ile kodun işletimini tekrar döngünün başına alabilirsi­niz. Aşağıda verilen kodda continue sayesinde 1’den 100’e kadar olan sayıların yalnızca tek olanları toplanır. 

    int toplam = 0; 
    for (int i=1; i<=100; i++) 
     { 
       if (i%2 !=1) continue; 
         toplam = toplam + i; 
     } 
    textBox1.Text = Convert.ToString(toplam);   

for Deyimi 

do–while döngülerinde döngünün kaç kez tekrarlanacağı önceden bilinmez. for döngüle­rinin kaç kez tekrarlanacağı genellikle bellidir. do–while döngüsünde olduğu gibi istenirse belli bir şart dahilinde for döngüsünden her hangi bir anda çıkılabilinir. Kod penceresinde for yazıp 2 kez Tab tuşuna basarsanız  Visual Studio sizin için bir for döngüsü kalıbı hazırlar. 

         for (Döngü Değişkeni = İlk Değer; koşul; artım) 
          { 
            [Break ] 
          } 

for deyimine ikinci parametre olarak verilen İlk Değer döngü değişkeni­n alacağı ilk değer­dir. Koşul ifadesi ile devam etme şartları belirtilir. artım ile döngünün her turunda değiş­kenin ne kadar artıp veya azalacağı belirtilir. 

         for (int X = 1; X<10; X++) 
           { 
           } 

Bu döngü örneğinde X döngü değişkeni, 1 döngü değişkenin başlangıç değeri ve 10 ise son değeridir. Bu döngüde for deyiminden sonraki blok içindeki satırlar 10 kez arka arkaya işletilir. break deyimi programın akışını for deyimi ile kontrol edilen bloğun sonuna aktarır. 

    int toplam = 0; 
    for (int i = 0; i <= 100; i++) 
     { 
       toplam = toplam + i; 
     } 

Yukarıda verilen kodda for ile kurulan döngüde 1’den 100’e kadar olan sayılar toplanmaktadır. Bu döngüde döngü değişkenini döngünün içinde tanımladık. for döngüsü içinde bir başkası kurulabilir. İç-içe for döngülerinin nasıl kulla­nıldığını anlat­mak için aşağıda verilen örneği hazırladık. Bu amaçla forma 2 ListBox yerleştirip ilk ListBox nesne­sine tasarım anında Items özelliğinden yararlanıp bilgi aktardık.



Aşağıda verilen kodda yapılan sıralamaya selection sort denil­mektedir. Az çok kod yazmış bütün programcılar bu sıralama algoritmasını bilirler. Bu kısacak kodda kullanılan dizi, i, j gibi değişken adları sık kullanılan değişken adlarıdır. Yerli prog­ramcılık kitapları yazan birisi bu sıralama tekniğini ben buldum ve bu değişken adları benimdir derse gülüp geçin. 

“Sırala” başlıklı düğme tıkandığında işletilecek bu satırlarda ilk olarak dizi değişken tanım­lan­dı. Dizi değişkenin eleman sayısı ListBox’ın elemanlarına göre belirlenecektir. 

private void Sirala_Click(object sender, EventArgs e) 
 { 
   int temp, item; 
   item = listBox1.Items.Count; 
   int[] dizi = new int[item]; 
   for (int i = 0; i <= item - 1; i++) 
     dizi[i] = Convert.ToInt32(listBox1.Items[i].ToString()); 
   for (int i = 0; i <= item - 1; i++) 
    { 
     for (int j = 0; j <= item - 1; j++) 
       { 
         if (dizi[j] > dizi[i]) 
            { 
            temp = dizi[i]; 
            dizi[i] = dizi[j]; 
            dizi[j] = temp; 
            } 
         } 
     } 
   for (int i = 0; i<= item - 1; i++) 
     listBox2.Items.Add(dizi[i].ToString());    
 } 

Daha sonra ListBox’lar hakkında bilgi verilen bölümde göreceğiniz gibi ListBox’ların  eleman sayısı Count özelliğinde saklanmaktadır. ListBox’ın eleman sayısı öğrenildikten sonra new deyimi ile dizi değişken oluşturuldu ve ListBox’ın içeriği Convert.ToInt32() metodu ile tam sayı tipine dönüştürüldükten sonra dizi değişkene akta­rıldı. Gerisi dizi değişkenin içeriği büyük olan elemanın içeriği küçük olan eleman ile yer değiştirilmesinden ibarettir. 

foreach Döngüsü 

Bazen bir koleksiyon veya dizi değişkenin içeriği okunurken koleksiyon veya dizi değiş­kenin kaç elemana sahip olduğu önceden bilinmez. Bu gibi durumlarda her okuma öncesi veya sonrası kontrol yapılabilir. foreach deyimi bu işlemleri kolaylaştırmaktadır.



foreach döngüsünün nasıl kullanıldığını anlatmak için forma bir RichTextBox ve ListBox yerleştirdik. RichTextBox’a girilecek bilgiyi kod yazarak satır satır okuyup ListBox’a aktaracağız. Yani RichTextBox’ın her satırı ListBox’ın ayrı bir elemanı olarak değerlendirecektir. 

RichTextBox’a bilgi girilip “Naklet” başlığı verilen düğme tıklandığı zaman girilen bilgilerin ListBox’a aktarılmasını sağlamak için aşağıda verilen kodu hazır­ladık. Bu kodda foreach yerine for döngüsünü kullandık. 

private void naklet_Click(object sender, EventArgs e) 
 { 
   int satir_sayi = richTextBox1.Lines.Length; 
   for (int i = 0; i < satir_sayi; i++) 
    { 
      string satir = richTextBox1.Lines[i]; 
      listBox1.Items.Add(satir);    
    } 
 } 

RichTextBox’ın satır sayısı Lines kolek­siyonun Length özelli­ğine bakılıp öğrenilmektedir.. RichTextBox nesnesinin ilgilenilen satırın nosu Lines koleksiyo­nuna parametre olarak verilmektedir. Bu gibi işlemleri yaparken veya bir koleksiyonun içeriğini elde ederken for yerine foreach döngüsünü kullanarak yazmanız gereken satırları azaltabilirsiniz. Aşağıda verilen 2 satır sayesinde RichTextBox nesnesinin bütün içeriği ListBox’a aktarılır. 

private void naklet_Click(object sender, EventArgs e) 
  { 
   foreach(string satir in richTextBox1.Lines)  
     { 
       listBox1.Items.Add(satir);    
     } 
 } 

Burada asıl üzerinde durulması gerekenler foreach deyiminden sonra parantezlerin içine yazılanlardır. Söz konusu koleksiyon hangi tipte bilgi içeriyorsa önce o tipte bir değişken tanımlanmalı. RichTextBox sınıfının Lines koleksiyonun elemanları string tipte oldukları için “satir” adında string bir değişken tanımlandık. Devamında “in” anahtar kelimesi ile belirtilen koleksiyonun sıradaki elemanı okunup parantezin içinde tanımlanan değişkene aktarılır. Bu değişkene aktarılacak eleman kalmadığında foreach döngü­sünden çıkılır. 

RichTextBox sınıfına IEnenumerator arayüzü uygulanmamış olsaydı Lines özelliğinin elemanları veya satırları üzerinde foreach ile hareket etmek mümkün olmazdı. Bu arayüz hakkında kitabın ileriki sayfalarında bilgi verilecektir. 

string[] basket = new string[4];
basket[0] = "Kerem";
basket[1] = "Mirsat";
basket[2] = "Hidayet";
basket[3] = "Mehmet";
foreach (string oyuncu in basket) 
   Console.WriteLine(oyuncu); 

foreachdeyimi 2 parametreye sahiptir. İlk parametrede koleksiyondan okunacak bilginin akta­rılacağı değişkenin verilmektedir. Ardından içeriği okunacak koleksiyon 2. parametre olarak kullanılmaktadır. Bu 2 parametrenin arasına “in” yazılmaktadır. 

Şimdi for ile foreach döngüleri arasındaki farkın anlaşılmasına katkı olması için bir örnek hazırlayacağız. Bu amaçla forma 2 ListBox yerleştirip ilk ListBox’a bazı ürünlerin adlarını, 2. ListBox’a ise fiyatlarını yazacağız. Sonra bu ürünlerin KDV’li fiyatlarını hesaplayıp 2. ListBox’a aktaracağız. Bu işlem için yazdığım kodu aşağıda görebilirsiniz. 

int sayi = listBox2.Items.Count;
for (int i = 0; i < sayi; i++) 
 { 
   double fiyat = Convert.ToDouble(listBox2.Items[i]); 
   double kdv = fiyat * 1.18; 
   listBox2.Items[i] = kdv.ToString(); 
 } 

Gördüğünüz gibi for döngüsü içinde döngüye konu edilen veriler üzerinde işlem yapıl­makta­dır. Bu kodun benzerini foreach döngüsü için hazırlamanız halinde hata meydana gelir. Çünkü foreach döngüsü içinde döngüye konu edilen koleksiyonun(burada 2. ListBox’ın Lines ) elemanlarının içeriğinde değişiklik yapılmasına izin vermez. 

int sayi = listBox2.Items.Count;
int i = 0;
foreach (string eleman in listBox2.Items)
{ 
   double fiyat= Convert.ToDouble(eleman); 
   double kdv = fiyat * 1.18; 
   listBox2.Items[i] = kdv.ToString(); 
   i = i + 1;
} 

Yukarıda foreach deyimi hakkında yazılanları tekrarlamak gerekirse şunlar söylenebilir: foreach; GetEnumerator metoduna sahip, başka bir deyişle Enumerable koleksi­yon eleman­ları üzerinde ilerlerken kullanılmakta­dır. 

C# 3.0 ile birlikte var anahtar kelimesi ile değişken tanımlayabilme imkanı programcılara sunuldu. Söz konusu koleksiyonun hangi tipte bilgi içerdiğinden emin değilseniz “in” deyimin­den önceki değişkeni tanımlarken var anahtar kelimesinden yararlanabilirsiniz. 

   foreach (var eleman in koleksiyon) 
    { 
    }