Embed Size (px)
Citation preview
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Visual Studio Açılış Ekranı
2 / 45
Visual Studio başlatıldığında bizi açılış sayfası karşılar.
Açılış sayfası aracılığıyla şunlar yapılabilir :
Sol üst kısımda New Project linkine tıkladığında açılacak diyalog kutusu, istediğin
tipte .NET projesi açmana yardımcı olur. Express versiyonda, full versiyona göre
daha az proje şablonu listelenecektir. Yeni proje oluşturuken altı çizilmesi gereken
bir diğer nokta şudur : Açılan proje, istenen .NET Framework versiyonuna yönelik
kodlanabilir.
Buna gerekçe olarak şöyle bir örnek verilebilir : Uygulamanın yazıldıktan sonra
çalışacağı gerçek ortamda bir önceki framework versiyonunun bulunması ve teknolojileri
departmanı politikası uyarınca o anda yükseltilememesi. Bu şekilde ilgili framework
versiyonunun sahip olduğu yeteneklerle uygulama geliştirebilirsin.
3 / 45
Sol üst kısımda Open Project linkine tıklayarak önceden kayıt attiğin bir projenin
sln dosyasını göstererek çalışmaya devam etmene yardımcı olur.
Sol taraftaki Recent Projects kısmında en son çalıştığın projeleri listeler. Projeleri
hızlıca yeniden açmanı ve çalışmaya devam etmeni sağlar.
Sağ tarafta 3 tane tab vardır.
o Get Started (Başlangıç): Windows, Web, Oficce Uygulamaları Geliştirme
gibi alt başlıklarda programlama yapmak için yardımcı olacak makale,
video gibi kaynaklar bulunur. Bu kaynakların bir çoğuna erişmek için
internet bağlantısına ihtiyaç olacaktır.
o Guidance and Resources (Rehber ve Kaynaklar) : Yazılım geliştirme
sürecini düzenlemek için yardımcı kaynaklar içerir. Planlama, yazılım
dizaynı, geliştirme, test, yayınlama, yönetme alt başlıkları için Visual
Studio’yu daha etkin nasıl kullanacağın konusunda makale ve videolar
içerir. Burası aynı zaamnda MSDN’deki kaynakları efektif kullanman için
sana yol gösterici olacaktır.
o Latest News (Güncel Haberler) : Buraya bir rss kayıt edebilirsin.
Varsayılan olarak Microsoft uygulama geliştirme ile ilgili son haberleri
içeren bir rss linki kayıtlıdır. Bilgisayarının internet bağlantısı olduğunda en
son gelişmeleri buradan takip etmen mümkün.
4 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Visual Studio Menüleri
5 / 45
Visual Studio kullanırken bütün ekranlarda gördüğün menüler komut ve pencerelere
erişim için kolaylık sağlar.
Bu menüler yardımıyla Visual Studio’nun gücünden faydalanabilirsin. Menüleri
birkaç örnek ile inceleyelim :
File : Üzerinde çalışılan proje kayıt edilebilir yada kapatılabilir, yeni proje
açılabilir.
Edit : Solution Explorer, Server Explorer, Object Browser gibi geliştiricinin ihtiyaç
duyacağı pencereler açılabilir.
Project : Projeye yeni kod dosyaları eklenebilir, referans kütüphane yada servis
eklenebilir.
Build : Projelerin derlenmesi için kullanılır. Kod yazarken sık sık kodun derlenmesi
ve varsa hataların incelenmesi için faydalıdır.
Debug : Kesme işareti (breakpoint) koyulabilir, debug edilebilir. Programların satır
satır ilerlenerek incelenmesi için kullanılabilir. Lokal değişkenlerin belli bir anda çalışma
zamanındaki durumunu anlamak için faydalıdır.
Data : Bir veri kaynağına bağlanmak için kullanılır. Örneğin bir sql veritabanındaki
tablolar ve verileri incelenebilir, sorgu ekranı olarak kullanılabilir.
Tools : Visual Studio’nun görsel ayarları yapılabilir.
Window : Visual Studio ekranını bölerek kullanmak, tab görünümünü değiştirmek
için kullanılır.
Help : Geniş MSDN (Microsoft Developer Network) kaynakları içerisinde yardım
aramak için, Visual Studio’nuzun versiyonunu öğrenmek için kullanılabilir.
6 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Visual Studio Pencereleri
7 / 45
Visual Studio Pencereleri
Visual Studio’nun gücünü daha yakından tanıyabilmek adına yazılım geliştirici için
bazı önemli pencereleri inceleyelim.
Solution Explorer
Üzerinde çalıştığın proje ile ilgili birçok detaya Solution Explorer penceresinden
erişebilirsin.
Projeye dahil ettiğin kod dosyaları
Projeye dahil ettiğin görsel arayüzler(windows form, web sayfası gibi)
Projeye referans olarak eklenmiş assembly’ler
Projenin konfigürasyon dosyası
Proje ile ilgili bütün dosyalar, projeyi oluştururken senin belirlediğin dizinde bir klasör
içerisinde saklanır. Solution Explorer, bu klasörü sana hiyerarşik bir şekilde gösteren
penceredir. Solution Explorer penceresini açmak için menüden View Solution
Explorer sekmelerini takip edebilirsin.
Tek Solution İçerisinde Birden Fazla Proje İle Çalışmak
Bazen aynı çözüm için birden fazla proje yazman gerekebilir. Örneğin bir içerik
yönetim sistemi programı için windows uygulaması açılabilir. Ardından excel
dosyalarındaki verileri veritabanına kayıt etmek için basit bir konsol uygulamasına ihtiyaç
duyulabilir. Her proje bir solution olabileceği gibi, bir solution içinde birden fazla proje
saklanabilir. Bu durumda 2.projeyi Solution Explorer üzerinde açmak gerekir. Bunun için
Solution Explorer içinde ilk satıra sağ tıklayıp Add New Project demek yeterlidir.
Böylece tek bir sln dosyası ile birden fazla projeyi gruplayarak takip edebilirsin.
8 / 45
Projeye Referans Eklemek
Projene .NET Framework içerisinde en sık kullanılan assembly’lerin referansları dahil
edilmiştir. Bunu Solution Explorer içindeki References klasöründe görebilirsin. Varsayılan
olarak eklenen bu kütüphanelerin listesi, açtığın proje çeşidine göre değişiklik gösterir.
.NET Framework içerisindeki diğer kütüphaneleri programında kullanmak
isteyebilirsin. Örneğin açtığın konsol uygulamasının konfigürasyon dosyasına (App.config)
erişmesi için gerekli tipleri içeren System.Configuration.dll’ini eklemek istedin. Bunun için
yapman gereken References klasörüne sağ tıklamak ve Add Reference... menü
kalemini seçmektir. Açılan pencerede birkaç tane sekme var.
9 / 45
.NET sekmesi, çalıştığın bilgisayarda kurulu olan framework’ün sahip olduğu bütün
assembly’leri listeleler. Bunlardan istenen dll dosyası seçilip OK butonuna basılır. Artık
seçtiğin assembly içindeki bütün tiplerden faydalanabilirsin.
Browse sekmesini kullanarak bir arkadaşının yazdığı yada internet gibi diğer
kaynaklardan bulduğun kütüphaneleri, projende kullanabilirsin. Bunun için yapman
gereken şey, dll dosyasının dizindeki yerini göstermek ve ardından OK butonuna
basmak.
Server Explorer
Server Explorer, Visual Studio’nun sunucu yönetim penceresidir.
Bu pencere yardımı ile, bir veri kaynağına bağlanıp oradaki veritabanını
incelenebilir. Bağlanılan veritabanı altında tablolar, fonksiyonlar listelenir. Dilenirse sql
sorguları yazılabilir. Microsoft Sql Server yanında Access, Oracle gibi diğer veri
kaynaklarına da bağlanılabilir.
Bunun yanında ağ üzerindeki bir bilgisayara bağlanıp sistem servislerinden bilgi
almak için kullanılabilir.
10 / 45
Server Explorer penceresini açmak için menüden View Server Explorer
sekmelerini takip edebilirsin.
Object Browser
Object Browser, projende yer alan bütün tip ve üyeleri incelemene izin veren bir araçtır.
Projeye varsayılan olarak dahil olan kütüphaneler, kendi yazdığın kodlar ve senin
sonradan eklediğin kütüphaneleri burada bulabilirsin.
Bu pencere sayesinde ilk defa kullanacağın bir kütüphaneyi yakında inceleyebilir ve hangi
üyelerini kullanabileceğin hakkında fikir sahibi olabilirsin.
Projenin referans mimarisini bir başka geliştirici arkadaşına anlatırken Object Browser
aracından faydalabilirsin.
Burada yakalaman gereken bir başka detay da şudur : Solution Explorer penceresindeki
referanslarda yer almayan ama Object Browser aracında görülen : mscorlib. Bu
assembly, varsayılan olarak bütün .NET projelerine dahil edilir. İçerisinde int, double,
Console vb. en temel veri tiplerini barındırır.
Object Browser penceresini View Object Browser menüsünden açabilirsin.
11 / 45
Object Browser üç tane panelden meydana gelmektedir:
Solda Nesne Paneli
Sağ üstte Üye Paneli
Sağ altta Açıklama Paneli
Nesne panelinde yer alan ikonlar, .NET Framework içerisindeki hiyerarşik yapıları ağaç
görünümünde sunmaktadır. Bu ağaçta isim alanları (namespaces), assembly’ler,
arayüzler (interface), sınıflar (classes) gibi bir programı oluşturan bütün kavramlar
gösterilir. Bu nesneleri panel üzerinde genişletebilir ve kendisine bağlı üyeleri sıralı olarak
inceleyebilirsin. Özellikler, metotlar, olaylar, değişkenler ve diğer tip üyeleri Üye
Panelinde listelenir. Nesne ve Üye panelinde seçilen programlama nesnesinin detayı
Açıklama Panelinde gösterilir.
12 / 45
Class View
Class View, geliştirmekte olduğun uygulamanın içinde çağrılan, referans edilen ve
tanımlanan programlama nesnelerini gösterir.
Class View penceresini View Class View menüsünden açabilirsin.
13 / 45
Class View penceresinin iki tane paneli vardır :
Nesne Paneli
Üye Paneli
Bu pencere uygulama yazarken her zaman açık kalabilir; böylece uygulama içindeki
hiyerarşiye sürekli hakim olursun. İkonlar sana hiyerarşik yapıyı gösterir; bu şekilde
projendeki tiplerin ve o tiplere ait üyelerin listesini görürsün. Aynı zamanda kendi
yazdığın tip yada üyeye tıklayarak projedeki kodun olduğu yere gidebilirsin. .NET
Framework’e ait bir tip yada üyeye tıkladığında ise daha detaylı inceleyebilmek için
Object Browser aracına geçiş yapabilirsin.
Code Definition
Code Definition, sen kod yazarken kullandığın tip ve üyelerin tanımlarını anlık olarak sana
gösteren bir penceredir. Aktif projede senin yazdığın yada referans edilmiş
kütüphanelerin içindeki kod dosyalarında yer alan tanımları gösterir. Gösterdiği tanımları
sadece-okunabilir olarak sunar.
14 / 45
Pencereyi View Code Definition Window menüsünden ilk defa açtığında, en son
seçtiğin nesnenin tanımını gösterir. Sadece okunabilir olmasına rağmen birçok açıdan
fonskiyonel bir editördür. Örneğin bu pencereden kod yada yorum satırı kopyalayabilirsin.
Penceredeki kod satırına kesme işareti (breakpoint) koyabilir; bu yolla programın o satıra
kadar çalışıp o satırda duraksamasını sağlayabilirsin. Pencerede gördüğün içeriği
güncellemek istediğinde ise pencere içinde sağ tıklayıp Edit Definition alt menüsünü
seçerek ilgili koda gidebilirsin.
15 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Visual Studio İle
Uygulamaların Debug Edilmesi
16 / 45
Yazmakta olduğun C# programı çalışırken lokal değişkenlerin değerini görmek istedin.
Bu, değerlerin doğru olduğundan emin olmak adına faydalı olacaktır. Aynı şekilde
programı satır satır çalıştırarak uygulamanın davranışını takip etmek çok işine yarayacak.
İşte sana Visual Studio ortamında değişkenlerin debug edilmesi ile ilgili bir örnek ekran :
Lokal değişkenlerin çalışma zamanında içeriklerine bakmak için kod bloğunun uygun
bir yerine kesme işareti (breakpoint) koymak gerekir. Bunu modellemek adına C# dili ile
yazılmış ve bir çok lokal değişkene sahip kısa konsol programına göz atalım :
Lokal Değişkenler Kullanan C# Programı
using System; namespace DebugCsharpProgram { class Program { static void Main(string[] args) { //İndirim oranı - Lokal değişken double oran = 0.15; //Aracın fiyatı - Lokal değişken long fiyat = 25460; //İndirimli satış rakamı - Lokal değişken double sonFiyat = fiyat - (fiyat * oran);
17 / 45
Console.WriteLine("Aracın satış rakamı :
{0}",sonFiyat); } } }
18 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Kesme İşareti (Breakpoint)
Eklemek
19 / 45
Örnek programın sonuna doğru bir kesme işareti ekliyoruz. Kaynak kodu yazdığın ekranın
en solunda dar gri bir şerit göreceksin. Debug etmek istediğin satırda o şerite tıkla (F9
yada menüden Debug Toogle Breakpoint). Visual Studio orayı kırmızı bir daire ile
işaretler. Kod üzerinde oluşan kırmızı blok ise debugger’ın açılacağı bloğu belirtir.
20 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Debug İşlemini Başlatmak
21 / 45
Visual Studio ile programı başlatırken, aynı zamanda debugger’ın nasıl başlatılacağını
görelim. Bunu yapmak için Visual Studio’da üst kısımdaki araç çubuğunda yer alan yeşil
oka tıklamak yeterlidir. Bu, klavyede F5 tuşuna basmak ile aynı işlemi gerçekleştirir.
Ayrıca debug süreci kısayollar yerine, menüden yönetilebilir. Visual Studio üst
menüsünde Debug Start Debugging tıklanarak hem uygulama çalıştırılmış olur, hem de
kod içerisinde kesme işaretiniz (breakpoint) varsa program çalışıp o satırda çalışmayı
duraksatır ve bekler.
Programın Kesme İşaretine Gelmesi
Program çalıştırıldığında kod dosyasına koyulan kesme işaretine gelir ve çalışması
ilgili o satırda duraksar. Kırmızı kod bloğu, sarıya döner. Sol şeritteki kırmızı dairenin
içinde sarı ok belirir ve debugger’ın o anda hangi satırı işletmekte olduğunu sana gösterir.
Visual Studio Call Stack, Immediate Window gibi birçok panel açar ve çalışma zamanı ile
alakalı geliştiriciye kullanışlı bilgiler sunar. Bu noktada Locals penceresini açarak, o anda
bellekte yer alan lokal değişkenleri inceleyelim. Visual Studio’daki birçok ekran gibi Locals
penceresini açmanın da birçok yolu var. Şimdi Debug Windows Locals menüsünü
kullan.
22 / 45
Buradaki kolonların ne ifade ettiklerine kısaca göz atalım:
- Name : Lokal değişkene verilen isim
- Value : Lokal değişkenin çalışma zamanında o andaki güncel değeri
- Type : Tanımlanan lokal değişkenin veri tipi
Komut Satırları Arasında Adım Adım İlerlemek
Bazen kodu debug ederken bir sonraki satıra ilerlemek isteyebilirsin. Bunu yaparken
sıradaki metodun içerisine girip satır satır kodu işletmek ve oradaki değişkenlerin aldığı
değerleri görme ihtiyacın olabilir. Ayrıca 3 satır aşağıda başka bir kesme işareti
(breakpoint) koymuş olabilirsin ve satır satır ilerlemeden programın doğrudan oraya
kadar çalışmasını ve orada yeniden duraksamasını isteyebilirsin. Bunun için tekrar F5’e
basman yeterlidir. İşte diğer seçenekler :
Step Into (F11)
Bu hareket, programın bulunduğu satırı çalıştırmasını ve ardından bir sonraki satıra
geçmesini sağlar. Eğer debugger’ın o an üzerinde bulunduğu satır, metot çağıran bir kod
içeriyorsa debugger metodun içine girer ve ilk satırında duraksar. Böylece metot
içerisindeki lokal değişkenlerin durumu gözlenebilir. Menüden Debug Step Into yada
klavyeden F11 ile kullanılabilir.
Step Over (F10)
Bu hareket, programın bulunduğu satırı çalıştırmasını ve ardından bir sonraki satıra
geçmesini sağlar. Ancak sıradaki satırda bir metot varsa onun içine girmez ve metodu
çalıştırıp devam eder. Menüden Debug Step Over yada klavyeden F10 ile kullanılabilir.
Step Out (Shift + F11)
Bu hareket, o an debug edilen metodun geri kalanına satır satır devam etmeyip tek
seferde çalıştırır ve kendisini çağıran metoda geri döner. Adım adım çalışmaya dışardaki
metottan devam eder. Menüden Debug Step Out yada klavyeden Shift + F11 ile
kullanılabilir.
23 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Debug İşlemini Sonlandırmak
24 / 45
Kodu Debug ederken istenen anda vazgeçebilir ve programı sonlandırabilirsin. Bunu
yapmak için Visual Studio’da üst kısımdaki araç çubuğunda yer alan mavi kare işaretine
tıklaman yeterlidir. Alternatif olarak klavyeden Shift + F5 tuşlarını kullanabilirsin.
Bir Uygulamayı Debug Etmeden Çalıştırmak
Yazdığımız programın içinde breakpoint’ler olsa da olmasa da adım adım ilerlemek
yerine bütün programı tek seferde çalıştırmak ve ortaya çıkan sonucu görmek istediğinde
Debug Start Without Debugging yada Ctrl + F5 tercih etmelisin.
Debug Seçeneğini Devre Dışı Bırakmak
Yazdığın programı gerçek ortamında yayınlamadan önce debug etme seçeneği
devre dışı bırakılmalıdır. Bunun sebebi debugger’ın önemli ölçüde performans yükü
getirmesidir. Debug seçeneği web.config dosyası üzerinden kapatılmış bir programın
çalışması, açık olan programın çalışmasına göre yaklaşık 2 kat daha hızlıdır. Bunun için
web uygulamasında web.config dosyasında compilation etiketinin debug niteliğine false
değer vermelisin. Konsol yada masaüstü uygulamalarda ise menüden Project ProjeAdin
Properties Debug Configuration listesinde Release seçmelisin.
25 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Kontrol Yapıları
26 / 45
If Kontrolü
İngilizce olarak Eğer anlamına gelen if kontrolü, aynen Türkçe’deki gibi kullanılır. Eğer
ile başlayan cümlenin mantıksal ifadesi doğru (true değer dönerse) ise eğer için yazılmış
kod bloğu çalıştırılır; aksi takdirde bu bloğun atlanarak çalıştırılmamasını sağlar. Bir
uygulamanın kod akışını belli şartlara bağlı olarak dallandırmak için kullanılan if
deyiminde kontrol her zaman ilişkisel, koşul veya eşitlik operatörleri ile sağlanır. Genel
söz dizimi aşağıdaki gibidir :
İf (mantıksal ifade) { //Yapılacak iş bloğu }
Bu örneğimizde mantıksal ifadenin doğru olması halinde “Yapılacak iş bloğu”
nun bulunduğu blok çalışır; yanlış olması yani false değer döndürmesi halinde ise
“Yapılacak iş bloğu” nun bulunduğu kod bloğu çalıştırılmadan atlanır ve bloğun bittiği
noktadaki satırdan itibaren normal kod akışı devam eder.
Ayrıca, if bloğunu takiben, bir else bloğu kullandığında; eğer mantıksal ifadenin
döndürdüğü değer yanlış olursa, if bloğu atlanıp, else bloğu içerisindeki kod
çalıştırılacaktır. Yani, mantıksal ifadenin sonucuna bağlı olarak, iki farklı kod bloğundan
sadece birini çalıştırmak istediğin durumlarda if deyimini else ile birlikte kullanabilirsin.
İhtiyaç dahilinde if ve else bloklarını bir arada kullanmak istediğinde, genel söz dizimi
aşağıdaki gibidir :
if(mantıksal ifade) { //Yapılacak iş bloğu 1 } else { //Yapılacak iş bloğu 2 }
Bu örnekte mantıksal ifadenin doğru olması halinde halinde “Yapılacak iş bloğu
1” in bulunduğu ilk kod bloğu çalışır; mantıksal ifadenin yanlış olması halinde halinde ise
“Yapılacak iş bloğu 2” nin bulunduğu kod bloğu çalışır.
x>7 : x değişkeninin içerisindeki değer 7’den büyük olursa mantıksal ifade true
döndürür, 7’ye eşit yada 7’den küçük olursa mantıksal ifade false döndürür.
... int not1 = 80; int not2 = 90; int ortalama = (not1 + not2) / 2; if (ortalama < 50) { Console.WriteLine("Bu dersten kaldınız..."); } else
27 / 45
} Console.WriteLine("Bu dersten geçtiniz..."); } ...
not1 ve not2 değişkenlerinin ortalaması alınarak hesaplanan ortalama
değişkeninin değerine bağlı olarak uygulamada iki farklı kod bloğundan birisi çalışır.
Hangi kod bloğunun çalışacağına if(...) deyiminin içerisindeki mantıksal ifadenin
değerlendirilmsi sonucunda karar verilir. ortalama, 85 olarak hesaplanarak if kontrolüne
girer; burada (85 < 50) şeklindeki mantıksal ifade değerlendirilir ve sonuç ‘yanlış (false)’
olarak elde edilir. Bu noktada if, kontrolün ilk bloktan mı yoksa ikinci bloktan mı devam
edeceğine karar verir ve elde edilen sonuç yanlış olduğu için kod akışı “else” bloğuna
yönlendirilir.
if ve else anahtar kelimelerinin ardından sadece tek bir komuttan oluşan
bir kod bloğu çalıştırılacak ise bloğu küme parantezleri içerisine almaya gerek
yoktur. Örneğin; if (ortalama < 50) Console.WriteLine("Bu dersten kaldınız...");
Fakat, birden fazla komut barındıran bir kod bloğu kullanılacağı zaman,
küme parantezlerinin kullanılması zorunludur. Aksi takdirde if’den sonra
kullanılmayan küme parantezleri için derleme zamanı hatası oluşma riski vardır.
(eğer arkasından else kullanılmış ise), else’den sonra kullanılmayan küme
parantezleri derleme zamanında hata üretmez fakat bloğun ilk satırından sonraki
kodlar else bloğundan bağımsız olarak çalışır ve isteğimiz dışında bir davranış
sergiler. Bu gibi olası hataların gerçekleşmesinin önüne geçmek için, kod
bloğumuz tek bir komuttan oluşsa dahi, if/else bloklarını küme parantezleri
içerisinde yazmalıyız. Benzer durum, ileriki konuda anlatılacak olan for döngüsü
için de geçerlidir.
Yukarıdaki örneğin çıktısı şöyledir:
if bloğu kullanımına örnek olarak aşağıdaki kodları inceleyelim:
...
if ((5 % 2) == 0) { Console.WriteLine("5, tek sayıdır...");
} else { Console.WriteLine("5, çift sayıdır..."); }
28 / 45
...
5’in 2 ile bölümünden kalan 1’dir. Dolayısıyla if deyimi false değer döndürür ve
kontrol else bloğundan akışına devam eder. Bu aşamalar debug edilerek çok daha sağlıklı
bir şekilde gözlemlenebilir. Debug işlemi, konunun anlaşılmasını da kolaylaştıracaktır.
Operatör öncelikleri
if parantezi içerisinde herhangi bir mantıksal ifade olması yeterlidir. Bu birden
fazla ifadenin birleşimi de olabilir, çok basit bir kontrol de olabilir. Örnekte if bloğu
içerisinde 7’nin 2 ile bölümünden kalan sayının 0’a eşit olup olmadığı kontrol
edilmektedir. (7 % 2) ifadesi parantez içerisine alınmasa da kod sağlıklı bir şekilde çalışır;
çünkü aritmetik operatörlerin eşitlik operatörüne karşı önceliği vardır. Ancak; hiçbir
zaman işi önceliklere bırakmayıp, kendi önceliklerini –aynen matematik
kurallarında olduğu gibi- parantezlerle belirlemen tavsiye edilir. Örnekte de bu
tavsiyeye uyulmuştur.
Hiçbir zaman işi önceliklere bırakma, kendi önceliklerini
parantezlerle belirle.
if – else if İfadeleri
if deyimleri birbirine bağlı olarak, arka arkaya kullanıldığında, mantıksal deyimler
birbirlerine zincirlenir ve bir tanesi true değer döndürünceye kadar birbiri arkasına
çalıştırılır. Örneğin haftanın günlerini ele alalım. Kullanıcıdan alınacak haftanın gün sayısı
ile günün ne olduğunu ekrana yazdıracağımızı düşünelim:
Bu örnekte kullanıcının hatasız şekilde bir sayı girdiği varsayılır. İlk if’den itibaren girilen
sayı ile karşılaştırma yapılarak ilerlenir. if ve else if kontrolleri birbirlerine bağlı şekilde
çalışmaktadır. Bu yüzden if ya da else if’lerden herhangi birinde doğru değer
... string gunAdi; Console.Write("1 ile 7 arasında haftanın bir gününü giriniz : "); string gun = Console.ReadLine();
if (gun == "1") gunAdi = "Pazartesi";
else if (gun == "2") gunAdi = "Salı";
else if (gun == "3") gunAdi = "Çarşamba";
else if (gun == "4") gunAdi = "Perşembe";
else if (gun == "5") gunAdi = "Cuma";
else if (gun == "6") gunAdi = "Cumartesi";
else if (gun == "7") gunAdi = "Pazar"; else gunAdi = "Doğru gün sayısı girilmedi"; Console.WriteLine(gunAdi); ...
29 / 45
tutturulmuşsa kontrol bağlı bulunan diğer blokların sonuna gider. Diğer bloklar boşuna
kontrol edilmez. Çünkü oradaki dizayn, bir tane doğrunun olması üzerine kuruludur.
else/if yapısı
else/ if blokları doğru bir şekilde çalışıyor.
if Bloğunda Koşul Operatörleri
if bloklarında koşul operatörleri de (&& , ||) kullanılabilir. Özellikle birden fazla koşulu tek
bir if içerisinde test etmek istediğimizde bu yola başvurabiliriz. Aşağıdaki yüzde kontrolü
buna iyi bir örnektir.
int yuzde = 90; if ((yuzde >= 0) && (yuzde <= 100)) { Console.WriteLine("Yüzde {0}",yuzde);
} else { Console.WriteLine("Geçersiz yüzde..."); }
Switch Kontrolü
if – else ve/veya if – else if deyimleri ile yapılabilen kontrollerin, bazı durumlarda
switch deyimi ile yapılması tercih edilebilir. Özellikle if – else if deyimlerinin sayısı
arttıkça, switch deyiminin tercih edilmesi, hem daha etkili, hem de daha okunaklı kod
yazılmasını sağlar. Dikkat edilmesi gereken nokta, switch bloklarının sadece sabit
değerler üzerinden koşul denetimi yapıyor olmasıdır. switch bloklarında eşitlik denetimi
yapılıyor olmasına rağmen, karşılaştırma veya eşitlik operatörlerinden faydalanılamaz.
Genel söz dizimi aşağıdaki gibidir:
30 / 45
Burada kodun hareketini kontrol eden kararDegiskenidir. Onun değeri switch
bloğu içerisindeki case anahtar kelimesinin önündeki değererle karşılaştırılır.
Eğer eşleşen bir değere rastlarsa bir alt satıra geçer ve kodu çalıştırır. Aksi
takdirder otomatik olarak bir sonraki case anahtar kelimesini kontrol etmeye
geçer.
Eşleşen hiçbir case bulunamazsa, default anahtar kelimesinin altındaki kodlar
çalışır.
‘case’ lerin altında herhangi bir süslü paranteze ihtiyaç duyulmaz. Çünkü
eşleşen bir case in kodları aşağıya doğru akar ve break anahtar kelimesini
görene kadar çalışır. break, kod akışını switch deyiminin sonuna götürür.
Böylece şartlardan sadece bir tanesinin çalışması ve diğerlerinin atlanması
garanti altına alınır.
Switch bloğunda default bulunmak zorunda değildir. Eğer default varsa ilgili
bloğun sonuna da break koyulmalıdır. detault yoksa, en son case deyimi
break ile bitmelidir. Zaten unutulursa derleyici, derleme zamanı hatası
vererek uygulama geliştiriciyi uyaracaktır.
Aşağıdaki örnekte kullanıcıdan sayısal bir değer alınıp, bu değere bağlı olarak
kullanıcıya basit cevap veren bir uygulama yer almaktadır. Kullanıcıdan istenilen değerler
dışında bir sayısal değer girilmesi durumunda, if kontrolündeki else bloğunun benzeri
işlevselliğe sahip default bloğu çalışır.
... int kararDegiskeni = 1; switch (kararDegiskeni) { case 1: Console.WriteLine("Karar 1"); break; case 2: Console.WriteLine("Karar 2"); break; default: Console.WriteLine("Varsayılan Karar"); break; } ...
31 / 45
... Console.WriteLine("1 [C#], 2 [VB]"); Console.Write("Lütfen dil seçiminizi yapınız: "); string dilSecimi = Console.ReadLine(); int n = int.Parse(dilSecimi); switch (n) { case 1: Console.WriteLine("İyi tercih. C#, .NET’in gözdesidir..."); break; case 2: Console.WriteLine("VB .NET: İşin biraz zor ama imkansız
değil..."); break; default: Console.WriteLine("Geçersiz bir değer girdin. Sana iyi
şanslar..."); break; } ...
switch deyimi kullanılarak kontrol edilecek değişken (Yukarıdaki örnekte
dilSecimi değişkeni) tipleri şunlar olabilir: Bütün tam sayı tipler, metinsel tipler,
bool tipi veya her hangi bir numaralandırıcı (enum) tipi.
32 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Döngüler
33 / 45
While Döngüsü
Mantıksal bir ifade doğru olduğu sürece belli bir kod bloğunu, tekrar tekrar
çalıştırılmak istediğinde başvurabileceğin döngü deyimlerinden biridir.
Döngülerin çalışma mekanizmasını daha kolay kavrayabilmen için,
aşağıdaki kod parçasını, çalışma zamanında debug edip, adım adım ilerlemelisin.
...
int a = 0; while (a <= 5) { Console.WriteLine("a'nın şu anki değeri : {0}",a); a++;
}
...
Önce a değişkeni tanımlanır ve 0 değerini alır. Sonra while deyiminin içerisi
kontrol edilir. Bu deyimin içi doğru olduğu sürece, while bloğu (küme parantezleri arası)
tekrar tekrar çalıştırılır. Dolayısıyla, deyim içerisinde kontrol edilen değişkenin değeri, her
dönüşte denetlenen şartı bozmaya yönelik olarak değiştirilmelidir. Yani deyim içerisinde
a<=5 ifadesini denetlerken, döngü bloğu içerisinde a’nın değerini her seferinde
azaltılırsak, bu döngüden çıkılmaz. Çıkılsa da sağlıklı olarak uygulamaya geri dönülemez.
Bu yüzden a değişkeninin değeri her seferinde 1 arttırılır. İlk şart sağlanıp ekrana gerekli
bilgilerin yazılmasının hemen ardından değişkenin değeri arttırılır. Sonrasında da döngü
deyiminin kontrolü yeniden yapılır ve ‘1’ değeri için de ifade doğru olduğundan, bloğa
tekrar girilip kod çalıştırılır. Döngü değişkeninin değeri tekrar arttırır ve bu döngü a, 5
değerini alana kadar devam eder. Hatta 5 değeri de şartı sağladığı için döngü içerisindeki
kod bloğu bir kere daha çalışır. Fakat sonraki artışta a değişkeni 6 değerini aldığı için
koşul false değer döndürür ve döngü sonlanır. Kod akışı, döngü bloğundan sonraki ilk
satırdan devam eder. Çıktı aşağıdaki gibi olur:
While döngüsü örneği
Burada dikkat edilmesi gereken nokta var. while döngüsünde 3 ayrı çok önemli
parametre tamamen birbirinden ayrı yerlerde işleniyor.
34 / 45
Döngü değişkeninin tanımlandığı ve ilk değerinin verildiği yer, döngü bloğunun
dışındadır.
Döngünün ne kadar süre ile devam edeceğine karar verilen yer, döngü deyiminin
içerisindedir.
Döngü değişkeninin değer arttırımı ise döngü bloğunun içerisinde yapılmaktadır.
Özellikle arttırım ifadesinin unutulmamasına ve doğru olarak verilmesine dikkat
edilmelidir. Bu koordinasyon iyi kurulduğu sürece ihtiyaç duyulan yerlerde while
döngüsünden maksimum fayda sağlanır.
While döngüsü için yazılmış aşağıdaki örnekte kullanıcıdan istenen iki kelimeden
birisi olan “yes” girilmediği sürece döngü içerisinde kalınmaktadır. Kullanıcıdan alınan
değer doğru olsa dahi büyük harfli olması durumunda eşleşme olmayacaktır. Her
ihtimalde doğru değerin kabul edilmesini garanti altına almak için ToLower() metodu ile
girilen değerin küçük harfli temsili elde edilir. While döngüsünde döngü deyimi
içerisindeki şart, kod bloğu çalışmadan önce kontrol edilir. Bundan dolayı, değişkene,
döngünün devamını sağlayacak bir başangıç değeri verilir.
... string deger = "no"; while (deger.ToLower() != "yes") { Console.Write("Tamam mı? [yes] [no]: "); deger = Console.ReadLine(); Console.WriteLine("*While döngüsündesin*");
} Console.WriteLine("-While döngüsünden çıktın-");
...
Burada döngünün devamını kontrol eden şey ekrandan “yes” dışında herhangi
bir şey girilmesidir. Çünkü döngü deyiminin içerisinde ‘eşit olmadığı sürece’ kontrolü
yapılmaktadır.
deger.ToLower() != "yes"
Do-While Döngüsü
Do-While döngüsü tamamen while döngüsü gibi çalışır. Aralarındaki tek fark
şudur. while döngüsünde döngü deyimi içerisindeki kontrol, döngüye girilmeden önce
yapılır. do-while döngüsünde ise bu kontrol ilk döngü bloğundan çıkıldıktan sonra
yapılmaya başlanır. Yani döngü bloğu içersinde yer alan kod, kayıtsız-şartsız ilk sefer için
çalıştırılır. Öyleyse while döngüsünde verilen 2. örnek aşağıdaki gibi düzenlenebilir:
...
string deger = ""; do { Console.WriteLine("*While döngüsündesin*");
35 / 45
Console.Write("Tamam mı? [yes] [no]: "); deger = Console.ReadLine();
} while (deger.ToLower() != "yes"); Console.WriteLine("-While döngüsünden çıktın-");
...
Öncelikle bir do-while döngüsünün yapısını inceleyelim. Döngü bloğunun içerisi,
ilk sefer için kontrol edilmeden çalışacağından while anahtar kelimesi ve döngü deyimi,
kod bloğunun sonunda yer alır. do-while söz dizimi noktalı virgül ile biter. Kod bloğunun
başına da do anahtar kelimesi gelir. Kod incelendiğinde görülen en önemli değişiklik,
bloğun ilk çalıştırılmada kontrole maruz kalmamasıdır. İkinci değişiklik ise, her şart
altında döngü bloğundaki kod çalıştırıldığı için (döngü deyimi içerisindeki şart sağlanmasa
da)
Console.WriteLine("*While döngüsündesin*");
yazısının döngü bloğunun başına alınmasıdır.
Do-while döngüsü kullanımına örnek olarak kullanıcı adı ve şifreyi kullanıcıdan
minimum bir defa isteyen bir algoritma düşünülebilir. Aşağıdaki kodu inceleyelim:
...
string kullaniciAdi = ""; string sifre = ""; do { Console.Write("Kullanıcı adı giriniz : ");
kullaniciAdi = Console.ReadLine(); Console.Write("Şifre giriniz : "); sifre = Console.ReadLine(); } while ((kullaniciAdi != "emrah") || (sifre != "1234")); Console.WriteLine("Siteye login oldunuz..."); ...
do bloğu herhangi bir kontrol yapılmadan ilk sefer için çalışır. Yanlış değerler
girilmesi durumunda kullanıcıdan, kullaniciAdi ve sifre bilgileri alınıp, ikinci sefer kontrol
ettirilebilir. Kullanıcı adı ya da şifreden birinin bile yanlış olması durumunda login olmayı
engellemek için kontrol aşağıdaki şekilde yapılmıştır:
while ((kullaniciAdi != "emrah") || (sifre != "1234"));
Bu deyim eğer kullanıcı adı ”emrah” değilse ya da sifre=”1234” değilse
döngüye devam edilsin olarak yorumlanabilir.
36 / 45
For Döngüsü
For döngüsü, while döngüsü ile benzer bir fonksiyonelliğe sahiptir. Döngü
değişkeninin tanımlanması, değişkenin döngü içerisinde güncellenmesi ve döngü koşul
deyiminin bildirilmesi for döngüsünde tek bir yerde yapılır. Genel söz dizimi aşağıda yer
almaktadır:
for (başlangıç değeri; mantıksal ifade ; kontrol değerinin güncellenmesi)
{ //kod bloğu;
}
Bu 3 işlem, for döngüsünün temellerini teşkil eder. Şimdi, aşağıdaki örneği
inceleyelim:
for (int i = 0; i != 10; i++) { Console.WriteLine(i);
}
1. Baştaki i değişkeni, sadece döngünün başında bir defa oluşturulur.
2. Eğer ortadaki mantıksal (boolean) ifade doğru ise döngü bloğu çalıştırılır.
3. Sondaki kontrol değişkeni güncellenir ve mantıksal ifade yeniden hesaplanır.
4. Eğer koşul hala doğruysa döngü bloğu yeniden çalıştırılır.
5. Kontrol değişkeni güncellenir ve mantıksal ifade yeniden hesaplanır.
6. Ortadaki koşul (mantıksal ifade) false dönene kadar bu süreç devam eder.
Burada dikkat edilmesi gereken bazı noktalar vardır:
Değişken oluşturma ve başlanıç değeri verme sadece ilk döngüde gerçekleşir.
Döngü bloğu her zaman konrol değişkeninin (i) güncellenmesinden önce çalışır.
Güncelleme her zaman mantıksal koşul ifadesinden önce çalışır.
For döngüsü örneği
Başka bir örnek daha inceleyelim. For döngüsü kullanarak 1 ile 20 arasındaki
tam sayıların toplamını bulan kod aşağıda yer almaktadır:
...
37 / 45
int toplam = 0; for (int i = 1; i <= 20; i++) { toplam += i;
} Console.WriteLine("1 ile 20 arasındaki değerlerin toplamı :
{0}",toplam); ...
Bu kod çalıştığında döngüden önce başlangıç değeri ‘0’ olan toplam değişkeni
tanımlanır. Döngü içerisinde her turda i değişkeninin güncel değeri toplam değişkenine
eklenir. Bu sayede 1’den 20’ye kadar olan sayıların kümülatif toplamı elde edilir.
For döngüsü kullanarak 1 ile 20 arasındaki sayıların toplamı
For döngüsünde aralarına noktalı virgül koyularak belirtilen üç bileşenden
herhangi biri, ikisi ya da üçü birden belirtilmeyebilir. Bu bileşenlerin uygun başka bir
yerde belirtilmesi de mümkündür. İhtiyaç varsa çoklu başlangıç değeri ve güncelleme
parçası kullanılabilir. Ayrıca döngü için oluşturulan değişkenlerle ilgili farkında olunması
gereken bazı önemli noktalar vardır:
Eğer mantıksal ifade yazılmazsa, varsayılan olarak dönecek değer true olacaktır.
Dolayısıyla aşağıdaki for döngüsü sonsuza kadar çalışır:
... for (int i = 0; ; i++) {
Console.WriteLine("Biri beni durdursun..."); } ...
Bir diğer sonsuz döngü çeşidi de aşağıda yer almaktadır:
for( ; ; )
{
}
Bu tarz sonsuz döngülere çok sık ihtiyaç duyulmaz. Genel olarak giriş-çıkış
(I/O) işlemlerinde, şifreleme algoritmalarında ve örneğin kullanıcı doğru değer
girene kadar devam etmesi gereken durumlarda vb. kullanılabilir.
38 / 45
Değişken oluşturup başlangıç değerini verme ile değişkeni güncelleme parçaları for
deyiminin içerisine yazılmasa dahi, doğru satırlara yerleştirilirse ortaya çıkan kod
‘while’ döngüsüne benzemektedir.
... int i = 1; for ( ; i != 11 ;) { Console.WriteLine(i); i++; }
...
For döngüsü için birden fazla değişken tanımlanıp yönetilebilir. Çoklu değişken
tanımlama, başlangıç değerlerini verme ve bu değişkenleri güncelleme ifadeleri
noktalı virgülle ayrılan parça içerisinde yer alır ve kendi içlerinde virgül ile ayrılır.
Ortadaki mantıksal ifade ise her zaman tek olmalıdır. Aşağıdaki örnek bunu
modellemektedir:
... for (int i = 0, j = 20 ; i != j; i += 2, j -= 2) { Console.WriteLine(i + " <---> " + j); } ...
Döngü Değişkenleri
For döngüsü kullanırken oluşturulan değişkenler, sadece döngü bloğu içerisinde
geçerli değişkenlerdir. Yani döngü deyimi içerisindeki mantıksal (boolean) ifadenin false
değer döndürmesinin ardından kod akışı döngü sonuna gelir ve değişken bellekten düşer.
Dolayısıyla döngü sonunda değişken, kullanılmaya çalışılırsa derleyici bizi uyarır:
... for (int i = 0; i < 10; i++) { // Hesaplamalar...
}// i değişkeni burada bellekten düşer. Console.WriteLine(i); //Derleme zamanı hatası ...
Yukarıdaki özelliğe bakarak şu ifade rahatlıkla söylenebilir: Ard arda gelen
döngüler içerisinde aynı isimli değişkenler kullanılabilir. Bunu sağlayan şey, her
değişkenin farklı bir kapsama alanına sahip olmasıdır:
...
39 / 45
for (int i = 0; i <= 10; i++) { Console.WriteLine(i); }
Console.WriteLine("******************");
for (int i = 10; i >= 0; i-- ) { Console.WriteLine(i); } ...
Son olarak for döngüsünün daha iyi anlaşılması adına aşağıdaki kodu analiz
etmekte fayda vardır: (Ancak döngülerin bu şekilde kullanılması tavsiye edilmez)
...
int i = 0; Console.WriteLine("*****Döngü başladı\n"); for(Console.WriteLine("Ben sadece ilk sefer çalışırım"); i < 6;
Console.WriteLine("Ben döngü deyimi doğru olduğu sürece çalışırım")) { Console.WriteLine(i); i++; } Console.WriteLine("\n*****Döngü sona erdi...");
...
Bu döngünün çıktısı aşağıdaki gibi olacaktır :
41 / 45
EĞİTİM :
VISUAL STUDIO
KULLANIMI - KONTROL
YAPILARI VE DÖNGÜLER
Bölüm :
Visual Studio Kullanımı
Konu :
Atlama Deyimleri (Jump
Statements)
42 / 45
Atlama deyimleri (jump statements) kullanılarak, kod akışı yönlendirilebilir ve akışta
dallanma(lar) sağlanabilir. Atlama deyimleri şunlardır:
break
continue
goto
return
throw
Bu atlama deyimlerinden return, daha sonraki konularda işlenecek olan
metotlarda kullanılır. return ifadesi, bir metotun çalışmasını sonlandırır. return
kullanıldığında, kod akışı metot bloğunun sonuna gider.
throw ise, program akışı sırasında oluşan alışılmışın dışında bir durumu
(çalışma zamanı hatası -exception-) işaret etmek için kullanılır. throw anahtar
kelimesinin kullanımına daha sonraki konularda değinilecektir.
break Anahtar Kelimesi
break anahtar kelimesine daha önce switch kontrolünde değinilmişti. Orada
yaptığı iş, kontrolü switch bloğunun sonuna transfer etmek ve akışın oradan devam
etmesini sağlamaktır. Bu anahtar kelime, bir döngü içerisinde kullanıldığında, yine switch
örneğindekine benzer bir davranış gösterir. Kod akışını bir daha dönmemek üzere döngü
bloğunun sonuna götürür. Bir başka deyişle döngü içerisinden bir koşul nedeniyle
çıkılmak istendiğinde kullanılabilir. Aşağıdaki örnek bunu modellemektedir:
... for (int i = 0; i < 10; i++) {
if (i == 4) { break; } Console.WriteLine(i);
} //break çalışınca kontrolü buraya transfer eder. Console.WriteLine("Döngü sonu..."); ...
Döngü bloğu 0,1,2 ve 3 için sağlıklı bir şekilde çalışır. İlk dört dönüş içerisinde
yapılan if kontrolleri sonucunda false değer döner ve break komutu çalıştırılmadan
geçilir. Döngü değişkeninin (i) değeri 4 olduğunda if kontrolü true değer döneceği için
break deyimi çalışır. Bunun sonucunda kod akışı, for döngü bloğunun sonuna gider.
Dolayısıyla 4 için değer ekrana yazdırılamaz; sonraki sayılar için ise döngü çalışmaz.
43 / 45
‘break’ anahtar kelimesinin çalışma mekanizması
Eğer iç içe döngü yapısı kullanılıyorsa; break, kod akışını kendisini
çevreleyen en yakın döngü bloğunun dışına transfer eder. Yani kontrol dışardaki
döngü için çalışmaya devam eder.
continue Anahtar Kelimesi
continue anahtar kelimesi, kod akışını, kendisini çevreleyen en yakın döngünün
başına transfer eder. Görüldüğü noktadan sonrasını o tur için çalıştırmaz. Yani döngüyü
bir turluğuna erteler. Döngü bir sonraki iterasyondan normal çalışmasına devam eder.
break için yazılan kodu şimdi de continue için test edelim:
... for (int i = 0; i < 10; i++) {
if (i == 3) {
continue; //aşağıdaki kod, 3 değeri için çalışmaz; ancak //4’den itibaren normal çalışmasına döner.
} Console.WriteLine(i);
} Console.WriteLine("Döngü sonu..."); ...
‘continue’ anahtar kelimesinin çalışma mekanizması
44 / 45
Yukarıdaki şekilden görüldüğü gibi döngü sadece 3 değeri için çalışmasına ara
verdi. Daha sonra ise normal çalışmasına devam etti.
break ve continue deyimlerinin kullanımı sadece for döngüsü ile sınırlı
değildir; while, do-while ve diziler konusunda incelenecek olan foreach
döngülerinde de kullanılabilir.
goto Anahtar Kelimesi
Bu anahtar kelime, kod akışını etiketlenmiş bir noktaya transfer eder.
... Console.Write("Bir sayı giriniz : "); int a = int.Parse(Console.ReadLine()); if (a % 2 == 0) { goto cift; } Console.WriteLine("Girilen sayı tek"); goto Son; cift: Console.WriteLine("Girilen sayı çift"); Son: ...
Yukarıdaki kod, kullanıcıdan alınan sayının tek mi çift mi olduğu kontrolünü
doğru bir şekilde yapar. Fakat, gerek buradaki kullanımı, gerekse diğer kullanılabileceği
yerler düşünüldüğünde, oldukça karışık bir düzen oluşturduğu görülebilir. Ayrıca, kodu,
anlaşılması güç hale getirir. Bu yüzden goto kullanımını sadece şu iki senaryoda tercih
etmek gerekir:
1. switch-case kontrolünde, akışı belli bir case’e ya da default’a yönlendirmek söz
konusu olduğunda.
2. İç içe geçmiş for döngülerinde break ya da continue ile sadece bir kademe dışarı
çıkılabilir. En dışa çıkılmak istendiğinde, yani kod akışının en dıştaki döngünün
sonuna yönlendirmesi istendiğinde.
Bu iki senaryo için goto kullanımı anlamlıdır. Bu durumlar dışında, goto
kullanmak spagetti kod (Anlaşılması zor, iç içe geçmiş kodlar) oluşturur.
... Console.WriteLine("Kahve boyutu: 1=Küçük 2=Orta 3=Büyük"); Console.Write("Lütfen seçiminizi yapınız : "); string secim = Console.ReadLine(); int n = int.Parse(secim); int fiyat = 0; switch (n) { case 1:
fiyat += 25; //Fiyatı : 25 break; case 2: fiyat += 25; //Fiyatı = 25 + 25 = 50
45 / 45
goto case 1; case 3: fiyat += 25; //Fiyatı 25 + 25 + 25 = 75 goto case 2; default: Console.WriteLine("Yanlış seçim"); break; } if (fiyat != 0) { Console.WriteLine("Lütfen makineye {0} kuruş atınız.", fiyat);
} Console.WriteLine("Teşekkürler...");
...
Burada doğru hesaplamayı yapmak için case’ler arasında ‘goto’ kullanımı ile
paslaşmalar yer almaktadır.
Eğer kullanıcı küçük boy kahve istiyorsa 1 girer. ‘n’ değişkeninin değerine göre
uygulamayı yönlendirecek olan switch kontrolünün içerisinde case 1:’den sonraki
kod çalışır. Başlangıç değeri 0 olan fiyat değişkeninin değeri 25 olarak değiştirilir.
Ardından break, kod akışını switch bloğunun sonuna götürür ve ekrana fiyatla ilgili
yazılar yazılır.
Eğer kullanıcı orta boy kahve istiyorsa 2 girer. switch kontrolünün içerisinde case
2:’den sonraki kod çalışır ve fiyat değişkeninin değeri yine 25 yapılır. Sonrasında
kod akışı break ile switch bloğu sonuna gönderilmez. ‘goto’ ile case 1’e transfer
edilir. Bir üst maddedeki süreç tekrar eder. Dolayısıyla fiyat 25 + 25 = 50 kuruş
olarak elde edilip kulanıcıya bildirilir.
Eğer kullanıcı büyük boy kahve istiyorsa 3 girer. Bu sefer önce case 3’ün
içerisindeki kod çalışır. Fiyat değişkeninin değeri 25 yapılır. Kod akışı, case 2’ye
transfer edilir. Burada fiyat 50’ye tamamlanır. Son olarak case 2 kod akışını case
1’e devreder. Nihai fiyat 75 kuruş olarak hesaplanır.
Bu kullanımın avantajı, küçük seçimin case’indeki olası bir fiyat artışında, bu
artışın diğer 2 boya otomatik olarak yansımasıdır.
Bu ders notu, Açık Akademi projesi çerçevesinde TCM tarafından Microsoft Türkiye için hazırlanmıştır.
Tüm hakları Microsoft Türkiye’ ye aittir. İzinsiz çoğaltılamaz, para ile satılamaz.
