Değişkenlere Başlangıç Değeri Verme

Bir değişkene değer vermek için atama operatörü kullanılır. Atama operatörü C#’da ‘=‘ dir. Öyleyse yeni tanımlanmış bir değişkene başlangıç değeri aşağıdaki gibi verilebilir:

int sayac;
sayac = 1;

Değişkenin başlangıç değeri aynı zamanda değişken tanımlandığı anda da verilebilir:

int sayac = 1;
string isim = "Keskin C";

Eğer aynı satırda birden fazla değişken tanımlanıp başlangıç değerleri de verilmek istenirse aşağıdaki yol takip edilmelidir:

double basariOrani = 88.8, katilimYuzdesi = 52.4;

Değişken Kapsama Alanı (Variable Scope)

Öncelike şu ayrımı yapmak gerekir. Bir metot içerisinde tanımlanmış (Örneğin Main() metodu) değişken lokal değişken (local variable) adını alırken; bir sınıfın ya da bir yapının üyesi olarak tanımlanan değişken alan (field) adını alır. Şu ana kadar ki bütün örnekler Main() metodu içerisinde test edildiği için kullanılan değişkenler lokal değişkenlerdir. Ayrıca daha sonra görülecek döngü ve kontrol deyimleri, özellik
(property),indeksleyici (indexer) gibi sınıf ya da yapı üyelerinin içerisinde tanımlanan değişkenler de lokal değişkenlerdir. Lokal değişkenlerin tanımlanmaları ile birlikte belleğin stack bölgesine yerleştiğini artık biliyoruz. Peki, bu değişkenler ne kadar süre orada kalıyorlar. Acaba uygulama kapanana kadar mı? Yoksa bizim ihtiyacımız kalmayıncaya kadar mı? Aslında ikisi de değil.

Lokal değişkenler, tanımlandıkları süslü parantezler arasında erişilebilirdirler. Evet, kulağa ilginç geliyor ama tam açıklaması böyle. Bu değişkenler tanımlandıkları bloğa özeldirler ve programda kontrol, bu bloğun sonuna geldiğinde blok içerisinde belleğe çıkarılmış olan bütün lokal değişkenler otomatik olarak bellekten düşer. Özetlemek gerekirse lokal değişkenler sadece tanımlandıkları blok içerisinde kullanılabilirler.

Blok içinde kullanım

...
{
int a = 5; //a değişkeni bellekte yerini alır.
} // a değişkeni, bellekten düşer.
Console.WriteLine(a); //Dizayn-zamanı hatası !!!
...

Yukarıdaki kod bloğunda a değişkeni tanımlanıp başlangıç değeri verilir ve blok sonuna kadar kullanılır. Tanımlandığı blok sonunda ise bellekten otomatik olarak düşer; sonrasında a değişkeni kapsama alanı dışında kaldığı için, kullanılmaya çalışıldığında henüz dizayn zamanında buna izin verilmez. Burada yalnız başına kullanılan blok, anlamsız gibi gözükse de aslında lokal değişkenlerin, içinde kullanılabileceği metot ya da daha sonra öğrenilecek deyimler ve diğer üyeleri temsil
etmektedir.

...
{
int b; //b değişkeni belleğe çıkar.
b = 23;
} //b değişkeni bellekten düşer.
{
int b; //b adında bir değişken belleğe yeniden çıkarılır.
b = 1;
} //Yeni b değişkeni bellekten düşer.
...

Yukarıdaki kod bloğunda yapılanlar tamamen legaldir. Burada birbirinden bağımsız iki tane blok yer almaktadır. İlk blok içerisinde bellekte 4 byte’lık bir yer ayrılır ve buraya 23 değeri atılarak blok içerisinde kullanılır. Blok sonuna gelinince bellekteki 4 byte’lık alan tamamen silinir; dolayısıyla hem bellek içerisinde saklanan değer hem de bellek alanına erişmek için verilen isim (değişken adı b) yok edilmiş olur. Artık
uygulamanın ilerleyen satırlarında yer alacak yeni bir kod bloğunda ‘b’ değişken isminin kullanılmaması için herhangi bir sebep yoktur.

…
{
int b;
b = 23;
{
int b; //Derleme-zamanı hatası.
}
}
…
Bu blokta önce ‘b’ isimli değişken bellekte yerini alır ve başlangıç değeri verilir. Ardından b değişkeninin kapsama alanında bulunduğu bloğun içerisinde yeni bir blok açılır ve burada belleğe yeniden ‘b’ adında bir değişken çıkarılmaya çalışılır. Ancak bellek bölgesinde aynı anda aynı isimli iki değişkenin yer almasına izin verilmez; çünkü değişken değerlerine erişim, bellek bölgelerine verilen değişken isimleri ile
sağlanır ve eğer aynı isimli birden fazla değişkene izin verilseydi işler karışırdı. Dolayısıyla yeni bir değişken ihtiyacı varsa ‘b’ değil de farklı isimde bir değişken adıyla bu sağlanabilir:

...
{
int b;
b = 23;
{
int c; //Sorun yok.
c = 23;
}
}
...

İçerdeki blokta b değişkeni hala erişilebilir olduğu için aynı isimli bir değişken tanımlanamamasına rağmen bu blokta ‘b’ değişkeninden faydalanılabilir:

...
{
int b;
b = 23;
{

Console.WriteLine(b); //Geçerli bir kullanım.
}
}
...

Şimdi de değişken kapsama alanı kombinasyonları için son örneği inceleyelim:

...
{
{
int b;
b = 23;
}
int b = 42; //Derleme zamanı hatası !!!
}
...

 
Burada içerdeki blokta tanımlanan ‘b’ değişkeni aynı zamanda dışardaki bloğun da kapsama alanındadır. O yüzden içerdeki bloğun sonuna gelindiğinde ‘b’ hala bellektedir; dolayısıyla aynı isimli değişken oluşturulmasına izin verilmeyeceği için derleme zamanında bununla ilgili hata alınır. Ayrıca beklenilenin aksine içerdeki bloktan çıkıp ‘b’ kullanılmak istendiğinde de kullanılamayacaktır.

degısken-csharp-visual-studi

İçerdeki blokta tanımlan bir değişkene blok sonunda, dışarıdaki bloğun kapsama alanı dahilinde olsa da erişilemez. ‘b’ değişkeni yukarıda görüldüğü gibi içerdeki blokta kullanılıp bloğun dışarısında erişilmeye çalışıldığı zaman erişilemez; bunun sebebi ‘b’ aslında halen bellekte olmasına rağmen tanımlandığı içsel bloğun dışında
erişilip yönetilememesidir.(debug edilerek bu görülebilir –‘b’ değişkeninin ilk tanımlandığı satıra bir kesme işareti <breakpoint> koyup uygulama F5 ile çalıştırılır ve ardından F11 ile satır satır ilerlenerek Locals penceresinden <Menülerden Debug->Windows->Locals ile açılabilir> – değişkenin durumu daha sağlıklı bir
şekilde gözlemlenebilir. Ya da kesme işareti koymak yerine uygulama doğrudan F11 ile başlatılarak da aynı işlemler yapılabilir)

Console.WriteLine(b); //Geçerli bir kullanım.
}
}
…
Şimdi de değişken kapsama alanı kombinasyonları için son örneği inceleyelim:
…
{
{
int b;
b = 23;
}
int b = 42; //Derleme zamanı hatası !!!
}
…
Burada içerdeki blokta tanımlanan ‘b’ değişkeni aynı zamanda dışardaki bloğun da kapsama
alanındadır. O yüzden içerdeki bloğun sonuna gelindiğinde ‘b’ hala bellektedir; dolayısıyla aynı isimli değişken
oluşturulmasına izin verilmeyeceği için derleme zamanında bununla ilgili hata alınır.
Ayrıca beklenilenin aksine içerdeki bloktan çıkıp ‘b’ kullanılmak istendiğinde de kullanılamayacaktır.

Veri Tipi (Data Types)

Veri tipi, bir değişken için bellekte ayrılacak bölgenin hangi içerikteki ve formattaki verileri saklayacağını bildirmek için kullanılır. Örneğin bir kitabın sayfa sayısı, uygulamanın ilerleyen aşamalarında kullanmak amacıyla saklanmak istenirse tanımlanacak değişken için bellekte ayrılacak alana sadece sayısal verilerin girebileceğini belirtmek gerekir. Bu alanın sayısal veriler için ayrılmasına ek olarak, tam sayı mı ondalık sayı mı olacağı, sayısal aralıkları gibi kriterleri belirtilerek sınırları daha da kesinleştirilmelidir. Kitabın adı için ayrılacak bellek alanı metin tabanlı veriler için olacaktır. Bu yolla kitabın sayfa sayısı için bellekte açılan alana ondalık sayı ya da text tabanlı bir değer girilmesinin; kitabın adı için ise sayısal bir değer girilmesinin önüne geçilmiş olup değerin istenilen içerik ve formatta tutulacağı garanti edilmiş olur. İşte bunları garanti eden kavram veri tipidir.

Temel Veri Tipleri

Şimdi de değişkenler için belirlenebilecek veri tipi çeşitlerini inceleyelim: .NET dünyasında 5 ana tip olduğundan bahsedilmişti. Bunlar tekrar sayılacak olursa;
-> Sınıf (class)
-> Yapı (struct)
-> Numaralandırıcı (enumaration)
-> Arayüz (interface)
-> Temsilci (delegate)
olduğu görülür. Bir değişken tanımlarken belirtilmesi gereken veri tipi, bu 5 ana tipten birinde oluşturulmuş olur. Yanlış anlaşılmasın; sayılan bu 5 ana tipte değişken oluşturulmaz; bu ana tiplerde oluşturulan veri tipleri kullanılır. Örnek vermek gerekirse C#’da tam sayı olarak veri saklamak istendiğinde veri tipi olarak,
bir çok programlama dilinde var olan int kullanılabilir. int, .NET Framework’u tarafından uygulama geliştiricilerin temel programlama görevlerinde kullanmaları için önceden oluşturulan bir veri tipidir. Bellekte kaplayacağı alan bellidir: 4 byte (32 bit). Özelliği, tam sayı datalarını saklayabilmesi ve bunu yaklaşık olarak -2 milyar,+2 milyar aralığındaki sayılar için yapabilmesidir. Ayrıca int, bir yapıdır (struct). int tipinde oluşturulacak bir değişkenin alabileceği minimum, maksimum değerleri ve daha sonra görülecek tip dönüşümlerde kullanılan üyeleri int’in bir struct olmasının getirileridir. Önceden tanımlı veri tiplerine bir başka örnek olarak metin tabanlı verilerin saklanabileceği “string” verilebilir. İstenilen uzunlukta karakterlerden oluşan bu veri tipinin taşıyabileceği veri uzunluğu sınırsızdır. (Ya da uygulama belleğiyle sınırlıdır) Bütün dillerin alfabelerindeki karakterleri, rakamları, matematiksel işlemlerde kullanılan simgeleri metin olarak karakter dizisi şeklinde veri saklayabilen bu tipin bellekte ne kadar yer kaplayacağı int veri tipi gibi önceden belli değildir; çalışma zamanında belli olur. String ile ilgili verilebilecek son bilgi de bir sınıf (class) olduğudur. Yine birçok programlama dilinde herhangi bir formda yer alan mantıksal veri tipi C#’da bool olarak yer almaktadır. Taşıyabileceği değerler iki tanedir: “True” ve “False”. Ondalıklı sayıları saklamak için double veri tipi, tek bir karakter tutmak için char veri tipi vardır. Bir de bütün tiplerin babası sayılabilecek object tipi vardır ki taşıyabileceği değerlerde sınır yoktur; bütün tiplerin taşıyabileceği değerleri üzerinde tutabilir. Örneğin object tipinden oluşturulmuş bir değişken 5 (sayısal tip), “bilgisayar” (string tip), ‘s’ (char tipi), ahmet isminde Personel tipinde kullanıcı tanımlı vb. değişken değerleri taşıyabilir. Object tipini daha çok duyacağınıza emin olabilirsiniz.

Değişken Tanımlama

Değişken tanımlamak için takip edilmesi gereken sözdiziminin;
veriTipi degiskenAdi; olduğunu görmüştük. Bunu C# veri tipleriyle örneklemek gerekirse;

int sayac;

ya da

string adres;

Değişken tanımlamaları ile ilgili örnekleri test ederken Main() metodu içerisinde yazıldığı varsayılır. Değişken tanımlaması bir satırda tek bir değişken için yapılabilirken, aynı tip için olmak kaydıyla birden fazla değişken için de yapılabilir.

double basariOrani, katilimYuzdesi;

C#’da bir değişken tanımlandığında saklayacağı veri için veri tipinin boyutu kadar bellekte yer ayrılır (bazı tiplerin bellekte ne kadar yer kaplayacağı önceden belliyken –int, bool gibi- bazı tiplerin ki çalışma zamanında belli olur –string gibi-) ve o bellek alanına daha sonra erişim için bir isim verilir (değişken adı); ancak bu bellek alanının içi henüz boştur. Bu yüzden;

int sayac;
Console.WriteLine("Sayacın şu anki değeri : {0}",sayac);

şeklinde yazılacak bir kod derlenmeyecektir; çünkü henüz o değişken için başlangıç değeri verilmemiştir.

Framework ve Path

C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319

Tabiki sizlerin adresi kullandığınız Framework’ün versiyonu ve .NET Framework 4.0 SDK’sının dizininizdeki yerine bağlı olarak değişebilir. “Path” değişkeni güncellendikten sonra test etmek amacıyla açık olan bütün konsol pencereleri kapatılıp yeni bir tane açılır ve komut penceresindeyken

csc ?/ ya da csc -?

yazılır. Eğer işler yolunda gitmişse C# derleyicisinin sunduğu seçenekler listesinin elde edilmiş olması gerekmektedir. Bu değişkenin eklenmesiyle artık herhangi bir .NET aracını herhangi bir komut penceresinden çalıştırmak mümkündür.

Uygulamalarda Yorum Satırı

Uygulamalar için dokümantasyon sağlamak önemlidir. Yazılan kod ile ilgili yeterli bilgi sağlamak, geliştirilme sürecinde hiç yer almamış veya sonradan katılmış bir programcının uygulamayı anlayıp takip edebilir seviyeye gelmesi sürecini fark edilir düzeyde etkiler. İyi yorumlar, sadece kodlara bakılarak anlaşılması kolay olmayacak bilgiyi sağlarlar ve orada verilmeye çalışılan cevap “NE” değil “NEDEN” sorusu olmalıdır.

C#, uygulama kodlarına yorum eklemek için şu yolları sunar: Tek yorum satırı, çoklu yorum satırları ve XML dokümantasyonu. Tek satırlık yorumlar çift bölü işareti (//) ile eklenebilir. Uygulama çalıştırıldığı zaman bu karakterlerin arkasından gelen yazılar satır sonuna kadar ihmal edilir.

//Uyelik için kullanıcıdan ismi alınır
Console.Write("Adınızı giriniz : "); string ad = Console.ReadLine();

Eğer aynı zamanda birden fazla satır yorumlanmak istenirse ya her satıra çift bölü işareti (‘//’) koyulur ya da blok yorumlama işaretinden faydalanılır. Blok yorum, ‘/*’ işareti ile başlayıp ‘*/’ işaretini görene kadar devam eder.

/*Aşağıdaki işlemin sonucu x değişkenine atanıp kullanılır*/
 int x = (…);

C# Komut Satırı Derleyicisi ile Çalışmak

C# uygulaması çalıştırılmadan önce derlenmelidir. Bu iş için Visual Studio gibi uygulama geliştirme ortamı kullanılabileceği gibi C# uygulamaları için csc.exe ile de .NET assembly’leri oluşturabilir (csc, C-Sharp Compiler’ı simgeliyor).

Bu derleme aracı .NET Framework 4.0 SDK’nın (Software Development Kit –Yazılım Geliştirme Kiti-) içerisinde yer almaktadır. Büyük ölçekli bir uygulama hiçbir zaman komut satırından konsol penceresi kullanarak derlenmez; ancak *.cs uzantılı dosyanın nasıl derleneceğinin temellerini bilmek bir uygulama geliştirici açısından önemlidir. Ayrıca böyle bir sürece ihtiyaç duyulması için birkaç sebep göstermek gerekirse;
-> Uygulamanın bulunduğu ortamda Visual Studio bulunmayabilir.
-> C# bilgimizi biraz daha derinleştirmek isteyebiliriz. Böylece otomatik derleme aracı yazma hakkında temel bilgimiz artmış olur.
-> Bir uygulamayı derlemek için grafik bir arabirim kullanılsa da eninde sonunda csc.exe’ye başvurulacaktır. Dolayısıyla burada arka planda neler olup bittiği ile ilgili biraz daha ayrıntılı bilgi elde etmek istenebilir. (Örneğin kendi Visual Studio IDE’mizi yazmak istediğimizde…)

csc.exe’nin tanımlanması

C# komut-satırı derleyicisi kullanılmaya başlanmadan önce çalışılan makinenin csc.exe’yi tanıdığından emin olunması gerekiyor. Eğer makine doğru bir şekilde konfigüre edilmediyse C# dosyalarını derlemek için her seferinde csc.exe’nin bulunduğu dizini belirtmek gerekecek. Makinemize *.cs uzantılı dosylarımızı her hangi bir dizinden derleme yeteneği kazandırmak için (Windows XP işletim sistemi üzerinde gerçekleştirilen) aşağıdaki adımları takip etmek gerekir:
-> Bilgisayarıma (MyComputer) sağ tıklanır ve Seçenekler (Properties) penceresi açılır.
-> Gelişmiş (Advenced) tabı açılır ve oradan Ortam değişkenleri (Environment Variable) butonu tıklanır. “Sistem Değişkenleri” bölümünden “Path“ değişkenine çift tıklanır ve listenin en sonuna csc.exe’nin içerisinde bulunduğu klasörün fiziki yolu yazılır. (“Path” değişkenindeki herbir değer noktalı virgül ile ayrılmıştır)

csc.exe çalıştır

Uygulama geliştirme bilgisayarı csc.exe’yi tanıdığına göre C# komut satırı derleyicisi ve notepad kullanarak DemoUyg.exe adında basit bir tek dosyalı assembly geliştirilebilir. Bir notepad açarak aşağıdakiler yazılır:

//Basit bir C# uygulaması

using System;
class DemoUyg {
public static void Main(string[] args) {
Console.WriteLine("Deneme 1,2");
Console.ReadLine();
 }
}

Dosya uygun bir dizine (Mesela c:\Ornekler klasörüne) DemoUyg.cs olarak kaydededilir. C# derleyicisinin seçenekleri incelenecek olursa dikkat edilecek ilk nokta; oluşturulacak assembly’nin adı ve tipinin nasıl belirtileceğidir (Örneğin Uygulamam.exe adında bir konsol uygulaması, Robotik.dll adında bir kod kütüphanesi, WinUygulamam.exe adında bir masaüstü uygulaması vb…) Her olasılık, csc.exe’ye komut satırı parametresi olarak geçirilen özel bir işaret ile temsil edilir.

csharp-csc-derleyici-komut-satırı

DemoUyg.cs’i DemoUyg.exe ismindeki çalıştırılabilir bir uygulamaya derlemek için komut penceresinden *.cs dosyanın dizinine geçilir:

demo-csc-csharp-ornek

ve aşağıdaki komut satırı girilip ENTER’a basılır:

csharp-komut-satırı

Burada bilinçli olarak /out kullanılmadı. O yüzden programın giriş noktasını içeren (Main() metodu) DemoUyg sınıfından üretilen çalıştırılabilir dosya *.cs dosyasıyla aynı isimde (DemoUyg.exe olarak) ilgili dizinde oluşturulur. Bu arada birçok C# işareti, kısaltmaları tanır. Burada da /target yerine /t kullanılabilir:

csharp-cmd-komut-ekran

Aynı zamanda bu işaret (t:exe) C# derleyicisinin varsayılan dosya çıktı tipidir; dolayısıyla DemoUyg.cs şu şekilde de derlenebilir

cmd-exe-csharp-ornek-ogren

Varsayılan /target:exe olduğu için hiçbir dosya çıktı tipi belirtilmediğinde target:exe olarak işlem yapılır. Artık üretilen DemoUyg.exe komut satırından ya da üretildiği dizinden çalıştırılabilir. Ekran çıktıları aşağıdaki gibidir:

csharp-ekran-admin-cd

Sayfa başarılı bir şekilde derlenip programın çalıştırılabilir assembly’si (DemoUyg.exe) oluşturulur… İster ‘c’ dizini altındaki dosyaya gidip, ister komut-satırından .exe dosyasının adı yazılıp ENTER’a basılarak çalıştırılabilir.

csharp-derleme-sonuc-cmd

Ve son çıktı aşağıdaki gibi olur:

csharp-calisan-program-ekran

*.cs dosyasında bir değişiklik yapılmadığı sürece uygulama, üretilen bu *.exe dosyasından çalıştırılabilir. *.cs dosyasında bir değişiklik yapıldığında ise uygulama, güncel hali ile çalışmaya devam etsin diye yeniden derlenmelidir.

Temel I/O

Console sınıfı ile basit I/O işlemlerini örneklemek için kullanıcıdan veri alıp bu verileri yeniden ekrana yazan aşağıdaki gibi bir Main() metodu yazılabilir:

...
public static void Main(string[] args)
{
//Ekrana yazı yazıyoruz...
Console.Write("İsminizi giriniz : ");
//Kullanıcı ENTER'a basınca o ana kadar yazılan yazı okunur ve
bir değişkene atılır.
string giris = Console.ReadLine();
//Değişken üzerindeki bilgiyi ekrana yazıyoruz...
Console.WriteLine("Merhaba {0}",giris);
Console.Write("Yaşınız kaç? : ");
giris = Console.ReadLine();
Console.WriteLine("Demek {0} yaşındasınız...",giris);
}
...

Ekran çıktısı aşağıdaki gibi olmaktadır :

basit-giris-cikis

Tututcu Place Holder

Şu ana kadarki örneklerde WriteLine() içerisine yazılan birçok {0}, {1} kullanımlarını, text alanın ardından da değerlerinin verildiği görüldü. .NET, string formatlamanın yeni bir stilini geliştirdi, buna “yer tutucu” (PlaceHolder) denir.

public static void Main(string[] args) {
 ... int sayisal = 5;
string text = "Merhaba";
bool mantiksal = true;
// Bir textin içerisinde yazılan '\n’yeni bir satır ekler.
Console.WriteLine("Sayısal değer : {0}\nText değer : {1}\n
Mantıksal değer : {2}", sayisal, text, mantiksal);
Console.ReadLine();
 }

csharp-giris-cikis-basit-tutucu

WriteLine() içerisine çift tırnak (“…”) arasında yazılan her şey normalde ekranda görünür. Bunun istisnai durumlarından biri kullanılan süslü parantezlerdir. Bu süslü parantezler ekran çıktısında görünmez; çünkü onlar başka değerler için yer tutarlar. Yer tutmak istediğimiz her değer için bir süslü parantez içerisine ‘0’dan başlamak kaydıyla indeks numaraları verilir. Bu indekslerin yerine ekranda görünecek değerler ise çift tırnakların arkasından verilir (“…”,degerler). Eğer birden fazla yer tutucu kullanılmışsa değerler, virgülle ayrılarak içerdeki indeks sırasına göre yazılır.

Aynı zamanda tek bir yer tutucunun, tek bir string veri ile birden fazla yerde kullanılması da mümkündür. Örneğin “asla, asla vazgeçemem senden asla” şarkı sözlerini koda dökmek istersek;

//Tarkan söylüyor...

 Console.WriteLine("{0}, {0} vazgeçemem senden {0}","asla");

Yer tutucu indeksine eklenecek bir parametre ile alan genişliği belirlenebilir ve ilgili değerin bu alanda sağa ya da sola dayalı olarak yazdırılması sağlanabilir.

Console.WriteLine("\"10 birimlik alanda sola dayalı :{0,-10}\"",23);
 Console.WriteLine("\"10 birimlik alanda sağa dayalı :{0,10}\"",23);

Örneğin

@“c:\\Documents and Settings\Administrator” olarak kodlamak, ekrandaki çıktının “c:\\Documents and Settings\Administrator” olmasını sağlar.

Nümerik Formatlama

Nümerik verilerin nasıl formatlanıp görüntüleneceğini belirtmek için “format stringi” kullanılır. Tam söz dizimi (syntax) {N,M,:FormatString} iken burada N yer tutucunun indeks numaralandırıcısını, M alan genişliği ve önüne koyulan ‘+’ – ‘-’ işaretiyle yazının hangi tarafa dayalı yazılacağını, FormatString ise nümerik verinin nasıl gösterilmesi gerektiğini belirtir. Bütün format seçenekleri aşağıdadır:

Format Karakteri Açıklaması

C ya da c Nümerik veriyi lokal para sembolünü kullanarak para olarak
gösterir. Format string harfini “Currency” kelimesinin baş harfinden alır.
D ya da d Bu format sadece tam sayılar için desteklenir. Hemen arkasına aldığı sayı ile (d5 gibi) ekranda gösterilmesi gereken minimum basamak sayısı belirtilebilir ve eğer sayının basamak sayısı, belirtilen minimum basamak sayısından fazlaysa sayının başına ‘0’ eklenerek stringe çevrilir. Format string harfini “Decimal” kelimesinin baş harfinden alır.
E ya da e Sayıyı üstel notasyon kullanarak göstermek için kullanılır. Sayıyı “d.dddd…E+ddd” formatında stringe çevirir. (d’ ler birer rakamı temsil ediyor) Burada ilk basamak her zaman tam sayı olur ve format stringinin hemen arkasına belirtilebilecek bir sayı ile ondalık kısmında kaç basamak bulunacağı belirtilebilir. Belirtilmezse varsayılan olarak bu değer 6’dır. Üstel ifade ise her zaman minimum 3 basamaktan oluşur; dolayısıyla eğer ihtiyaç duyulursa e ya da E (string format’ına yazılacak harfin büyük mü küçük mü olduğuna bağlı olarak değişiyor)’den sonraki rakam “0” larla 3 basamağa tamamlanır… Format string harfini “Exponential” kelimesinin baş harfinden alır.
F ya da f Sayı, ondalık olsun ya da olmasın varsayılan olarak 2 basamak ondalıkla stringe çevrilir. Eğer tam sayı ise sonuna ondalık olarak sıfırlar eklenir. Eğer ondalık sayı ise ve ondalık kısmı ikiden fazla ise varsayılan değer iki olduğu için virgülden sonraki değerlerinin sadece ilk ikisi alınarak formatlama yapılır… Format string’inin hemen arkasından verilecek bir değer ile sayının ondalık kısmında bulunması istenilen basamak sayısı belirlenebilir (f4 gbi). Format string harfini “Fixed” kelimesinin baş harfinden alır.
G ya da g Sayıyı hemen arkasından verilebilen değere ve basamak sayısına
bağlı olarak ya aynen yazılır ya da ‘e’ string formatıyla stringe çevrilir. Eğer format string ile birlikte bir değer verilmezse sayı olduğu gibi alınır. Eğer verilirse; değer, stringe çevrilecek sayının istenilen tam ve ondalık basamak sayıları toplamını işaret eder. Değer, sayının tam kısmındaki basamak sayısından az ise formatlama üstel olarak yapılır, diğer durumlarda sayı olduğu gibi çevrilir. Format string harfini “General” kelimesinin baş harfinden alır.

N ya da n Bu format stringi ile soldan başlayarak her 3 basamakta bir araya
bin ayıracı koyulması sağlanır. Hemen arkasından verilebilecek değer ile istenilen ondalık basamak sayısı verilebilir. Bu değer varsayılan olarak 2’dir. Format string harfini “Number” kelimesinin baş harfinden alır.
P ya da p Sayı 100 ile çarpılarak yüzde işareti ile sunulur. Hemen arkasından
verilebilecek değer, yüzde değerinden sonra gelmesi istenilen ondalık basamak sayısıdır. Bu değer varsayılan olarak 2’dir. Format string harfini “Percent” kelimesinin baş harfinden alır.
X ya da x Sayı hexadecimal (onaltılı sayı sistemi) formatta stringe çevrilir.
Sadece tam sayılar için desteklenir. Format string harfini “Hexadecimal” kelimesindeki x harfinden alır.

.NET formatlama stringleri ve anlamları

Aşağıda nümerik formatlama ile ilgili bazı örneklere yer verilmiştir:

public static void Main(string[] args) {
Console.Title = "Nümerik Formatlama";
 Console.WriteLine("Para birimi formatlama: {0:C} / {0:C4}", 234.23);
Console.WriteLine("Tam sayı formatlama : {0:D5}",23);
Console.WriteLine("Üstel formatlama : {0:E3}",234.2);
 Console.WriteLine("Sabit noktalı formatlama : {0:f4}",234.5);
Console.WriteLine("Genel formatlama : {0:G2} {0:G4}",234.23);
Console.WriteLine("Sayı(Bin ayraçı) formatlama : {0:N}",2345678.2);
 Console.WriteLine("Hexadecimal formatlama : {0:X4}",23);
Console.ReadLine();
}

.NET formatlama karakterlerinin kullanımı sadece konsol uygulamaları ile sınırlı değil. String.Format() metodu ile bütün format stringleri herhangi bir uygulama tipinde (Masaüstü uygulamaları, ASP.NET, XML Web servisleri…) kullanılabilir.

public static void Main(string[] args) {
 ... //Yeni bir string veri oluşturmak için string.Format()
metodu kullanılıyor.
string formatStr;
formatStr = string.Format("Hesabınıza {0:C} yatırmak istediniz.
Onaylıyor musunuz?",234);
 Console.WriteLine(formatStr);
Console.ReadLine();
 }

Bu kodların çalıştırılmasıyla elde edilen ekran çıktısı ise aşağıdadır:

numerik-format-csharp

Namespace (isim alanı) Kavramı

C#, Microsoft.NET Framework’ün bir parçası olarak temel ve faydalı programlama işlerini gerçekleştirmek için yazılım geliştiricinin hizmetine birçok kullanışlı sınıf sunmuştur. Bu sınıflar isim alanları (namespaces) altında organize edilmişlerdir. Bir namespace, benzer amaca hizmet eden sınıflardan oluşan bir kümedir. Aynı zamanda bir isim alanı, başka isim alanlarını da içerebilir. Mesela System.IO isim alanı dosya giriş/çıkış ile ilgili tipleri, System.Data isim alanı temel veritabanı işlemleri ile ilgili tipleri içerir. Ayrıca vurgulamak da fayda var ki; tek bir assembly (mscorlib.dll gibi) istenilen sayıda isim alanı içerebilir, her bir isim alanında da istenilen sayıda tip yer alabilir. Bu, Visual Studio 2005 içerisindeki View menüsünden erişilebilecek olan Object Browser yardımıyla da görülebilir:

namespace-isimalanı-csharp

Console Sınıfı

Kitabın şu ana kadarki örneklerinde System.Console sınıfı sık sık kullanıldı, kullanılmaya da devam edilecek. Konsol kullanıcı arayüzü, Windows kullanıcı arayüzü kadar çekici değilken örnekleri konsol arayüzü ile kısıtlamak bize grafik arayüzünün kompleksliği ile uğraşmak yerine öğrenmeye çalıştığımız C# temellerine odaklanma fırsatı sunuyor. Adından anlaşılabileceği gibi bu sınıf konsol uygulamalarında kullanıcıdan veri alma, kullanıcıya veri gösterme, oluşan hata durumlarında gerekli manipülasyonları gerçekleştirmeyi üstlenir. Aşağıdaki üyeler örnek olarak verilebilir…

Üye ->Tanımı
BackgroundColor ->Ekran çıktısının arka plan ve yazı rengini değiştirmeye yarar.
ForegroundColor ->Ekran çıktısının arka plan ve yazı rengini değiştirmeye yarar.
WindowHeight ->Konsol ekran boyutunu değiştirmeye yarar.
WindowWidth ->Konsol ekran boyutunu değiştirmeye yarar.
WindowTop ->Konsol ekran boyutunu değiştirmeye yarar.
WindowLeft ->Konsol ekran boyutunu değiştirmeye yarar.
BufferHeight ->Konsol ekranında yazı yazılabilecek alanı belirler.
BufferWidth ->Konsol ekranında yazı yazılabilecek alanı belirler.
Clear() -> Konsoldaki yazı alanını temizleyen metot.
Title ->Çalışan konsol penceresinin başlığını belirler.

Temel Giriş Çıkış

Tablodakilere ek olarak Console sınıfı, ekrandan yapılan giriş ve çıkışları yakalayan üyeler tanımlar. Bu üyelere sınıf adı üzerinden erişiriz ve daha sonra görüleceği üzere bu üyelere static üyeler denir. WriteLine(), ekrana metin olarak yazı yazılmasını sağlar ve imleci bir alt satırda beklemeye zorlar, böylece arkasından yazılacak metin bir alt satırdan başlar. Write() metodunun tek farkı ise imleci ekrana yazılan yazının hemen sonunda bekletmesidir, böylece arkasından yazılacak metin aynı satırdan devam edecektir. ReadLine(), ekrana yazılan yazıyı metin olarak satır sonuna kadar okumayı sağlar, Read() ise ekrana yazılan metnin sadece ilk karakterini okur ve bunu karakterin ASCII karakter setindeki sayısal karşılığı olarak döndürür (Daha sonra görülecek dönüştürme yöntemleri ile bunun karakter karşılığı elde edilebilir), bir döngü içerisinde okunduğunda ve okuyacak karakter kalmadığında ise -1 döndürür. ReadLine() ve Read() metodu, ekrandaki yazıları kullanıcı klavyesinden ENTER tuşuna basılınca okur; yani uygulama, kaynak kodunda bu iki metoda rastlarsa ENTER tuşlanana kadar bekleyecektir.

Visual Studio Kullanarak Uygulamaların Derlenmesi

Visual Studio kullanarak uygulamaların derlenmesi için C# uygulamasını içeren proje açılarak Build menüsünden Build Solution tıklanır.

Visual Studio Kullanarak Uygulamaların Çalıştırılması

Visual Studio kullanarak uygulamaların derlenmesi için Debug menüsünden Start Debugging (ya da Ctrl F5) ya da Start Without Debugging (ya da F5) tıklanır. Konsol uygulaması geliştirilirken Ctrl + F5 ile çalıştırılması, uygulama sonlandığında kullanıcı herhangi bir tuşa basana kadar pencerenin açık kalmasını sağlar. Bu iki çalıştırma yolunun farkı; ilkinde uygulama debug (hata ayıklama) modunda çalıştırılırken ikincisinde debug mod kapalı olarak çalıştırılmasıdır.

Derleme Zamanı Hataları

Hem komut satırından hem de Visual Studio 2005 kullanarak uygulama derlendiğinde csc.exe, sözdizimi ya da semantik (anlam) bir hata yakalarsa bunu raporlar. Eğer komut satırından derlenmişse ekrana yazdırılan mesaj ile hatanın dosyadaki satır sayısı ve karakter pozisyonu bildirilir. Eğer derleme için Visual Studio kullanılmışsa Hata Listesi (ErrorList) penceresi bütün hatalı satırları işaret edip hata mesajını bildirir; hataya çift tıklanmasıyla da uygulama ortamı bizi ilgili satıra götürecektir. Uygulama derlendiğinde artık hata alınmıyorsa derleme zamanı hatalarından arınmışız demektir; uygulamanın .exe’si çalıştırılabilirdir.

Çalışma Zamanı Hataları

Uygulama çalıştırılabilir dosyasının (*.exe) sorunsuz olarak üretilmesinin ardından çalıştırılır ve eğer çalışma sırasında bir hata oluşursa buna çalışma zamanı hatası (exception) denir. Uygulama geliştirici olarak çalışma zamanında oluşacak hatalara karşı kod yazmamışsak bütün programlama ortamları için uygulama ekranında hatayla ilgili bilgilerin yer aldığı bir ekranla karşılaşılır. Uygulamadan faydalanan kullanıcının böyle bir ekranla karşılaşması istenmeyeceği için (en azından anlamlı bir hata mesajı ile karşılaşmasını isteyeceğimiz) bu hataları ele alan kodların yazılmış olması gerekir. (Bu konu “Çalışma zamanı hatalarını ele alma” başlığı altında ileriki konularda detaylı olarak incelenecektir)

Visual Studio Hata Ayıklayıcısı Yardımıyla Uygulamanın İzlenmesi

Uygulamaya kesme noktaları (break point) koymak ve kullanılan değişkenlerin çalışma zamanı değerlerini incelemek,takip etmek için Visual Studio Hata Ayıklayıcısı’ndan (Visual Studio Debugger) faydalanılabilir. Eğer bir uygulama satır satır ilerlenerek çalıştırılmak istenirse Debug menüsünden StepOver kliklenerek çalıştırılır ve yine aynı şekilde uygulama sonlanana kadar ilerlenebilir; satırlar arası ilerlerken uygulamanın nerelere dallanıp çalıştığı takip edilebilir ve kullanılan değişkenlerin değerleri incelenebilir. Uygulamaya kesme noktaları koymak için kod yazdığımız C# dosyasında (*.cs) herhangi bir satıra sağ tıklayıp BreakPoint seçeneğinden Insert BreakPoint tıklanır. Aynı zamanda sol kenar boşluğuna tıklanarak da koyulabilir. Kaldırmak için yine aynı satır üzerinden BreakPoint seçeneğinden Delete BreakPoint tıklanır. Aynı zamanda sol kenar boşluğunda çıkmış olan işarete tekrar tıklanarak da kaldırılabilir. Uygulama debug modda çalıştırıldığı zaman (F5 ile) herhangi bir satır ya da satırlara koyulan kesme noktasına kadar çalışıp o satırda bekleyecektir. Kullanılan değişkenlerin o anki değerlerinin incelenme ihtiyacı duyulduğunda bu faydalı olacaktır. Daha sonra uygulama ister adım adım (F10 ya da F11 ile) ister normal şekilde (F5) çalıştırılmaya devam edilir.

Main Metodu

Her uygulamanın bir başlangıç noktası olmalıdır. Bir C# uygulaması çalıştırıldığı zaman çalışmaya Main adındaki metottan başlar, kontrol bu metodun sonuna geldiğinde ise uygulama sonlanır. (Ya da varsa metot içerisinde return ifadesinin görüldüğü yerde uygulama sonlanır)

uygulama-derleme-main-debug-csharp

Microsoft Visual Studio

Microsoft Visual Studio; Microsoft teknolojileri üzerinde yazılım geliştirmek için en fazla kullanılan yazılım geliştirme aracıdır. İçerdiği araçlarla yazılım geliştiricilere çok fazla kolaylık sağlayan Microsoft Visual Studio, yazılım geliştirme deneyiminin çok üst seviyede yaşanmasına olanak tanımaktadır. Yazılımcıların eli ayağı olan Microsoft Visual Studio’ya biraz daha yakından göz atalım;

Microsoft Visual Studio Üzerinde Yeni Proje Açmak

Yeni proje açmak için File menüsünden New seçeneğinin üzerine gelinir ve açılan menüden “Project” seçeneği seçilir.

csharp-visual-studio-yeni-proje

New prokect menüsü karşınıza aşağıdaki ekranı çıkaracaktır. Yeni proje açmak istedinildiği Visual Studio’ya belirtildikten sonra bir de yeni açılacak olan projenin tipi belirtilmelidir. Sıradaki adımda projenin tipi belirtilmektedir.