GUI kütüphanelerinin desteklediği farklı öğeleri kullanarak uygulamalarımıza farklı özellikler kazandırmak da oldukça kolaydır. Butonlar, metin kutuları, ikon ve sekmeler gibi kullanıcıların aşina olduğu bu öğeler ile C# uygulamalarımız hem göze hitap edecek hem de daha işlevsel olacaklar. Yazının başında Windows Forms konusuna değineceğimizi belirtsek de burada yapacağımız örnekleri Linux altında Mono kullanarak da yapabilmeniz mümkün. Bildiğiniz gibi platformdan bağımsız olarak çalışan .NET uygulamaları Linux altında Mono Projesi kapsamında çalışıyor ve Mono çok güçlü GUI araçlarına sahip.

Visual Studio GUI konusunda çok güçlü araçlara sahip.

Yakın zamana kadar konu arayüz tasarımı olduğunda deneyimli programcılar bile temkinli davranır, uygulama dizaynının yanında programda kullanılacak arayüz araçlarının kullanımı hakkından uzun bir ön çalışma yaparlardı. Ancak Visual Studio, Windows Forms uygulamaları hazırlamak için çok kapsamlı yardımcılara sahip ve GUI araçlarının farklı pencerelerde kullanımını gerçekten oldukça kolaylaştırıyor. Farklı araçların sahip olduğu birçok özellik sağ tarafta bulunan bölmeden fare tıklamalarıyla değiştirilebilirken, öğelere ait olaylar yine çok kolay bir şekilde görülebiliyor ve programlanabiliyor. Formlar üzerine öğeler eklemek, boyutunu değiştirmek, bu öğeleri konumlandırmak, aksiyonlarını ayarlamak ve olayları tanımlamak gibi birçok ince detayı sadece farenizi kullanarak yapabilmek bizlere gerçekten önemli miktarda hız kazandırıyor.

İlk Uygulamamız

Sanırım en iyisi bir “Merhaba Dünya” uygulaması hazırlayarak anlattıklarımızın ne kadar kolay olduğunu deneyerek görmek. Visual Studio’yu açtıktan sonra New Project tuşuna tıklıyor ve artık “Windows Forms Application” öğesini seçiyoruz. Bu aşamadan sonra gri bir tual şeklinde boş formumuz karşımıza çıkacaktır. Dikkat ettiyseniz Formların ve üzerine eklediğiniz birçok aracın köşelerinde ve kenarlarının ortalarında bulunan daireler bu öğelerin yeniden boyutlandırılabilmesine olanak tanır. Kullanabileceğimiz bütün forms araçları ise solda bulunan araç kutusu (Toolbox)  içerisinde çeşitli kategorilere ayrılmış bir şekilde bizi beklemekte. Dilerseniz burada bütün öğelerin bulunduğu ilk sekmeyi açın ve buradan bir düğme (button) öğesini fareniz ile formun üzerinde istediğiniz yere taşıyın. Bu şekilde araçları taşırken çıkan kılavuz çizgileri ile doğru hizalama yapabildiğimizi ve birçok aracın düzenli bir şekilde yerleştirilebildiğini de hatırlatalım.

Çoğunlukla faremizi kullanarak bir Forms uygulaması hazırladık!

Dizayn ekranında bulunan her türlü öğenin sahip olduğu stil, fonksiyon ve değişkenleri değiştirmeye yönelik birçok özelliği bulunmaktadır. Bu özellikleri görebilmek ve değiştirebilmek için bu öğelere sağ tuşla tıklayıp özellikler (Properties) seçeneğini seçerseniz, ekranın sağ tarafında ilgili bölmesi açılacaktır. Örneğin yeni yerleştirdiğimiz butonu düşünecek olursanız burada fare ile değiştirebildiğimiz konum ve boyut özelliklerinden, butonun rengi, biçimi, üzerindeki yazı ve bu yazının stili gibi birçok ince ayara ulaşabilmemiz mümkün.

Dilerseniz ilk örneğimizi tamamlamak için butonun üzerine bir tane metin kutusu (TextBox) aracını da araç kutusundan seçerek formumuza yerleştirelim. Uygulamamız buraya yazacağımız değeri alarak bir mesaj kutusu içerisinde gösterebilen temel bir uygulama olacak. Ancak yine de metin kutusunun başına bir açıklama koymak isteyebiliriz ve bunun için tek yapmamız gereken araç kutusundan bir etiket (Label) nesnesini faremiz ile forma eklemek olacaktır. Özellikler bölmesinde bulunan Text değerlerini değiştirerek bu öğelerin metin değerlerini istediğimiz gibi ayarlayabiliriz. Yeni eklediğimiz Label ve Button nesnesinin bu değerini de ayarladıktan sonra sıra geldi butona basıldığında nelerin olacağını ayarlamaya.

ToolBox içerisinde birçok araç mevcut.

Events

Dilimize “olaylar” olarak çevirebileceğimiz events, bir öğenin belirli şartlar altında yapacağı aksiyonları belirleyen fonksiyonları uygulamaya ekler. Uygulamanın çalışması esnasında farenin bir öğenin üzerine gelmesi, belirli bir tuşa basılması veya seçili duruma gelmesi gibi kullanıcı tarafından meydana getirilen bu olaylar, programda bulunan belirli bir fonksiyonu tetikleyerek istediğimiz aksiyonun gerçekleşmesini sağlar. Birçok araç için en çok kullanılan olayların fonksiyonları, o aracı bir formun üzerine sürükledikten sonra üzerine fare ile çift tıklarsanız otomatik olarak kod sayfasına eklenecektir. Ancak bunlardan farklı bir olay için fonksiyon tanımlamak isterseniz, bunu Properties bölmesinde bulunan Event butonuna tıklayarak çıkan olay listesinden ilgili olaya çift tıklayarak gerçekleştirebilirsiniz.

Araçlar değişik olaylara yanıt verebiliyorlar.

Bizde ilk örneğimizde eklediğimiz düğmeye tıklandığında bir mesaj kutusu ile kullanıcılarımıza selam vermek istiyoruz. Bunun için dizayn ekranında eklediğimiz butona çift tıklayarak onun olay fonksiyonunun (button1_Click) yaratılmasını sağlıyoruz. Daha sonra bu fonksiyona bir mesaj kutusu içerisinde önceden eklediğimiz metin kutusundan alacağımız değerle birlikte bir mesajı aşağıdaki kod ile yazdırabiliriz:

private void button1_Click(object sender, EventArgs e)

{

MessageBox.Show("Merhaba, " + textBox1.Text + "!");

}

Burada MessageBox, Windows Forms kütüphanesi altında bulunan mesaj kutularına ait nesnedir. İçerisine aldığı string tipindeki değişken değerini göstermeye yarar ve konsol uygulamalarında sıkça kullandığımız Console.WriteLine() fonksiyonu gibi kullanıcıya mesaj vermekte kullanılır. Burada dikkat etmemiz gereken diğer bir nokta textBox1 ismindeki değişkendir. Formumuza ekleyeceğiniz bütün araçlar, isminin küçük harfle başlayan ve sonunda bir numara görebileceğiniz değişkenler yardımıyla kod içerisinde kontrol edilebilir.  İlk örneğimizi bitirdikten sonra diğer araçların kullanımını öğrenmeye devam edebiliriz.

Button aracının özellikleri.

En önemli GUI nesneleri arasında sayabileceklerimizden biri hiç şüphesiz diğer araçları içinde bulunduran panellerdir. .NET içerisinde bulunan panel araçlarından biri olan sekmeler ise programcılar tarafından en çok sevilenlerden biridir. Dilerseniz ikinci örneğimize geçmeden önce formumuza bir sekme kontrolü (TabControl)  aracı ekleyerek ikinci örneğimizi farklı bir sekmede hazırlayalım. Sekmeler tabPage adı verilen yapraklardan oluşur ve sekme kontrol nesnesine sağ tuşla tıklayınca menüden  “Add Tab” seçeneği ile bu yaprakların yenilerini eklemek mümkündür. Biz ikinci örneğimizde doğumumuzdan itibaren kaç gün geçtiğini hesaplayan küçük bir uygulama hazırlayacağız ve bunun bütün bileşenlerini ikinci sekmemizde bulunduracağız.

Dizayn ekranında formda bulunan ikinci sekmeye tıkladığınızda boş bir panel elde etmiş olacağız. Bu alana doğum günümüzü girmemiz için bir metin kutusu ekleyebilirdik ancak bu tür tarih konularında kullanıcılara daha kolay bir arayüz sağlayan DateTimePicker aracı işimize daha çok yarayacaktır. Bu aracı formumuza ekledikten sonra altına bir buton yerleştirerek şimdiki zamanla seçilen tarih arasında kaç gün geçtiğini hesaplayan fonksiyonu çalıştıracak bir tetikleyici bulundurabiliriz. C# içerisinde geçerli tarih ve saat  değerlerini tutmak için hazırlanmış bir veri tipi bulunur. DateTime ismindeki bu veri tipleri 1970 yılı Ocak ayından beri artan bir değere sahiptir ve bu değere göre zamanı saklar. Sakladığı değer long tipinde bir sayı olsa da, tarihsel bir değer istediğimiz zaman bize yıl, hafta, gün ve saat gibi farklı aralıklarda istediğimiz türden veri döndürebilen fonksiyonları bulunmaktadır. DateTime nesnelerinin bir diğer kullanım alanı da Now isimli özelliğinin “çağırıldığı zamanı” döndürerek zaman aralığı hesaplamalarında bize yardımcı olabilmesidir.

private void button2_Click(object sender, EventArgs e)

{

//Örnek 2

DateTime dt = dateTimePicker1.Value;

DateTime simdikiZaman = DateTime.Now;

TimeSpan zaman = simdikiZaman - dt;

MessageBox.Show("Siz dogduktan sonra " + zaman.Days +" gün geçmis. ");

}

Ancak iki zaman arasında matematiksel işlem yapmak kolay olmayacağı için TimeSpan isimli başka bir nesneden de yardım almamız gerekebilir. Biz de örneğimizde butonumuzun tıklanma olayına önce DateTimePicker nesnesinin sahip olduğu değeri ve şimdiki zamanı saklayan iki adet DateTime nesnesi oluşturarak başlıyoruz. Daha sonra eklediğimiz bir TimeSpan objesi bu öğelerin arasındaki zamanı saklamak için kullanılıyor. En son yaptığımız işlem ise ortaya bir mesaj kutusu çıkararak bu iki tarih arasında kaç gün olduğunu kullanıcıya bildirmek oluyor.

İkinci örneğimizin dizayn görüntüsü.

Windows Forms uygulamalarına giriş yapmamızı sağlayan örneklerimizde bazı kullanıcı arayüzü araçlarını tanıtma fırsatımız oldu. Aralarında renk seçmeye yarayan ColorDialog gibi aşina olduklarımızdan, seri porttan veri gönderip almaya yarayan araçlara kadar birçok çeşit bulunan bu araçları, sahip olduğu özellikleri ve olayları boş zamanlarınızda incelemenizi tavsiye ederim. C# ve .NET ile geliştirilmesi çok kolay bir hal alan Forms uygulamaları, internet tabanlı uygulamalar ne kadar gelişse de günümüzde hala oldukça yoğun kullanıma sahip olan ve kullanıcıya gerçekten birçok kolaylık sağlayan bir yapıya sahip. Hazırladığınız uygulamayı kullanıma açmadan önce farklı bilgisayarlarda, çözünürlüklerde ve farklı sürüm Windows işletim sistemlerinde denemeniz de önemli. Örneğin bir takım araçların stil ve görünüm özellikleri farklı Windows temaları altında bile değişiklik gösterebilir.

Bu yazıyla birlikte blogumdaki C# dersleri serisinin sonuna geliyorum..  Dersler hakkındaki görüşlerinizi benimle paylaşırsanız çok sevinirim, umarım bu yazılar bazılarına yardımcı olabilmiştir! :) Sizden gelen görüşlere göre derslere devam edebilir yada farklı konularda buna benzer yazılar hazırlayabilirim, yeter ki fikirlerinizi belirtin :)

p.s. Bu yazı Ocak 2009 tarihinde yazılmıstır.

Veri yönetim biçimleri her programlama dilinde farklıdır. Nesne tabanlı programlama dillerinde ise çalışma sırasında bütün veriler nesnelere dönüşür ve referans ya da doğrudan bağlantıyla program akışı içerisinde kullanılırlar. C# altında da bütün veri tipleri ikiye ayrılır: temel tipteki nesneler ve sınıf referansı nesneleri. Temel tipteki nesneler önceki örneklerimizde bolca kullandığımız, byte, sayı, karakter veya metin değeri alan int, char veya string gibi C# içerisindeki dahili tiplerdir. Diğer veri tipleri ise bizim yazdığımız sınıflar (class) kullanılarak üretilen nesnelerdir.. Sınıflar nesne yönelimli programlamanın çekirdeğini oluşturan en küçük yapılar olarak projenizin sürdürülebilirliği, geliştirilebilir ve güvenliğine katkıda bulunur.

Ancak sınıf yapısına geçmeden önce, sınıfları oluşturan diğer bir önemli unsur olan fonksiyonlara değinmeliyiz. Programlama dillerinin en çok kullanılan özelliklerinden biri olan fonksiyonlar, belirli parametreler alarak çalışan ve kendi içinde belirlenen hesaplamayı yaparak cevabı çağrıldığı yere döndürebilen yapılardır. Özellikle uygulamamızın kodlarında birbirini tekrar eden yerler olduğunda veya birçok yerde kullanacağımız bir fonksiyonu defalarca yazmamız gerektiğinde fonksiyonlar yardımımıza koşar. ayrıca fonksiyon kullanmak, bu çok tekrar eden kodlarda herhangi bir değişiklik yapmamız gerekirse tek yerden bu değişikliği bütün uygulama çerçevesinde gerçekleştirmemize olanak verir.

Fonksiyon Kullanımı

Bütün fonksiyonlar stabil bir yapı içerisinde tanımlanır ve fonksiyona ait kodlar geçmiş eğitimlerde gördüğümüz döngülerde olduğu gibi süslü parantezler { ve } arasına yazılır. Yine burada önemli olan, bu parantezler ile kod blokları oluşturduğumuz için parantezi kapattıktan sonra noktalı virgül kullanmamamız gerektiği. Kodumuzu yer aldığı alandan önce fonksiyonun erişim parametreleri, döndüreceği değer, ismi ve varsa aldığı parametreler yazılmalıdır. Fonksiyonlar amaçlarına göre kendi yazıldığı sınıf içerisinde kullanıldığı gibi, başka sınıflar tarafından da ilgili sınıfın bir nesnesi yaratılarak kullanılabilirler. Bir fonksiyonu çağırmak için, eğer aynı sınıf içerisinde ise fonksiyon(parametreler) şeklinde çağırabilir, farklı bir sınıf içerisinde tanımlıysa ileride değineceğimiz şekilde o sınıftan bir nesne yaratarak çağırabiliriz. Bu sayede birçok sınıf birlikte çalışabilir ancak bazı fonksiyonlar sadece o sınıfın kendi iç işleyişi için gereklidir ve o dışarıdan çağırılmaması hatalara neden olmaması adına önemlidir. Bu yüzden fonksiyon tanımlamalarına başlarken ilk önce bir erişim denetliyici parametre kullanarak ilgili fonksiyonun hangi sınıflar tarafından görülebileceğini belirtebiliriz. Kullanabileceğimiz farklı değişkenlerden en önemlileri “public” ve “private”’dir. Eğer bir fonksiyonun uygulamanın bütün sınıfları tarafından çağrılmasında bir sakınca yoksa onu ortak yani “public” olarak tanımlamalıyız. Ancak tersi bir durum içi gizli (private) bir fonksiyon olarak tanımlayarak ilgili sınıf dışından kullanılmasını engelleyebiliriz.

Örnek fonksiyon deklerasyonu

İkinci adım olarak fonksiyonumuzun dönüş parametresini belirlemeliyiz.  Hesap yapmakla görevli bazı fonksiyonlar, hesaplamaları yapacakları değerleri parametre olarak aldıktan sonra, ilgili işlemleri kendi içinde yapar ve yaptığı hesabın sonucunu geri döndürebilir. Biz bu dönen değeri başka bir değişkene atayabilir ya da ekranda yazdırabiliriz. İlk örneğimizde konsolda çalışan basit bir hesap makinesi hazırladık. Burada gördüğünüz gibi Islemler isminde bir sınıfımız bulunmakta ve bu sınıfın içerisinde Topla ve Carp adında iki fonksiyon mevcut. Ondalık sayı değerini ifade eden double türünden değerleri toplayabilen ve çarpabilen bu fonksiyonlar başka sınıflardan da çağırılabildiği için public olarak erişilebilir kılınmış ve sonuç olarak bir ondalık değer döndürebileceğinden double türünden bir dönüş değeri tanımlanmış.

İlk örneğimizin ekran çıktısı

Ancak fonksiyonların her zaman bir değer döndürmeleri zorunlu değildir. Örneğin ekrana yazı yazdıran veya veritabanına girdiler ekleyen bir fonksiyonun çağrıldığı yere bir değer döndürmesi gereksizdir. Böyle durumlarda döndürülecek değerin olmadığını belirten void ifadesi yazarak fonksiyonumuzu tanımlıyoruz. Fonksiyonların döndürmesi gereken değerler olduğunda ise, bu değeri hesaplandıktan sonra return anahtar sözcüğünü kullanılarak çağrıldığı noktaya iletebiliriz. Örneğimizdeki Topla ve Carp fonksiyonları da aldığı değerleri basit olarak matematiksel bir işlem yaptığı için bunları direk return ifadesinin yanında gerçekleştirebiliyoruz. Burada dikkat etmemiz gereken nokta, return ifadesinin fonksiyonu sonlandırdığını bilmek. Bu ifadeden sonra fonksiyondan çıkılacağı için “return”’ü bütün işlemlerini bitirdikten sonra ya da bazı koşullar sağlandığında çıkmak isterseniz if gibi ifadelerin içerisinde kullanmamız gerekiyor.

IntelliSense programcılara çok büyük kolaylı sağlıyor.

Dönüş tipini belirledikten sonra fonksiyonumuza bir isim verip, parantezler içerisinde fonksiyonun alacağı ifadeleri tanımlıyoruz. Fonksiyon içinde kullanılacak parametreler burada vereceğimiz isimler ile anılan lokal değişkenler haline gelirler. Ayrıca parametre isimlerinden önce mutlaka veri tiplerini de belirmemiz gerekmekte.

Sınıf ve Nesneler

Daha önce bahsettiğimiz gibi, belirli fonksiyonların sınıflar altında gruplanarak uygulama içerisinde belirli bir işlevi yürütmeye çalışırlar. Geçtiğimiz eğitimlerden hatırlayacak olursanız, C# ta uygulamalar, Main ismindeki özel bir fonksiyon ile başlar. Yani programımız çalışırken bu Main fonksiyonu aranır ve bütün işlemler bu fonksiyon ile başlatılır. Önemli olan bir nokta, bütün program içerisinde sadece bir adet Main fonksiyonunun olması gerektiğidir. Programımız sahip olduğu nesneleri kullanarak işlevlerini yerine getirir ve sınıflar bu nesnelerin yaratılması için gerekli bir kalıp görevi görür.

Yaratılan nesneler kendi isimleriyle çağırılırlar ve bağlı bulunduğu sınıfın fonksiyonlarını çalıştırmamıza imkân verirler. Bir sınıftan yeni bir nesne yaratmak için ise yeni anlamına gelen “new” anahtar sözcüğünden yararlanıyoruz.

Ornek nesneİsmi = new Ornek();

Şeklinde örnek bir sınıfa dair yeni bir nesne yaratabiliriz. Daha sonra nesneİsmi bu nesnenin referansı haline gelecek ve kodun ilerleyen kısmında bu nesneyi temsil edecektir. Herhangi bir nesnenin içerdiği fonksiyonlara, o nesnenin yanına bir nokta koyarak ulaşabiliriz. Bu gibi durumlarda noktadan sonra ilgili fonksiyonun ismini yazmamız gerekse de Visual Studio’nun IntelliSense adı verilen özelliği, siz nokta işaretini koyduğunuz anda kullanabileceğiniz fonksiyonları imlecin sonunda size listeliyor. Bütün geçerli değişkenleri, fonksiyonları ve aldığı parametreleri görebileceğimiz bu liste gerçekten çok büyük bir zaman avantajı sağlamakta.

Örnek sınıf ve isim uzayı kullanımı

Yeni bir sınıf yaratmak için sağ tarafta bulunan Solution Explorer içerisinde projemize sağ tuşla tıklayıp, New Item -> Class seçeneğini seçebiliriz. Burada görebileceğimiz gibi sınıf (class) ismi otomatik olarak atanacaktır. Burada class anahtar sözcüğünden sonra sınıfımızın ismini yazıyor ve sonraki kod blokları içerisine ilgili kodlarımızı yazıyoruz. Burada dikkat çekici diğer bir ifade ise namespace ifadesiyle tanımlanan isim uzaylarıdır. İsim uzayları c# içerisindeki sınıfların gruplandığı, içerisine toplanan belirli gruptaki sınıfların bir katman olarak kullanılabildiği üst yapıdır. Aynı gruptaki bütün sınıflar, aynı isim uzayı içerisinde çalışmalıdır ve bu isim uzaylarının isimleri namespace ifadesinin yanında belirtilir.

Bütün uygulamalar Main fonksiyonu ile başlarlar..

Sınıflar içerisinde bütün fonksiyonların ve diğer sınıfların görebileceği değişkenler oluşturmak ta mümkündür. Global değişken denilen bu tipler, başına yazılan bir erişim denetleyicisi sayesinde diğer sınıflar tarafından görünebilirliğini değiştirebilir. Fonksiyonlar içerisindeki lokal veriler ile çakışmaması için bu değişkenlere farklı bir isim atamak doğru bir karar. Yine de bir fonksiyon içinde this.GlobalDeğişkenAdı biçiminde bu değişkenlere ulaşmak mümkündür.

Sınıflar için oldukça önemli olan bu global değişkenlerin ilk atamalarının yapılması ise diğer bir önemli konu. Nesneleri oluşturmak için bir kalıp olarak kullandığımız sınıflar, bu değişkenlerin aldığı değerler ile birbirinden farklı nesneler üretebilirler. Bu değişkenlere değer veren fonksiyonlar oluşturabileceğimiz gibi, direk nesne oluşumunda da bu değişkenlere değerini atayabiliriz. Yapılandırıcı (constructor) denilen özel yapılar bir nesne oluşturulmadan bu atamaları ve varsa farklı işlemleri yapmamıza olanak verir.  Yapılandırıcı oluşturmak için herhangi bir dönüş tipi olmayan ve sınıfla aynı isimdeki fonksiyonları kullanırız. Örneğin Arac isimli bir sınıfımız varsa;

public Arac(int hiz, string renk)  { … }

Şeklinde bu sınıfa örnek bir yapılandırıcı oluşturabiliriz. Buradaki “hiz” ve “renk” değerleri, Arac sınıfının ilgili global değişkenlerini atamakta kullanılabilirler. Bu aşamadan sonra yapılandırıcı kullanılarak oluşturulan nesneler gerekli başlangıç değerlerini alarak oluşmuş olurlar. Bir örnek vermek gerekirse, aynı Arac sınıfından bu şekilde yeni nesne yaratabiliriz:

Arac yeniArac = new Arac(180, “mavi”);

Burada new ifadesinin yanında Arac sınıfının yapılandırıcısı doğrultusunda değerler vererek sınıfı başlangıç değerleriyle yaratabiliyoruz. Son olarak ikinci örneğimize bakacak olursak, yarattığımız bir Saat sınıfının saat, dakika ve saniye olmak üzere 3 global değişkeni bulunmakta. Bu değişkenler bir yapılandırıcı sayesinde nesne yaratıldığında değer alıyor ve SaatiGoster fonksiyonu ile ekrana yazdırılıyorlar. Saati gösteren fonksiyonumuzu döneceği bir değer bulunmadığı için void ifadesi ile yaratıyoruz. Konsol uygulamalarında göstereceğimiz bu son örnek ile C# derslerinin bu bölümünü tamamlıyoruz.. Bir sonraki yazıda görüşmek üzere ;)

p.s. Bu yazı Aralık 2008 tarihinde hazırlanmıştır.

İkinci örneğimizin sonuç ekranı

Örnek Kod 1:

//1. Örnek

class Islemler

{

public double Topla(double a, double b)

{

return a + b;

}

public double Carp(double a, double b)

{

return a * b;

}

public static void Main()

{

//Once sınıfımızdan bir nesne yaratıyoruz.

Islemler hm = new Islemler();

//Örnek olarak 10 ve 20 sayısını kullanıyoruz.

Console.WriteLine(“Toplam: ” + hm.Topla(10, 20) + “\nÇarpım: ” + hm.Carp(10, 20));

}

}

Örnek Kod 2:

//2. Örnek

class Saat

{

public int saat;

public int dakika;

public int saniye;

public Saat(int yeniSaat, int yeniDakika, int yeniSaniye)

{

saat = yeniSaat;

dakika = yeniDakika;

saniye = yeniSaniye;

}

public void SaatiGoster()

{

Console.WriteLine("Saatimiz: " + saat + ":" + dakika + ":" + saniye);

}

static void Main(string[] args)

{

//Saat sınıfından yapılandırıcıyı kullanarak bir nesne yaratıyoruz.

Saat saatim = new Saat(22, 10, 56);

//SaatiGoster fonksiyonunu cagiriyoruz.

saatim.SaatiGoster();

}

}

Programlama dillerinde dizileri kullanmak bizi birçok satırda yazacağımız kod satırlarından ve birçok değişkenin yarattığı karışıklıktan kurtararırken, aynı işlemleri tek satır bir koda dönüştürerek daha basite indirgenmiş anlaşılır bir hale getirir. Örneğin 10 tane değişkenle işlem yapabilen bir uygulamayı yazmak çok zor değildir, ancak binlerce sayı kullanarak hesaplama yapmamız gerektiğinde bütün değerler için yeni bir isim bularak yeni değişkenler yaratmamız tamamen bir vakit kaybıdır. Dizilerin kullanımı bize zamandan kazanç sağlar ve daha sağlıklı kodlar üretmemize olanak tanır. Temelde sıralı olmayan elemanların bir araya gelmesiyle oluşan diziler, belirli bir sayıda veriyi bir değişkene bağlar ve bu değişken üzerinden döngü yapılarıyla bütün verilere çok hızlı bir biçimde arama, sıralama, değiştirme gibi işlemleri uygulamanıza imkân verir. Dizi tipindeki bir değişken içerisinde istediğimiz kadar veri tutmamız mümkündür, ancak burada önemli nokta bütün verilerin tiplerinin aynı olması gerektiğidir.

Diziler birçok değişkeni bünyesinde barındırırlar..

Dizilerin Kullanımı

Tanımlandıktan sonra bilgisayarınızın belleğine yazılan bu diziler, 0’dan başlayan indekslere (indis olarak da adlandırılır) sahiptir ve dizi içerisinde belirli bir sıradaki elemana erişim bu indeks ile gerçekleştirilir. Programlama diline göre farklılık gösteren başlangıç indeksinin 0 olması, örneğin 5. elemanı getirmek için indeksi 4 olan öğeyi çalıştıracağınız anlamına geldiği için dikkatli olmamızı gerektirir. Yeni bir dizi yaratma işlemi 2 adımda gerçekleşir. Primitif değişkenler yaratırken yaptığımız gibi diziyi tanımlarız ve bundan sonra bir nesne yaratırken kullandığımız “new” anahtar sözcüğü ile dizimizi oluşturabiliriz. Bu iki adımda değişkenlerden farklı olarak kare parantezler kullanarak yarattığımız şeyin bir dizi olduğunu belirtiyoruz. Örneğin 5 elemanı olan bir int dizisi yaratmak için:

int[] ornek = new int[5];

ifadesini kullanmamız yeterli. Böylece “ornek” isminde 5 adet sayıyı barındıran bir dizi değişkeni yaratmış oluyoruz. Dizimizin barındırdığı elemanlara erişmek için indeks sayıları kullanıldığından yukarıda bahsetmiştik. Değişken ismine bitişik yazdığımız kare parantezleri kullanarak bu indeks sayılarını belirtebilir ve istediğimiz elemana erişebiliriz. Örneğin yukarıda yarattığımız 5 elemanlı dizinin son elemanını değiştirmek için

ornek[4] = 100;

yazmamız yeterli. Eğer bu elemanı daha sonra bir işlem içerisinde kullanmak veya yazdırmak istiyorsak yine indeksini belirterek kullanmamız mümkün. Aşağıdaki kod ile aynı elemanımızı konsola yazdırabiliriz:

Console.WriteLine(ornek[4]);

Dizilerin kullanımında aklımızda bulundurmamız gereken en önemli husus ise, her dizinin yaratılırken boyunun belirlenmesi gerektiğidir. Hatırlarsanız “ornek” isimli dizimizi yaratırken kullandığımız new int[5] ifadesindeki 5 bu dizinin boyutunu belirler. Belirlediğimiz boyut kadar bilgisayarın belleğinde (RAM) yer ayrıldığı için dizileri oluştururken mutlaka boyutunu belirlememiz gerekir ve bu boyutu daha sonradan değiştirmemiz mümkün değildir. Varolan bir dizinin boyutunu değiştirmenin tek yolu yeni bir dizi oluşturup mevcut dizinin bütün elemanlarının bir döngü içerisinde yeni diziye aktarılmasıdır. Eğer dizi yapınızın boyutunun dinamik olarak artması önemli ise, daha farklı bir veri yapısı (ör: ArrayList) da kullanabilirsiniz.

İlk örneğimizin ekran görüntüsü..

Aslında değişkenlerin bir kümeyi oluşturduğu veri yapıları olan dizilerin bir diğer özellikleri ise boyutlarıdır. Yukarıda bahsettiğimiz tek bir indeks sayısı olan diziler gibi olanlar tek boyutlu, satır ve sütun olarak veri depolayabilenlere çift boyutlu diziler denir. Günümüzde bazı dillerde bulunan ikiden fazla boyut destekleyen çok boyutlu dizileri C# içerisinde oluşturmamız mümkündür ancak bunların kullanım alanları kısıtlıdır.

Tek Boyutlu Diziler

Daha önce nasıl oluşturabileceğimizi gördüğümüz bu diziler ile ilgili olarak asıl bilmemiz gereken, onların döngüler içerisinde kullanımıdır. Geçtiğimiz ay değindiğimiz for veya while döngüleri ile dizilere eleman atamak, mevcut elemanları görüntülemek veya değiştirmek gerçekten çok fazla kullanılan ve çok hızlı yapıldığı için bir nevi hayatımızı kolaylaştıran işlemlerdir. Dizinin eleman sayısı kadar çalışan döngüleri özellikle tek boyutlu dizilerde kullanmak zor değildir. Yapmamız gereken tek şey dizilerin boyutunu döndüren “Length”  özelliğini kullanarak geçtiğimiz ay öğrendiğimiz sayaç kullanılan döngüler oluşturmak. İsterseniz ilk örneğimizde 100 elemanlı double tipinde bir dizi yaratalım ve 1’den 100’e kadar olan sayıları bu diziye dolduralım. Elemanları görüntüledikten sonra bütün hepsini ikiye bölerek tekrar konsolda görüntüleyelim. Cümleleri takip ettiyseniz burada yaptığımız dört farklı işlem bulunmakta. Önce diziyi dolduruyor, ekranda gösteriyor, sonra ikiye bölüp en sonunda tekrar görüntülüyoruz. Bütün bu işlemlerin bir for döngüsü içerisinde yapıldığı ilk örneğimizi Örnek Kod 1 içerisinde (yazının altında) bulabilirsiniz.

C# çok boyutlu dizilere de destek veriyor..

Hazırladığımız döngüleri inceleyecek olursak, hepsinde bir “i” sayaç değişkenimiz bulunmakta ve bu değişken 0’dan başlayarak dizi boyutuna gelmeden durmaktadır. İşte dizilerin döngü ile etkileşime geçebilmesi bu değişken sayesinde gerçekleşiyor. Sayacı dizimizin indeks sayısı olarak kullanabiliyoruz ve sayaç her döngüde değiştiği için bizde sürekli dizimizin farklı bir elemanına varolan işlemi uygulamış oluyoruz. Örneğimizde dikkat edeceğimiz diğer bir nokta ise, bizim dizi elemanlarını eşitlemek istediğimiz sayı değerleri 1’den başlıyordu ancak biz sayacımızı yine de 0’dan başlattık. Dizilerin indeks sayısı 0 olduğundan ve döngü sayacını dizimizin indeksi olarak kullandığımızdan “i” değişkenini bu değerler ile tanımlamak zorunda kaldık.

İki boyutlu diziler tablo yapısındadır.

Çok Boyutlu Diziler

Dizilerin birçok farklı alanlardaki kullanımı, onun tek düze gidişatını bozmamızı gerektirebilir. Sakladığımız değerler ile ilişkili başka değerleri de bu verinin bulunduğu satırda bir tablo gibi tutmamızı gerektiren pek çok uygulama vardır. Örneğin matris işlemleri, birçok oyundaki veriler genelde iki boyutlu diziler ile çalışırlar. Excel gibi çizim tablolarından alışık olduğumuz satır ve sütun mantığı burada da geçerli olmakla beraber, bu dizileri kontrol edebilmek için boyut sayısı kadar iç içe döngüye de ihtiyaç duyarız. Çok boyutlu dizilerin C# içerisindeki söz diziminin mevcut diğer programlama dillerinden farklı olduğunu da söylemekte fayda var. Yine 2 adımda oluşturduğumuz dizilerimizi tanımlama sırasında yazdığımız köşeli parantezlerin içerisine virgül koyarak bir boyut daha artmasını sağlıyoruz. Yani buraya iki adet virgül koyarsanız diziniz üç boyutlu olacaktır. Bundan sonra oluşturma sırasında aynı şekilde boyut değerlerini, araya bu virgüller gelecek şekilde yazmanız yeterli.

double [,] ikiBoyutlu = new double[10,30];
int[, ,] ucBoyutlu = new int[3, 5, 8];

Şeklinde çok boyutlu dizilerinizi oluşturabilirsiniz. İsterseniz konuyu daha iyi anlayabilmek için Tablo 2 içerisinde verdiğimiz örneği inceleyelim. Bu uygulamamıza 10’a 30’luk iki boyutlu dizi oluşturarak başlıyoruz. Bu tanımlamadan sonra gördüğünüz iç içe for döngüleri aslında çok boyutlu dizinin bütün elemanlarına giden aynı döngüler. Sadece ilkinde bütün dizi elemanları doldurulurken ikinci döngüde bu elemanlar konsola yazdırılıyor.  İç içe döngülere dair bilmemiz gereken tek şey dışarıdaki döngünün satırlar, içerideki döngünün sütunları kontrol ettiği.

İkinci örneğimizin ekran görüntüsü..

Döngüler ile dışarıdan içeriye doğru tablo şeklindeki veri yapımızın bütün elemanlarını seçerken tek boyutlu dizilerden farklı olan diğer bir nokta da, Length özelliğinin bu tür dizilerde kullanımının çok tehlikeli olması!  Satırlar arasında ilerleyen dışarıdaki for döngüsü için sadece satır sayısı, sütunlar arasında gezen içerideki for döngüsü için sadece sütun sayısı önemlidir. Bir dizinin bütün elemanlarının sayısını döndüren “Length” özelliği ise satır ve sütun kavramlarını gözetmediğinden for döngülerinde indeks sayısının taşması sonucu birçok hatanın ortaya çıkmasına yol açabiliyor. Bunun çözümü ise örneğimizde görebileceğimiz gibi, dizilerin getLength(boyut) fonksiyonu ile istediğimiz boyutun uzunluğunu for döngümüzün içerisinde kullanmak. Fakat boyutların da 0’dan başlayan bir indeksi var ve bu yüzden satırlar için getLength(0), sütunlar için getLength(1)  yazarak kullandık.

Son Sözler

İkinci örneğimizin bir tablo gibi görünmesini ise içerideki for döngüsünden sonra bir satır atlayıp elemanları konsola yan yana yazdırarak sağladık. Özellikle çok boyutlu dizilerin kullanımına alışmak maalesef önceki eğitimlerimizin konularına göre daha zor. İç içe for döngülerinin yapısını anlamak özellikle ilk görüşte bunu başarmak gerçekten çok zor. Ancak uygulama geliştirirken gerçekten fazla kullanılan temel konular olduğu için dizilere hükmetmeye çalışmanızın ilerideki projelerimiz açısından çok faydalı olacağını düşünüyorum. Bu yüzden diziler ile ilgili örneklerimizi geliştirerek değişik uygulamalar tasarlamanızı tavsiye ederim.

p.s. Bu yazı Kasım 2008′de yayımlanmıştır.

Örnek Kod 1:

//Örnek 1

//double tipinde elemanlar içeren dizimizi oluşturuyoruz.
double[] ornek = new double[100];

//Dizimizi 1-100 arası sayılar ile dolduruyoruz.

for (int i = 0; i < ornek.Length; i++)

{

ornek[i] = i + 1;

}

//Bütün dizimizin elamanlarını ekranda gösteriyoruz.

for (int i = 0; i < ornek.Length; i++)

{

Console.WriteLine(ornek[i]);

}

//Bütün elemanları 2'ye bölüyoruz.

for (int i = 0; i < ornek.Length; i++)

{

ornek[i] = ornek[i] / 2;

}

//Elemanların son değerini tekrar ekranda görüntülüyoruz.

for (int i = 0; i < ornek.Length; i++)

{

Console.WriteLine(ornek[i]);

}

Örnek Kod 2:

//Örnek 2

double [,] ornek = new double[10,30];

for (int i = 0; i < ornek.GetLength(0); i++)

{

for (int k = 0; k < ornek.GetLength(1); k++)

{

ornek[i, k] = i;

}

}

for (int i = 0; i < ornek.GetLength(0); i++)

{

for (int k = 0; k < ornek.GetLength(1); k++)

{

Console.Write(ornek[i, k]);

}

Console.WriteLine("");

}

Üstelik karekök hesaplayan algoritmalarda olduğu gibi bazı durumlarda yapmamız gereken işin ne zaman tamamlanacağını önceden kestirmemiz de imkansızdır. İşte bu tip uzun tekrarlar ya da iştediğimiz şart oluşana kadar aynı işlemin yapılmasını istediğimiz durumlarda döngüleri kullanıyoruz. Önceki yazılarımızda bahsettiğimiz gibi, normalde uygulamamız çalışırken kodlar yukarıdan aşağıya satır satır işlenir ve son satır işlendikten sonra program sonlandırılır. Bizim kullanacağımız döngüler ise süslü parantezler kullanarak oluşturduğumuz kod bloğunun, belirli bir koşul sağlanmışken sürekli kendini başa alarak tekrar işlenmesine imkan tanıyor. C# içerisinde farklı tip döngüler olsa da bunların hepsi barındırdığı koşul sağlandıkça içerisindeki kod bloğunu çalıştırırlar ve koşul yanlış olduğunda sonlanırlar. Şimdi isterseniz bu döngü tiplerinin kullanımını örnekler ile inceleyelim.

While Döngüsü

Türkçe’ye  “sırasında” veya “-iken” olarak çevirebileceğimiz “while” anahtar sözcüğü, while(koşul) {kod} biçiminde döngü yaratmamızı sağlar. While yanında bulunan parantezler içerisinde yazılan koşul doğru olduğu sürece koşul parantezlerinden sonra gelen süslü parantezler içerisindeki kod bloğunu çalıştırılır. Bu döngü tipinin çalışma biçimini kafanızda canlandırmanız için hemen gerçek hayattan bir örnek verebiliriz. Örneğin su dolu bir sürahiyi bir bardak kullanarak başka bir kaba boşaltmak istiyoruz. Burada yapacağımız iş, sürahiden su dökerek bardağı doldurmak, sonra bardak içerisindeki suyu kaba dökmek olacaktır. Programlama mantığında düşünecek olursak, “sürahide su bulunması”nı koşul olarak seçersek istediğimizi gerçekleştirebiliriz. Şimdi bir while döngüsü kuracak olursak; sürahide su bulunması koşulu doğru olduğu sürece, yapacağımız işi tekrarlamış olacağız. Başlangıçta sürahide su varsa, bardağı suyla doldurup kaba boşalttıktan sonra koşulumuz hala doğru mu diye sürahiye bakıyoruz. Eğer sürahide hala su varsa bardağı tekrar dolduruyoruz ve bu sürahide su kalmayana kadar böyle devam ediyor. Sanırım döngünün çalışma mantığını bu şekilde aklımızda tutabiliriz.

While ile oluşturduğumuz sayısal döngü kalıbı for döngülerinde geçerlidir.

İlk örneğimiz, önceden tanımladığımız “sayı” ismindeki bir değişkenin değerinin tek ya da çift sayı olduğunu bulan bir program. Burada while döngüsü içerisindeki kod bloğunda sayıdan sürekli 2 çıkarıyoruz. Koşulda yazdığımız tanım gereği sayı 1 veya 0’a eşitlenmedikçe buradaki kod bloğu çalışıyor ve çıkarma işlemlerine devam ediliyor. Sayı değişkenimiz bu 0 yada 1 değerine ulaşırsa artık koşul doğru olmayacağından döngü sonlandırılıyor, ardından yazdığımız if kontrolü ile kalan sayı eğer 1 ise sayının tek, 0 ise çift olduğunu belirliyoruz.

Belirli koşullar altında işlem yapan döngülerin diğer bir kullanımının da, biz programcıları uzun ve kendini tekrar eden kod yazmaktan kurtarması için olduğunu söylemiştik. Çok basit olarak ekrana bir yazıyı bin kere yazdırmak isterseniz bunu yapabilen bir kod oluşturmanız, kodu kopyalayıp yapıştırarak hazırlasanız bile çok uzun zamanınızı alabilir. İşte böyle durumlarda, bir sayaç değişkeni yardımıyla while döngüleri ile bir işlemin istediğimiz sayıda gerçekleşmesini sağlayabiliriz. İlk yapmamız gereken, int tipinde bir değişken oluşturmak. Bu değişkene döngüye girmeden önce bir sayı değeri atıyoruz, while döngüsünün kod bloğunun sonunda değerini değiştirerek, döngü koşulunda bu değeri kontrol ediyoruz ve bu şekilde işlemlerin istediğimiz kadar tekrar edebilmesini sağlıyoruz.

İkinci örneğimizde bu senaryoyu işleyen bir program yazdık. Sayac isimli int tipinde değişkenimize 0 değerini atıyoruz. While döngüsünün kod bloğunda ekrana yazı yazdıran satırda işlemi bitirdikten sonra, bu sayac değişkenimizin değerini bir artırıyoruz. Önceki yazılarımızdan hatırlayacak olursak, bir değişkenin sonuna eklenen ++ ifadesi, onun değerini bir arttırmak anlamına geliyor. Döngümüzün koşul bölümüne de, işlemin kaç kere tekrarlanacağını belirlediğimiz boolean (doğru ya da yanlış değer döndüren) ifadeyi yazıyoruz. Örneğimizde kullandığımız “sayac < 1000” ifadesi sayac 1000’den küçük olduğu sürece doğru (true) değerinde dönecek ve yazıyı bin defa ekrana yazdırmamızı sağlayacak. Keşke ilkokulda öğretmenimizin verdiği tahta doluncaya kadar aynı cümleyi yazdığımız cezalar için de böyle bir sistem olabilseydi J.

For Döngüsü

Yukarda örneğini verdiğimiz, sayaç kullanarak oluşturduğumuz sayısal döngüler programlamada çok sık kullanılır. Bu nedenle bu döngü kalıbını daha hızlı bir şekilde oluşturmaya yarayan for döngü tipi türetilmiştir. Kullanım şekli for(sayac oluşturma; koşul; artırım değeri) {kod} şeklinde olan bu komut ile daha hızlı sayısal döngü oluşturabiliyor ve ileride değineceğimiz sonsuz döngü oluşturma gibi hataların önüne geçmiş oluyoruz.

Üçüncü örneğimizi inceleyecek olursak, for ifadesi yanındaki parantezin içerisinin noktalı virgül “;” karakteriyle 3 farklı bölüme ayrılmış olduğunu görebiliriz. Sayaç değişkenimizi burada oluştururken dikkat etmemiz gereken başındaki tip ifadesini (genelde int kullanılır) unutmamamız gerektiği. İkinci bölümde yazdığımız koşul, while döngüsündeki koşul parantezinde olduğu gibi döngünün hangi koşulda devam edeceğini belirliyor. Son bölümde ise artırım değerimizi yazıyoruz. Burada yine sayac++ gibi bir ifade yazarak koşuldaki değere birer birer ulaşmaya çalışacağımızı belirtiriz. Ancak sayac+=2 gibi farklı ifadelerle değeri artırmak veya azaltmak mümkündür. Döngüye dair bütün işlemleri bu parantez içerisinde hallettikten sonra süslü parantezler ile oluşturacağımız kod bloğunda yapmak istediğimz işlemi yazabiliriz.

Sonsuz Döngü

Buraya kadar döngülerin belirli bir koşul doğru olduğu sürece kod bloğunu tekrar çalıştırdığını gördük. Peki ya bu koşul hiçbir zaman yanlış çıkmazsa? İşte böyle durumlarda program kodlarında ilerlemek mümkün olmaz ve programımız olduğu yerde takılı kalır. Programın ilerlememesinin ötesinde, sürekli yeni bellek kullandığınız bir döngüde böyle bir durum gerçekleşirse bu programın belirli bir süre çalıştıktan sonra yanıt vermemesine hatta bilgisayarda çalışan diğer programları yavaşlatmasına kadar giden kötü sonuçlar doğurabilir. Yinede sonsuz ya da kısır döngü denilen bu tür döngüleri bir hata olarak nitelendiremeyiz, bu döngülerin kullanıcı arabirimleri ve ağ uygulamaları gibi birçok alanda işlevsel kullanımları bulunmaktadır.

Döngüyü oluşrurken yapacağımız bir hata sonsuz döngüye sebep olabilir..

Ancak şu aşamada arka planda çalışmayan bir sonsuz döngü hazırladığımız uygulamaların takılmasına neden olacaktır ve çalışma zamanında ortaya çıktığı için Visual Studio tarafından uyarılmamız da söz konusu değil. Sonsuz döngülerin önüne geçebilmek için yazdığımız döngülerin koşul alanlarına oldukça dikkat etmeli, gerekirse sonsuz döngüye yol açabilecek farklı durumlar için ve (&&), veya (||) gibi bağlaçlardan yararlanarak koşulu genişletmeliyiz. Ayrıca bir sayaç değişkeni kullanarak hazırladığımız sayısal döngülerde, sayaç değişkenine başlangıç değerini yanlış atamak veya kod bloğunun sonunda bu değeri değiştirmeyi unutmakta uygulamanın sonsuz döngüye girmesine sebep olacaktır.

Dilerseniz sizde dördüncü örneğimizde olduğu gibi bir sayı sayan program yazarak sonsuz döngü kullanabilirsiniz. Burada dikkat etmeniz gereken while(true) ifadesinin sonsuz döngü oluşturmak için kullanılabileceğidir. Son bir hatırlatma yapmak gerekirse, sonsuz döngüye giren bir konsol uygulamasını Ctrl+C tuşlarına basarak kapatabilirsiniz.

Döngülerden Acil Çıkış

Birbirinden farklı birçok kullanım alanı olan döngüleri istersek kendimiz de sonlandırabiliriz. Örneğin bir listede bir elemanı aramak için bütün öğeleri bir döngü ile inceliyorsak, eğer bu elemanı liste bitmeden bulursak listenin kalanında arama işlemine devam etmek sadece zaman kaybı olacaktır. Ya da bir sayının karekökünü sırayla deneme yoluyla arıyorsak, sayıyı bulduğumuzda daha fazla sayı denememize gerek yoktur. İşte böyle durumlarda programın içinde bulunduğu döngüden çıkması için “break” anahtar sözcüğünü kullanabiliriz. Döngüyü sonlandırdığımızda, program döngü kod bloğunun bittiği yerden çalışmasına devam edecektir.

Beşinci örneğin sonuç ekranı.

Beşinci örneğimizi incelersek, döngü koşuluna göre ekrana 100’e kadar sayı değerlerini yazması gerekirken, sayı değişkeni 10’a eşitlenince break komutuyla döngüyü sonlandırdığımız için uygulama sadece 0-10 arası sayıları ekranda gösterecektir.

Döngülerin çalışmasına müdahale eden diğer komutumuz ise Türkçe’de “devam etmek” anlamına gelen “continue”. Break kadar çok kullanılmayan bu anahtar sözcük, döngünün sadece mevcut iterasyonuna son vererek koşul hala doğruysa kod bloğunun baştan çalışmasını sağlar. Altıncı örneğimizde continue kullanarak 0-100 arası tek sayıları ekrana yazdırıyoruz. Kod bloğunun başında mevcut sayının çift sayı olduğunu kontrol ediyor, eğer çiftse iterasyonu continue ile sonlandırarak ekrana yazılmamasını sağlıyoruz.

continue kullanarak hazırladığımız örneğin sonuç ekranı.

Do-While Döngüsü

Son olarak bahsedeceğimiz döngü çeşidi ise Do-While. Bu  döngü biçiminin while döngüsünden tek farkı, ilk işlemi gerçekleştirmek için koşula bakmaması. Yani kod bloğu ilk seferde mutlaka çalıştırılır, ondan sonra yazılan koşul değerlendirilir ve eğer doğruysa kod bloğu tekrar baştan çalıştırılır. Yazılış biçimi ise do {kod} while(koşul) şeklindedir. Son örneğimizdeki uygulamamız ise basit bir şekilde kullanıcının ismini öğrenmek istiyor. Eğer kullanıcı ismini girmeden giriş tuşuna basarsa soru tekrarlanıyor ve kullanıcı isim girene kadar program devam etmiyor. Burada kullanıcıdan veri almak için Console.Readline() komutunu kullanıyoruz. Eğer kullanıcı herhangi bir isim yazmadan giriş tuşuna basarsa, “yazi” ismindeki string değişkenimiz boş bir değere sahip olacağı için, while yanındaki koşul doğru olacak ve program kod bloğunu tekrar çalıştıracaktır.

do-while kullanarak kullanıcıdan isim bilgisini istiyoruz.

Do-while döngüsüne de değindikten sonra C# ile temel programlama konusunda önemli bir aşama kaydetmiş bulunuyoruz. Son olarak, döngü içerisinde elde ettiğiniz değerler ile yeni işlemler gerçekleştirmek için birden fazla döngüyü iç içe kullanabilmenizin mümkün olduğunu da söyleyelim. Özellikle matris uygulamaları gibi birden fazla boyutu olan dizilerle ilgileneceğimiz ileriki yazılarımızda iç içe döngülerin kullanımı konusuna detaylı olarak değineceğiz. Farklı örneklerle anlatmaya çalıştığımız döngülere hakim olmanız programlama konusunda ilerlemeniz için gerçekten çok önemli. Bu yüzden verdiğimiz örnekleri kendi yaratıcılığınızla geliştirerek yeni örnekler oluşturmanızı kesinlikle tavsiye ederim. Bir sonraki yazıda görüşmek üzere :)

p.s. Bu yazı Ekim 2008′de yazılmıştır.

Örnek Kod 1:

//örnek 1

int sayi = 876528;

while (sayi != 0 && sayi != 1)

{

sayi = sayi - 2;

}

if (sayi == 1)

Console.WriteLine("Tek sayı.");

else

Console.WriteLine("Çift sayı.");

Örnek Kod 2:

//örnek 2

int sayac = 0;

while (sayac < 1000)

{

Console.WriteLine("While Döngüsü");

sayac++;

}

Örnek Kod 3:

//örnek 3

for (int sayac = 0; sayac < 1000; sayac++)

{

Console.WriteLine("For Döngüsü");

}

Örnek Kod 4:

//örnek 4

int sayi = 0;

while (true)

{

Console.WriteLine(sayi++);

}

Örnek Kod 5:

//örnek 5

for (int sayi = 0; sayi < 100; sayi++ )

{

Console.WriteLine(sayi);

if (sayi == 10)

break;

}

Örnek Kod 6:

//örnek 6

for (int sayi = 0; sayi < 100; sayi++ )

{

if (sayi % 2 == 0)

continue;

Console.WriteLine(sayi);

}

Örnek Kod 7:

//örnek 7

string yazi;

do

{

Console.WriteLine("İsim: ");

yazi = Console.ReadLine();

}

while (yazi == "");

Console.WriteLine("İsminiz: " + yazi);

Öncelikle şunu söylemek gerekir ki program akışının yön değiştirmesini sağlayan karar ve kontrol mekanizmaları olmasaydı, bilgisayarların pahalı bir metal yığınından farkı kalmazdı. Programların çeşitli koşullara göre farklı işlemler yapabilmesi, insanların gerçek hayatta farklı koşullar altında farklı davranışlar göstermesi gibidir. Gerçekleştireceği bir eylemde birçok seçenek arasından bulunduğu koşula uygun olanını seçerek tamamlamasına neden olur. Örneğin sabah uyandığınızda nasıl kıyafet seçtiğimizi düşünelim. Dolabımızda birçok çeşit kıyafet olabilir, ancak biz dışarıdaki hava durumuna bakıp karar verir, güneşli ve sıcak bir günde kazak ya da yağmurluk yerine ince bir t-shirt giymeyi tercih ederiz. Bilgisayar programları da amacı doğrultusunda değişik koşulları göz önünde bulundurarak çalışmasını sürdürür.

Karar verme mekanizmalarının çalışması, belli bir koşulun mantık değeri olarak doğru veya yanlış olarak değerlendirilmesiyle ilgili kod bloğunun işlenmesine dayanır. Mantıksal ifadelerin koşul içerisinde değerlendirilmesi, önceki yazımızda bahsettiğimiz mantıksal (boolean) değişkenler kullanılarak yapılır. Hatırlatmak gerekirse, doğru (true) veya yanlış (false) olabilen bu ifade türleri, koşullarını durumunu belirlemek için kullanılır. Bir ifadenin doğru veya yanlış olduğu, programcılar tarafından tanımlanan boolean değişkenler ile belirlenebildiği gibi, mantık öğeleri veya ilişkisel operatörler kullanılarak da belirlenebilir.

Mantıksal İfadeler

Belirli koşulların sağlanması için, sonucu doğru ya da yanlış olan ifadeler kullanırız. Bu ifadelerin doğru ya da yanlış olması ilişkisel operatörler ve mantık öğeleri ile belirlenir. İlişkisel operatörler rakam, harf gibi temel değişkenleri veya nesneleri karşılaştırmaya yarayan, karşılaşma sonucunda bir mantık değeri (true veya false) döndüren operatörlerdir. Tablo 1 de (yazının hemen altında) inceleyebileceğiniz bu operatörler, sağda yazılan değeri soldaki ile karşılaştırarak bir sonuç verirler. Bir değerin diğerine göre büyüklüğü veya eşit olması, program kontrollerinde ve ileride değineceğimiz iterasyon (yenileme) kontrolleri içerisinde sürekli kullanacağımız karşılaştırma yapılarıyla belirlenir.

Koşullar içerisinde birden fazla mantıksal ifade kullanmamız gerekebilir. Bu gibi durumlarda “VE operatörü” olan “&&” ile “VEYA operatörü” olan “||” kullanarak mantıksal değerleri bağlayabiliyoruz. Bir şartın gerçekleşebilmesi için bütün mantıksal değerlerin doğru olması gereken durumlarda VE operatörünü kullanarak bu doğruluğu sınayabiliriz. Şartlardan birinin doğru olması koşulun doğru olması için yeterli ise VEYA operatörü kullanarak bu koşulun doğru sonuç vermesini sağlayabiliriz. Ayrıca mantıksal bir değeri (boolean) tam tersine çevirmek için değil (NOT)  operatörü olan ünlem “!” işaretini ifadenin başına yazmamız yeterlidir. Örneğin iki sayı değişkeninin 10 ile 100 arasında olup olmadığını kontrol etmek istiyoruz. Bu durumda aşağıdaki gibi bir ifade kullanarak iki karşılaştırma ifadesiyle istediğimizi gerçekleştirebiliriz:

int sayi = 30;

Boolean sonuc = (sayi > 10) && (sayi < 100);

Buradaki sonuç değişkeni, üst satırda girilen sayı değişkeninin hem 10’dan büyük hem de 100’den küçük olması koşulunun doğruluğunu bir arada arayacaktır. Bizlere boolean değer döndüren son mantıksal öğemiz ise, değişkenlerin türünü kontrol etmemize yarayan “is” anahtar sözcüğü. Diğer anlattığımız mantıksal ifadeler kadar çok kullanmayacağımız bu komut ile, tanımlı olan değişkenlerin hangi nesne türüne veya sınıfına dahil olduğunu anlayabiliriz. Küçük bir örnek vermek gerekirse:

int sayi = 30;
Console.WriteLine(sayi is int);

şeklinde basit bir ifade yazarsak, “sayi” isimli değişken int tipinde olduğu için konsola doğru (True) değerini yazdırdığını görebiliriz.

IF & ELSE Kontrolleri

Buraya kadar program kontrol elemanlarından bahsettikten sonra, sıra geldi bu kontrollerin nasıl yapıldığını görmeye. İngilizcede “eğer” anlamına gelen if kelimesi, birçok programlama dilinde olduğu gibi C# içerisinde de en çok kullanılan kontrol söz dizimi olarak karşımıza çıkıyor. Kullanımı if(koşul) şeklinde olan bu yapı, “eğer” parantez içerisindeki koşul doğru ise önünde bulunduğu kod bloğunu çalıştırıyor. Süslü parantezler ile oluşturduğumuz kod bloğu, eğer koşul sağlanamazsa es geçiliyor ve içerisindeki komut satırları çalıştırılmıyor. Hemen ilk örneğimize bakarsanız (Kod 1) burada tanımladığımız “hava” ismindeki string değişken, if içerisinde ilişkisel operatörler kullanılarak kontrol ediliyor ve eğer değeri koşul içinde belirtilen değere eşit ise altındaki kod bloğunun çalıştırılması sağlanıyor.

Oldukça basit hazırladığımız ilk örneğimizde değişkenimizin değeri koşul içerisinde belirtilen ile aynı olursa ekrana bir satır yazı yazdırıyoruz. (Yazının altında örnek kodları bulabilirsiniz.)

İkinci örneğimize bakacak olursak, birbirini tamamlayan iki if kontrolünün iç içe kullanıldığını görebiliriz. Dışarıdaki if, cinsiyet değişkenini kontrol ederken, içerideki if kontrolleri yaşın 18’in üzerinde olup olmadığını kontrol ediyor. Eğer üzerinde ise ilk if içerisindeki kod bloğu çalışıyor ve askere gitmek için uygun olduğunuz mesajını alıyorsunuz. Yaş değişkeninin 18’in altında olması durumda ise diğer kod bloğu içerisindeki komut satırı çalışıyor. Buradaki sorun, bizim farklı koşullar için farklı if kontrolleri yazarak gereksiz yere işlem yapıyor olmamız. Elinizde yapacak birden çok seçeneğiniz olduğunda, hepsi için bir if kontrolü yazmadan tek bir ifade ile bu koşulları değerlendirmemiz için, Türkçeye “aksi halde” olarak çevirebileceğimiz “else” komutu yardımımıza koşuyor.

Kontrol ifadesinin koşulu olarak verdiğimiz boolean ifade yanlış (false) bir değer döndürdüğünde, yani aradığımız koşul olmadığında else ifadesinin ardından yazdığımız bir kod bloğunun çalıştırılması mümkün Üçüncü örneğimizde bir sayı değişkeninin % operatörüyle 2’ye bölümünden kalan sayıyı buluyoruz ve bu sayıyı 1’e eşitleyerek tek ya da çift sayı olduğunu belirliyoruz. Üstelik iki eylem için tek bir if kontrolü kullanarak işlem zamanını da azaltmış oluyoruz.

Programımızda yapılan işlem sayısını azaltmak için birbiri ile ilişkili koşulları yine else komutu ile birbirine bağlamamız mümkün. Yazılan ilk if bölümünden sonra “eğer böyle değil ise” anlamında “else if(koşul)” yapısında kontrolü bir zincir halinde uzatmamız mümkün. Bu tür zincirlerde gerekli koşul sağlandığında zincirin alt elemanları değerlendirmeye alınmayacağından işlemden tasarruf edebiliyoruz. Lise yıllarımızdaki not sistemini hatırlayabildiğim kadarıyla dördüncü örneğimizde kullanmaya çalıştım. Burada not isimli bir sayı değişkeni ile not baremimizi bulmaya yarayan bir if zinciri oluşturduk. Mantıksal bağlayıcı VE operatörü (&&) ile not aralıklarını belirlediğimiz koşullar çalışacak kod bloğunu belirliyor ve buradaki yazının konsola yazılması sağlanıyor. Eğer not değeri else if ile oluşturduğumuz bloklara giremeyecek kadar düşük ise en sona yazdığımız else ifadesindeki kod çalışıyor.

Kontrollerin işlem sayısını önemli ölçüde azaltan zincirleme koşullar yapısına değinmişken, bu yapıyı daha kolay bir biçimde kullanmamıza imkân veren switch yapısından da bahsedelim. Tek bir değişkeninize bağlı birden fazla koşul olduğu ve bu koşulların hepsinde bir eşitliğin arandığı durumlarda switch kontrolü yazdığınız kodu oldukça kısaltacaktır. Switch(değişken) yapısıyla koşulların bağlı olduğu değişkenin ismini alır ve süslü parantezler arasına değişkenin alabileceği değerler “case DEĞER:” şeklinde yeni bir durum olarak ifade edilir. Farklı değerler için yeni “case”ler oluşturmalı ve çalışacak kod bloğunu bu sefer süslü parantezler kullanmadan “case”lerin altına yazmalısınız. Süslü parantez olmadığı için gereken kodları yazdıktan sonra bitirdiğinizi en sona yazacağınız “break” komutu ile belirtiyoruz.

Switch kullanarak her yeni durum (case) oluşturduğunuzda ilk dikkat etmeniz gereken, yazdığınız değerlerin türleri olacaktır. Tipi int olan bir değeri direkt yazabiliyorken, char tipler için tek tırnak (‘’), string tipindeki değerler için çift tırnak  (“”) kullanmamız gerektiğini unutmamalıyız. Son kod örneğimizi incelerseniz, burada string tipindeki il değerlerinin switch komutuyla eşini bulmasını sağlıyoruz. Öncelikle bahsetmemiz gereken, zincirleme else-if serilerinde verdiğiniz değer hiçbir koşula uymuyorsa geçerli olan koşulu belirlemek için en sona yazdığımız else ifadesi, switch yapısı içerisinde “default” anahtar sözcüğüyle aynen kullanılabiliyor. Kullanımı zorunlu olmayan default komutunu kullanırsanız, verdiğiniz değer mevcut “case”ler içerisinde bulunamazsa çalıştırılacak bölümü belirlemekte. Ayrıca aynı kod bloğuna birden fazla koşulda erişilebilmesi gibi durumlarda, birden fazla case başlığını üst üste yazarak kullanabilirsiniz. Bizde örneğimizde küçük harf ve büyük harf yazılan şehir isimleri de aynı değeri verdiği için bu tür bir yol izledik.

Bütün kontrol yapılarına değindikten sonra artık C# ile kendi kararlarını verebilen işlevsel programlar yazmaya başlayabileceğinizi rahatlıkla söyleyebiliriz. Mevcut örneklerimizi değiştirip geliştirerek ilk etapta denetimlerin nasıl çalıştığı konusunda tecrübe edinmenizi tavsiye ederim. İyi çalışmalar!

p.s. Bu makale Eylül 2008 tarihinde yazılmıştır.

Tablo 1:

Örnek Kod 1:

static void Main(string[] args)

{

string hava = "GÜNEŞLİ";

if (hava == "GÜNEŞLİ")

{

Console.WriteLine("Bugün t-shirt giyeceğim.");

}

}

Örnek Kod 2:

string cinsiyet = "ERKEK";

int yas = 21;

if (cinsiyet == "ERKEK")

{

if (yas >= 18)

{

Console.WriteLine("Askere gitme vaktiniz gelmiş.");

}

if (yas < 18)

{

Console.WriteLine("Askerlik için henüz erken.");

}

}

Örnek Kod 3:

static void Main(string[] args)

{

int sayi = 30;

if (sayi % 2 == 1)

{

Console.WriteLine("Tek Sayı!");

}

else

{

Console.WriteLine("Çift Sayı!");

}

}

Örnek Kod 4:

int not = 71;

if (not <= 100 &amp;&amp; not >= 85)

{

Console.WriteLine("5 Pekiyi");

}

else if (not < 85 &amp;&amp; not >= 70)

{

Console.WriteLine("4 İyi");

}

else if (not < 70 &amp;&amp; not >= 60)

{

Console.WriteLine("3 Orta");

}

else if (not < 60 &amp;&amp; not >= 50)

{

Console.WriteLine("2 Zayıf");

}

else

{

Console.WriteLine("1 Geçmez");

}

Örnek Kod 5:

string il = "İSTANBUL";

switch (il)

{

case "ANKARA":

case "ankara":

Console.WriteLine("Plaka: 06");

break;

case "İSTANBUL":

case "istanbul":

Console.WriteLine("Plaka: 34");

break;

case "İZMİR":

case "izmir":

Console.WriteLine("Plaka: 35");

break;

default:

Console.WriteLine("Hatalı giriş.");

break;

}

Kodlar tam olarak buna benzemeli! :))

Önceki yazımda C# dilinin temelinde yer alan .NET çatısının yapısını incelemiş, 2000’li yıllardan sonraki tarihi süreci sizlere aktarmıştım. Söz dizimi C/C++ dillerine benzeyen C# özellikle bu dillerden birini veya JAVA kullanmış deneyimli programcılar için alışması çok kolay bir dil. Bu sebeple daha önceden farklı dillerde program yazmış okurlarımız söz dizimine alıştıktan sonra .NET çatısının bizlere sunduğu kütüphaneleri kullanarak farklı uygulamalar geliştirmeye kolayca başlayabilirler. Ancak biz yazı dizimizde programlama dünyasına yeni adım atacak okurlarımızı da düşünerek sayfalarımızda programlama dilinin detaylarına da değinmeye çalışacağız.

İlerideki eğitimlerimizde Windows Forms uygulamaları geliştirerek grafik arayüze sahip (GUI – Graphical User Interface) programların C# kullanarak ne kadar kolay hazırlayabileceğimize şahit olacağız. Ancak bu safhaya gelmeden önce temel programlama içeriğini işlerken genelde konsol uygulamaları üzerinden örnekler geliştireceğiz. DOS işletim sistemine aşina okurlarımızı eski zamanlara götürecek bu tür uygulamalar Windows Komut İstemi altında çalışan temel projeler. Eğitimlerimizi takip edenlerin hatırlayacağı gibi, Visual Studio altında yeni proje oluştururken “Console Application”’u seçerek bu türde uygulama hazırlamaya başlayabiliriz. Uygulamamızı derlemeden önce Ctrl+F5 tuşlarına basarak çalıştırabiliyoruz. Geliştirme ortamımızı anlattıktan sonra C# ile program yazmaya hazırız demektir.

İlk yazımızda C#’ın bir süslü parantez ( { } )  dili olduğundan bahsetmiştik. Aslında söylemek istediğimiz bu parantezler arasında kod blokları oluşması, fonksiyon ve kontrollerin içerisindeki kodların yine bu parantezler arasında yer almasıdır. Bu kod blokları arasında gerçekleştireceğimiz bütün eylemlerin sonuna noktalı virgül “;” koyarak komutu tamamlamayı unutmamalıyız. Yazdığımız her program çalışmak için “Main” olarak isimlendirilen ana fonksiyona başvurur. Yeni proje açtığınızda oluşturulan Program.cs dosyası içerisindeki Main fonksiyonu altındaki kod bloğunun sahip olduğu süslü parantezler ( { } ) arasına hazırladığımız örnek kodları yazabilirsiniz. Bunun yanında, derleyici tarafından dikkate alınmayan, sadece not tutmak için kullanılan yorum satırları oluşturmak için tek satırlık // karakterlerini kullanabilir, ya da satır sınırlaması olmayan yorum bölümlerini /* ve */ arasına metin yazarak oluşturabilirisiniz.

DEĞİŞKENLER

Matematik derslerinde denklemler ile hayatımıza giren değişken ifadesi, programlamada en çok kullandığımız yapıların başında geliyor. Belirli bir değeri bilgisayarın belleğinde (Random Access Memory – RAM) tutmak istediğimizde bir değişken tanımlıyor ve yeri geldiğinde tanımladığımız bu değişkenin değerini istediğimiz gibi değiştirebiliyoruz. Mantıksal, sayısal ve karaktersel değerler alan değişkenler için bellekte sabit bir yer ayrılmakta. Ancak bir değişken kullanıldığı yere göre daha az veya fazla bellek alanına ihtiyaç duyabilir. Örneğin bellekte tutulan sayısal değerleri düşünün. İkili sistem ile bellekte tutulan sayı değerleri, sayının büyüklüğüne göre farklı bellek alanı işgal edecektir. Bu durumda bir basamaklı bir sayı için en fazla 5 bitlik bir alan ayrılması yeterliyken, basamak sayısı arttıkça ihtiyaç duyulan bellek miktarı da artmakta. Eğer biz bir değişkende tek basamaklı bir sayı tutacaksak, o sayı için bellekte 32 bitlik bir alan ayırmamız halinde belleği etkin kullanmamış oluruz. Etkin bellek kullanımını sağlamak amacıyla programlama dilleri içerisinde farklı boyutlarda değişken türleri mevcuttur.

Tablo 1’de (yazının sonunda) görebileceğiniz değişken türleri arasında sayı değeri tutan tiplere bakacak olursanız “short” tipi bir değişken 16 bit olup en fazla 5 basamaklı bir sayı tutabilirken, “integer” 10, “long” 19 basamaklı sayılara kadar veri saklayabilir. Bu sayılar negatif değer alabiliyorken, işareti olmayan “unsigned” tipler sadece pozitif değer alabilmekte, böylelikle daha fazla basamaklı sayıları aynı miktarda bellek harcayarak tutabilmektedir (uint, ulong gibi). Sayılar konusunda diğer bir önemli nokta, ondalık değerlere dikkat etmenizin gerekmesi. Ondalık değerleri bellekte tutmak için, boyutları değişen “float” ve “double” tipi değişkenler kullanıyoruz.

Mantıksal değişkenler ise, sadece doğru (True)  ya da yanlış (False) değerini tutabilen 1-bit boyutunda veri tipleridir. Yine ortaöğrenim sırasında mantık derslerinden aşina olduğunuzu düşündüğüm bu yapılar, Boolean değişkenler olarak adlandırılır. Tutulan bu mantıksal değerler, program akışında gidilen yolu değiştiren koşullar içerisinde kullanılır. Diğer dillerden farklı olarak bu değişkenleri tanımlamak için kısaca “bool” yazıyoruz. Ayrıca true ve talse değerlerinin baş harflerinin küçük olması önemli.

İlk örneğimizin kodları

CHAR  vs. STRING

Karakter tutan “char” veri tipi, C/C++ zamanından günümüzü yapısını bozmadan gelmeyi başarmış. Öncelikle sadece ikili tabanda sayı saklayabilen bilgisayar belleklerinin karakterleri nasıl hafızasında tutabildiğinden bahsedelim. Noktalama işaretleri, rakamlar ve harflerden oluşan karakter dizisi elemanları, ASCII kodu adı verilen bir sayıya eşitlenmiştir. Büyük ve küçük harfler için farklı olmak üzere bütün bu elemanların http://en.wikipedia.org/wiki/Ascii_table adresinde inceleyebileceğiniz gibi bir sayı değeri vardır. İşte char veri tipi, programcının kendine atadığı bir karakteri bu sayı değerine eşitleyerek bellekte saklar. Burada programcı olarak sizin yapmanız gereken, kod içerisinde tanımladığınız değişkenin karakter olduğunu belirtmek için onu tek tırnak ( ‘’ ) içerisine almanız.

Ancak tek karakterin bellekte saklanması her zaman sizin için yeterli değildir. Bir kelime ya da cümleyi değişken içerisinde saklamak istediğinizde eski programlama dillerinde karakter dizileri oluşturmanız gerekmekteydi. Ancak C# gibi yeni nesil programlama dillerinde bu işi string adı verilen ikincil değişken tipleri kendiliğinden yapıyorlar. Böylelikle belirli bir metni tırnak işaretleri (“”) arasına yazarak değişken içerisinde saklayabiliyorsunuz. Aklınıza bu metin içerisinde tırnak işareti kullanmak geldiyse, onun için kaçış işlemi uygulamanız gerekmekte. String değişkenlerine özgü bu işlemde kullanmanız sakıncalı olan karakterlerin başına “\” işareti koyarak metnin içerisinde bulunmasını sağlayabilirsiniz. Mevcut kaçış işlemlerinin yapılabildiği karakterler: ‘ (tek tırnak), “(çirt tırnak), \(ters eğik çizgi), n (yeni satır), t (sekme). Aslında birçok char değişkeninin birleşiminden oluşan string, değişken gibi kullanılsa da bir veri yapısından ibarettir. Bu yüzden string değişkenlerinin bellekte kaplayacağı sabit bir boyut bulunmaz.

İlk programımızı çalıştırdık.

OPERATOR KULLANIMI

Farklı değişken tiplerini anlattıktan sonra, bu değişkenleri kod içerisinde nasıl kullanacağımızdan bahsetmemiz gerek. Tablo 2 içerisinde gördüğünüz programımızda farklı değişken tipleri tanımladık ve bu değişkenleri  Console.WriteLine() fonksiyonunu kullanarak konsolda yazdırıyoruz. Bu programı incelersek, önce kullanacağımız değişkenin tipini yazıyor, sonra ona bir isim veriyoruz.  Bu andan itibaren program kodunun içerisinde bu ismi kullanarak değişkeni çağırmamız mümkün. Değişkenlere değer atamak için eşittir “=” karakterini kullanıyoruz. Bir değişkene değerini onu tanımladığınız satırda ya da farklı bir satır içerisinde atayabilirsiniz, istediğiniz yerde değiştirebilirsiniz.

Eğer tipleri aynı ise, bir değişkenin değerini başka bir değişkene atamanız mümkün.  Ancak sayısal değişkenlerde işler biraz karışıyor;  bellekte kapladığı alandan daha büyük boyuta sahip olanların atamasına izin verilmiyor. Yani bir int değerini long’a atayabilirsiniz, ancak bunun tersi mümkün değil. Bu atamalar sırasında aritmetik işlemler yapmaya ihtiyaç duyduğunuzda C# operatörleri yardımınıza yetişecektir. Tablo 3 içerisinde görebileceğiniz örneğimizdeki gibi kullanabileceğiniz toplama (+), çıkarma (-), çarpma (*), bölme (/) ve mod (%) operatörleri ile değişkenleri ve rakamları sayısal işlemlere tabi tutabilirsiniz. Bunun dışında + operatörünü string ifadeleri birleştirmek için de kullanabiliyorsunuz. Aritmetik işlemler arasında bir sıra olması gerektiğinde işlem içinde parantezler kullanabiliriniz. Matematik kurallarından bildiğimiz gibi, parantez olmadığı zaman önce / ve * operatörleri, daha sonra + ve – operatörleri işletilir.

Bu örneğimizde değer ataması yaparken operatörleri kullanıyoruz.

İSİMLENDİRME SANATI

Değişkenlere vereceğiniz isim konusunda özgür olmakla beraber, kod uzadıkça kafanızın karışmaması ya da yıllar sonra koda baktığınızda neler olup bittiğini anlayabilmeniz için anlaşılır isimler seçmenizi tavsiye ederim. Özellikle başka insanların da yazılan kodu çözebilmesi için yorumlara önem vermek, fonksiyon ve değişken isimlerini anlaşılır yapmak oldukça önemlidir. Bu konuda her programcının kendine özgü bir stili olsa da, kelimelerin baş harfini büyük yapmak (ör: int piSayisi; ) ya da alt çizgi kullanmak (pi_sayisi) gibi bir yöntem benimsemeniz iyi olacaktır. Bunların dışında Türkçe karakter kullanmaktan ve rakam ile başlayan değişken isimlerinden kaçının.

Hazır değişken tiplerini anlatmışken, C# 3.0 sürümü ile birlikte gelen bir yenilikten bahsetmeden geçmeyelim. Yeni sürüm beraberinde tip ayrımı gözetmeyen ortak bir değişken getiriyor. Tablo 4’te ki örnekte görebileceğiniz üzere “var” anahtar sözcüğü ile tanımlanan değişkenler, atanan ilk değerin tipine dönüşerek program içerisinde kullanılıyorlar. Özellikle farklı tipte verilerin gelebildiği veritabanı uygulamaları için kullanışlı bir özellik olduğunu söyleyebiliriz. Değişken ve operatörlere ait eğitimimizi burada bitirirken, yaptığımız örnekleri deneyip değişik varyasyonlar deneyerek çalışmanızı tavsiye ederim.

Ortak veri tipi ile değişkenlerinizin tipi ilk değer atamasında belirlenir.

Tablo 1:

Tablo 2:

static void Main(string[] args)

{

//Tek satır yorum

/* Çoklu satır yorum */

int sayi1;

sayi1 = 1;

int sayi2 = 10;

Console.WriteLine(sayi1);

Console.WriteLine(sayi2);

double sayi3 = 10.5;

double sayi4 = sayi3;

Console.WriteLine(sayi3);

Console.WriteLine(sayi4);

bool b = true;

Console.WriteLine(b);

string isim1;

isim1 = "Merhaba, ";

string isim2 = "PC Magazine";

Console.WriteLine(isim1);

Console.WriteLine(isim2);

isim2 = "yigit";

Console.WriteLine("yeni isim: " + isim2);

}

Tablo 3:

static void Main(string[] args)

{

int a = 5;

int b = 10;

int c = ((a * 2 - 2) - 1) + ((b * 3) % 5) / 3 ;

Console.WriteLine(c);

string s1 = "PC Magazine.";

string s2 = "Merhaba, ";

string s3 = s2 + s1;

Console.WriteLine(s3);

Console.WriteLine("Yigit\n\n\nKiran");

}

Tablo 4:

static void Main(string[] args)

{

var metin = "Merhaba, PC Magazine";

var sayi = 4;

var ondalikSayi = 4.5;

var boolean = true;

Console.WriteLine(metin);

Console.WriteLine(sayi);

Console.WriteLine(ondalikSayi);

Console.WriteLine(boolean);

}

p.s. Bu yazı Ağustos 2008 PC Magazine dergisindeki makalemden derlenmiştir.

Bill Gates, yaklaşık 20 yıl önce vizyonunu açıkladığında sektörün içinden ve dışından birçok insanın tepkisiyle karşılaşmıştı. Her eve bir bilgisayar gireceği ve kişisel bilgisayarların insan hayatında çok önemli bir yere sahip olacağını söyleyen bu genç girişimcinin sözleri, laptop bilgisayarların yaklaşık 1.5 ton civarı olduğu o yıllarda (!) fazla gerçekçi durmuyordu. Ancak geçen zaman, özellikle 90’lı yıllarda kişisel bilgisayarların atağa geçmesi, bu vizyonun ne kadar gerçekçi olduğunu ortaya koydu. Microsoft’un Windows işletim sistemleriyle katkıda bulunduğu bu vizyon, 2000’li yıllara gelindiğinde artık her evde birden fazla bilgisayar görülmeye başlanınca miyadını doldurmuş oldu. Kişisel bilgisayarların yayılması internetin kullanımını da arttırırken bilgi çağının başlangıcına da öncülük ettiler. Yeni milenyuma girdiğimizde artık internet hayatımızın bir parçası haline geldi ve bu gelişmeler esnasında, 2002 yılında gerçekleştirilen Microsoft’un lansmanında artık başarısını kanıtlayarak genç girişimci yıllarını geride bırakmış Gates kendisinin ve firmasının yeni vizyonunu açıkladı: Her zaman, her yerden, her cihazdan bilgiye ulaşmak! Kişisel bilgisayarların yayılmasında Windows işletim sistemleri büyük pay sahibi olarak karşımıza çıkarken, lansmanda bu yeni vizyonu gerçekleştirmek için daha dinamik bir altyapı bizleri karşılıyordu: “.NET”.

Bu yeni vizyon, beraberinde yepyeni bir programlama dilini birlikte getirdi. Okunuşunun kolay olmadığını kabul ediyorum, ancak C# (C Sharp: §İ – ∫a¦rp)  adını duyurduktan kısa bir süre sonra dünyada en çok kullanılan diller arasına girmeyi başardı. En köklü programlama dillerinden C/C++ yada Java gibi “süslü parantez” dilleri ailesinden gelen söz dizimi (syntax), nesne & bileşen tabanlı yapısı ve Visual Studio gibi başarılı bir geliştirme ortamında yazılması kolay öğrenilmesine neden oldu. Ayrıca ASP.NET ile web tabanlı uygulama geliştirmek için de kullanılması kolayca yayılmasını sağladı. Geliştirme ekibinin başında bulunan Anders Hejlsberg, zamanında Turbo Pascal gibi devrim yaratmış bir IDE’nin geliştiricisi ve Borland firmasında programlama dilleri üzerine uzun yıllar çalışmış biri olarak 1999 yılında çalışmalarına başladığı C#’ı birçok dilin avantajlarına sahip kapsamlı bir dil olarak geliştirdi. Günümüzde Java ve PHP ile kullanımı yükselen 3 dil arasında bulunan C# aslında bu dillerin en yenisi. Ülkemizdeki bilgisayar sektöründe de geniş kullanım alanı bulunan bu dili blogdaki yazılardan takip ederek, en başından başlayıp öğrenebilirsiniz! Eğitimimizde temel programcılık mantığını anlatırken bol bol örnek uygulamalar yapıp kendinizi geliştirmenize yardımcı olmayı amaçlıyoruz.

.NET yeni logosu

Danimarkalı mühendis Anders Hejlsberg C# geliştirme ekibinin başında

Bu ayki konumuz, programcılığa başlmadan önce biraz ısınmak; C# uygulamalarını üzerinde geliştireceğimiz .NET Framework’ün yapısını ve amaçlarını sizlere aktarmak. Bütün programlarımızın temelinde yer alacak bu altyapının çalışma tarzı diğer dillerin çalışma biçiminden farklı olduğu için basit mantığını anlamak gerçekten önemli. Yukarıda .NET’i dinamik bir altyapı olarak nitelendirmemizin başlıca nedeni, birden çok platformda çalışarak bu platformları birbirine bağlayacak olan bir çatı’ya (framework) sahip olması. Katmanlı yapıda olan bu çatı, çeşitli ihtiyaçlara cevap vermek üzere hazırlanmış birçok hizmeti içeren sınıf kütüphanelerini programcıların hizmetine sunarak, eskiden çok uzun zaman alan birçok işlevin yönetilebilir (managed) kodlar sayesinde kolayca uygulama içerisinde kullanılmasına imkan veriyor. C# eğitimlerinde sık sık kullanacağımız bu kütüphanelerin detaylarına girmeden önce .NET Framework felsefesini ve çalışma şeklini inceleyelim.

.NET Framework’ün Yetenekleri

Bilgiye her yerden ulaşabilmek için .NET Framework, uygulamalarının platform bağımsız çalışmasını amaçlar. Yazdığınız uygulama Windows, Linux gibi farklı işletim sistemleri altında bir değişiklik yapmanıza gerek kalmadan çalışabildiği gibi, PDA, Smartphone, XBOX yada akıllı ev araçları (embedded donanımlar) gibi farklı istemciler ile kolayca iletişim kurabilmeli ve belirli bir çözümün içerisinde yer alabilmelidirler. Hazır gelen sınıflar arasında bulunan temel kütüphanelerin yanı sıra, güvenlik, ağ, veritabanı erişimi gibi özelleşmiş alanlardaki kütüphaneler bizlere uygulama geliştirmek için önemli zaman tasarrufu sağlar. Örneğin bir XML dökümanını okumak için temel sınıf kütüphanesinden ilgili sınıfı çağırıp, birkaç satır kod yazarak istediğimiz işlevi yerine getirebiliriz. Bu şekilde hazır kod kullanımı, ilk zamanlarda herşeyi kendi elleriyle yazmayı seven eski programcılar tarafından yadırgansada, karmaşık uygulamaların yükünü hafifleterek daha büyük uygulamalar geliştirmek için bizlere büyük bir fırsat sunuyor.

Temel Sınıf Kütüphanesinin içeriği

.NET Framework’ün ilk versiyonundan itibaren hayatımıza giren C#, bu yeni altyapıyı en rahat biçimde kullanabilmek için tasarlandı, ancak .NET üzerinde uygulama geliştirmenin tek yolu değil! Sevdiği programlama dilinden vazgeçmek istemeyen programcılar için VB, C++, Delphi, Java gibi tanıdık dillerden ADA, Eiffel, Scheme gibi farklı 40’tan fazla dil destekleniyor (desteklenen dillerin listesine buradan ulaşabilirsiniz: http://en.wikipedia.org/wiki/CLI_Languages). Bütün bu diller, ortak aradile çevrilerek bir sanal çalışma zamanı uygulaması tarafından işlenerek çalıştırılıyorlar.

Farklı platformlar üzerinde çalışan CLR (Common Language Runtime) uygulaması, farklı dillerden çevrilmiş ortak aradili (CIL) Just-In-Time compiler adı verilen eşzamanlı derleyici ile bulunduğu platformun diline çevirir. Bu sayede aynı kodun farklı platformlar üzerinde çalışması sağlanırken, farklı dillerin kullanımına imkan tanınıyor. Bunun yanında çalışan kodun güvenliği, bellek yönetimi, hata denetimi, uyumluluk ve birlikte çalıştırılabilmesi gibi zorlu görevler CLR tarafından denetlenerek uygulamanın stabil çalışması, performansı ve güvenliği üst seviyede tutuluyor. Üstelik önceden yazılımcının sorumluluğunda bulunan bu işlevler artık otomatik olarak kontrol edilerek zamandan tasarruf ediliyor ve hatalar en aza indirgeniyor.

Platform bağımlı sistemlerden kodlar derlendikten sonra ortaya yürütülebilir bir dosya (.exe uzantılı) çıkmasını ve işletim sisteminin direk bu dosyayı çalıştırabilmesine alışığız. Ancak çalışma prensibini yukarıda anlattığımız .NET Framework CLR servisi, bir sanal makine gibi çalışarak, .NET uygulamaları ve işletim sistemi arasında iletişimi sağlıyor. Uygulamalar bu sanal makinede derlenerek bulunduğu platformun anlayacağı kodlara çevriliyorlar. Aslında .NET üzerinde geliştirdiğimiz programları yayınladıktan sonras yine .exe uzantılı bir dosya elde ediyoruz, fakat bu diğer yürütülebilir dosyalar gibi makine dili içermiyor. Assembly olarak adlandırılan bu dosya türleri, ortak dile çevrilmiş kod, doğrulama, güvenlik, referans ve yansıma bilgilerini içinde bulunduran özel bir yapıya sahiptir. Bu yüzden programlar çalışmak için .NET Framework’ün bilgisayarda yüklü olmasına ihtiyaç duyuyorlar (indirmek için: http://msdn.microsoft.com/en-us/netframework/aa569263.aspx).

C# ile farklı platformlara yazılım geliştirmek mümkün.

.NET Çalışma Ortamı

Farklı diller için hazırlanmış birçok ortamda uygulama geliştirmek mümkün olsa da, MS Visual Studio kullanarak C#, VB.NET, C++ ile windows forms, konsol, mobil uygulamalar geliştirebilir, ASP.NET web siteleri, web servisleri gibi bir çok değişik projede çalışabilirsiniz. Bütün bu uygulamaları ve daha fazlasını bünyesinde barındıran Visual Studio ücretli bir uygulama olsa da, özelleşmiş Express versiyonları tamamen ücretsiz. Biz eğitimimizde C# ile çalışacağımız için VS 2008 C# Express Edition’u (http://www.microsoft.com/express/vcsharp/) kullanacağız. Veritabanı ve web servisleriyle çalışabilme desteği olan, IntelliSense adı verilen otomatik kod tamamlayıcı yardımcıları bünyesinde bulunduran bu program eğitimimiz boyunca yoldaşımız olacak J.

.NET Framework sürümlerinin içerikleri

Kabul etmek gerekir ki, .NET Framework’ün 2002 yılında çıkan ilk versiyonunda herşey bu kadar parlak değildi. Altyapıda bulunan hatalar ve performans problemleri, uygulamaların temelini zayıflattığı için birçok soruna neden oluyordu. Ancak Microsoft çalışanları bir yıl boyunca özverili bir çalışma gösterip birçok açığı kapattı ve stabil 1.1 sürümünü yayınladılar. Daha sonra 2005 yılında 2.0 sürümü hatalarından iyice arınmış, generics, 64 bit uyumluluğu, ADO.NET 2.0, ASP.NET 2.0 gibi yeniliklerle karşımıza çıktı. Windows Vista ile birlikte gelen 3.0 versiyonunda ayrıntılarına ileride değineceğimiz WPF, WCF, WF gibi iletişim, görsellik, iş akışları ve erişim üzerine eklentiler dahil edilirken; geçtiğimiz aylarda çıkan en son 3.5 sürümü LINQ ve AJAX desteği ile yayınlandı. Özellikle 3.0 sürümünden sonra eski versiyonlarla geri uyumluluk tamamen sağlanırken, Windows 98, 2000 ve ME işletim sistemlerine verilen desteğe son verildi.

Visual Studio 2008 C# Express açılış ekranı

Merhaba Dünya!

Ne yazık ki uygulama geliştirme araçlarının Türkçe desteği bulunmaması, bazı okurlarımızın sorunlarını çözebilmek için daha çok çaba sarfetmesini gerektiriyor. Kullanacağımız Visual Studio 2008 C# Express Edition’un kurulum aşamasında size MSDN Express ve SQL Server Express programlarını kurmanızın da faydalı olabileceği hatırlatılıyor. Microsoft Geliştiriciler Ağı (MSDN) dökümanları,  C# hakkında birçok makaleye ulaşabilmeniz ve karşılaştığınız sorunlara cevap bulabilmeniz açısından önemli fakat maalesef Türkçe içeriği bulunmuyor. Microsoft’un ücretsiz veritabanı uygulaması olan SQL Server Express’i önümüzdeki aylarda değineceğimiz konular için yüklemenizi tavsiye ederim.

C# Express ile oluşturabileceğiniz proje çeşitleri

Yükleme işlemini tamamlayıp geliştirme ortamını açtığınızda, güncel MSDN haberlerinin yer aldığı başlangıç ekranıyla karşılaşacaksınız. Proje oluşturmak için File>New Project seçeneğini işaretleyin. Açılacak diyalogdaki seçeneklerden “Console Application”, komut sisteminde çalışan konsol uygulamaları için kullanacağımız seçenek. Programcılık mantığına değineceğimiz eğitimlerde bu tarz projeler hazırlayacağız. “Windows Forms Application” ise windows arayüzünü kullanarak pencereler tasarlayacağımız form uygulamaları yapmamızı sağlıyor. Yeni Visual Studio serisinin  arayüz tasarlama konusundaki en başarılı programlardan biri olduğunu belirtmeliyim. Yeni proje oluşturduktan sonra ilgili dosyalar Belgelerim>Visual Studio 2008>Projects altında projenizin ismine ait klasörün içinde saklanmakta ve Express versiyonlarda bunu değiştiremiyoruz. Uygulamanın sağ tarafındaki “Solution Explorer” bölmesi programın sahip olduğu dosya ve klasörleri yönetmek için kullanacağımız alan. Son olarak proje yarattıktan sonra, üst kısımda bulunan yeşil “Run” butonuyla yazdığınız programı çalıştırabildiğinizi hatırlatalım. Bu ay anlatacaklarımızın sonuna geldik ama ilk programımızı yazmadan Visual Studio’yu kapatamayız. O zaman hemen bir konsol  uygulaması yarattıktan sonra ortadaki süslü parantezler “{}” arasına aşağıdaki kodu yazıp “Run” butonuna basarak ilk programımızı tamamlayabiliriz.

İlk C# Programımız:

Console.WriteLine("Merhaba C#!");

update: Haziran 2008 tarihinde yazdıgım bu yazıdan sonra çıkan VS 2010 sürümünü yüklemenizi tavsiye ederim.