5. BÖLÜM : DEĞİŞKEN TANIMLAMAK ve KULLANMAK(*)

Şimdiye kadar verilen basit örneklerde zaman zaman değişken tanımlayıp kullandık. Bu bölümde değişkenler bütün yönleri ile anlatılmasa bile ortalama bir programcının değişkenler konusunda gerek duyacağı kadar bilgi verildi. Konu nesneye yönelik programcılık olduğunda değişken tanımlamak demek gerçekte ilgili sınıfın alanlara sahip olmasını sağlamaktır. Bu bölümde değişkenler konusunu işlerken Class kavramını göz ardı edeceğiz. Bunu yaparken Visual Studio ile Windows Forms Application şablonuyla hazırlanan projenin formu ve dolayısıyla Visual Studio tarafından hazırlanan “Form1” sınıfını kullanacağız. 

.NET ortamı için geliştirilen bütün diller aynı veri tiplerine sahiptir. Dillerin arasındaki fark, değişkenleri tanımla şeklindedir. Örneğin Visual Basic’te tamsayı tipteki değişkenleri tanımlamak için “Dim Sayi As Integer” şeklinde kodlama yapılmaktadır. Bu şekilde tanımlanan değişken bellekte 4 byte yer kaplar. Benzer bilgi C# projesi dahilinde saklanmak istendiğinde ise “int Sayi;” şeklinde kodlama yapılarak değişken tanımlanır. 

Başka bir deyişle .NET uyumlu bütün dillerde aynı özelliklere sahip değişkenler bulunmaktadır. Çünkü .NET uyumlu her programlama dili Common Type System adı verilen ortak tip tanımlama kurallarına bağlı kalmak zorundadır. Bu nedenle C# projelerinde tanımlanan her değişkenin Common Type System’de bir karşılığı vardır. 

Başka bir deyişle .NET uyumlu her programlama dili Common Type System’de tanımlı türlere kendince takma adlar vermektedir. Örneğin C#’ta tam sayı bilgileri bellekte saklarken kullanılan int tipindeki değişkenlerin CTS’deki karşılığı System.Int32’dir. Benzer şekilde C#’ta kullanılan bool değişkenlerin Common Type System’deki karşılığı System.Boolean’dır. int gerçekte System.Int32 yapısının(struct) takma adıdır. 

Kesirli sayıları saklamak amacıyla kullanılan float değişkenlerin Common Type System’deki karşılığı ise System.Single’dır. Visual Basic’te tamsayı bilgileri saklamak amacıyla kullanılan System.Int32 türündeki değişkenlere Integer takma adını verirken, C# bu değişkenlere int takma adını vermektedir. 

Değişkenlerin içerikleri bir tipten başka bir tipe Convert sınıfı ile dönüştürülürken Common Type System’deki karşılıkları kullanılır. Örneğin TextBox’a yazılan ve rakamlardan meydana gelen bilgi int tipindeki değişkene aktarılırken aşağıdaki gibi bir dönüştürme yapılır. Burada kullanılan ToInt32(), Convert sınıfının bir metodudur. 

int sayi;
sayi = Convert.ToInt32(textBox1.Text); 

Bu nedenle C# projelerinde kullanılan tiplerin Common Type System’de bir karşılığı olduğunu bilmek bazı konuları anlamanıza yardım edecektir. Değişken tiplerinden söz edilirken bazen ilgili değişkenin Common Type System’deki karşılığından söz edilecektir. Common Type System’deki veri tipleri ve C#’taki karşılıkları aşağıda tablo halinde verildi.

Varsayılan değişken tipleri adları yerine, değişken tiplerine kendiniz ad verip kullanabilirsiniz. Bu işlemin nasıl yapıldığını aşağıda görebilirsiniz. Kod dosyasının başında using anahtar kelimesi ile ilgili tip veya yapıyı takma ada eşitledik. 

usingSystem;
usingTamsayi = System.Int32; 
namespaceConsoleApplication1
{ 
  class Program 
   { 
     static void Main(string[] args) 
       { 
        Tamsayi i; 
        i = 2007; 
       } 
    }
} 

Bu hazırlıktan sonra Int32 tipinde değişken tanımlarken bu takma isimden yararlanabiliriz. Birden fazla dilde program yazıyorsanız bir dildeki alışkanlığınıza uygun olarak tiplere takma adlar verebilirsiniz. 

Tekrar etmek gerekirse gerçekte int, char, double, byte vs birer takma addır. Örneğin int, “System.Int32” tipinin veya yapısının(struct) takma adıdır. Bu nedenle değişken tanımlarken mevcut takma adlar yerine ilgili sınıfı veya yapıyı kullanabilirsiniz. Aşağıda verilen kodda takma ad kullanmadan “Int32” tipinde bir değişken tanımlanmaktadır. 

System.Int32 i;
i = 2007;
textBox1.Text = i.ToString(); 

Daha sonraki konularda göreceğiniz gibi Struct’lar da tıpkı Class’lar gibi yapıcı metoda sahip olabiliyor ve Struct’ların örnekleri alınabilmektedir. Bu nedenle System.Int32 ve System.Byte gibi yapıların örnekleri aşağıdaki gibi bilinen şekilde alınabilir. 

System.Int32 i = new System.Int32();
i = 2007;
textBox1.Text = i.ToString(); 

Değişkenlere İlk Değer Aktarmak 

C#’ta değişken tanımlanırken önce değişkenin tipi, ardından değişkenin adı belirtilmektedir. Örnek olması için forma yerleştirdiğimiz button nesnesinin Click olayını temsil eden metodun içinde string, int ve bool tipinde 3 değişken tanımlayıp bilgi aktardık.



C# derleyicisi değişken adları konusunda büyük-küçük harf ayrımı yapmaktadır. Ayrıca değişken adlarının ilk karakteri harf olmalıdır. Değişken adı olarak anahtar kelimeler kullanılamaz ve değişken adı içinde özel karakterlere(*, +, #, vs) yer verilemez. 

Değişkenleri tanımlarken aynı zamanda ilk değer aktarabilirsiniz. İlk değer ataması yapılırken değişkene aktarılan bilginin değişkenin tipine uygun olmasına dikkat edilmelidir. Değişken tanımlarken ilk değerin nasıl aktarıldığını aşağıda görebilirsiniz. 

string Takim = "Fenerbahçe";
int Yil = 2007;
bool Medeni_hal= false; 

Programın yazımı sırasında söz konusu değişkene aktarılacak ilk değer belli değilse sayısal değişkenlere 0 ve bool değişkenlere ise false aktarılabilinir. Değişkenlere varsayılan başlangıç değeri aktarılırken new anahtar kelimesi kullanılabilir. new anahtar kelimesi ile değişkenlere nasıl ilk değer aktarıldığını aşağıda görebilirsiniz. 

int Yil = new int();
bool Medeni_hal = new bool();
char Cevap = new char();
float Katsayi = new float(); 

newanahtar kelimesi C# gibi nesneye yönelik programlama dillerinde önemlidir. Çünkü new ile yapı veya sınıflardan yola çıkılarak nesne hazırlanmaktadır. 

Yukarıda değişkenleri button1_Click() metodu içinde tanımladık. Dolayısıyla bu değişkenleri ilgili sınıfın(burada Form1) başka metotlarında kullanmak mümkün değildir. Çünkü class’taki herhangi bir metodun içinde tanımlanan değişken o metottan çıkılıp başka bir metoda geçildiğinde tanımsız duruma düşer. Aşağıda verilen kodda tanımlanan değişkenler bu formdaki(sınıftaki) bütün metotlarda kullanılabilir.



Yukarıda değişkenlerin yaşam alanı konusunda anlatılanlardan başka C# derleyicisi yalnızca blok içinde geçerli olabilen değişkenlerin tanımlanıp kullanılmasına izin vermektedir. Aşağıda verilen kodda Form1 sınıfının Form1_Click() metodu içinde “if” deyimi ile sınırlanan blokta “Oyuncu” adında bir string değişken tanımladık. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   string Takim = "Fenerbahçe"; 
   if (Takim == "Fenerbahçe") 
     { 
       string oyuncu; 
       oyuncu = "Tuncay Şanlı"; 
       textBox1.Text = oyuncu;  
     }   
  } 

Bu metot işletilirse “if” deyimi ile kontrol edilen koşul doğru olacağından blok işletilir ve bu bloktaki satırlar sayesinde değişken tanımlanıp kullanılır. Bu blokta tanımlanan bu değişken bloktan çıkıldığında tanımsız duruma düşer. Bu nedenle bu metot aşağıdaki gibi düzenlenirse hata meydana gelir. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   string Takim = "Fenerbahçe"; 
   if (Takim == "Fenerbahçe") 
    { 
      string oyuncu; 
      oyuncu = "Tuncay Şanlı"; 
    }   
    textBox1.Text = oyuncu;  // Hata meydana gelir..
 } 

Tanımlanan değişken hiç kullanılmazsa hata meydana gelmez ama derleme sırasında uyarı mesajı verilir. Benzer şekilde ilk değer aktarılmayan değişken herhangi bir şekilde kullanılmak istendiğinde hata meydana gelir. 

Değişkenleri Public Yapmak 

Tanımladığınız değişkeni diğer Class’larda kullanabilmek istiyorsanız public yapmalısınız. Tanımlama satırının başına public veya private yazılmayan değişkenlerin private oldukları kabul edilir ve yalnızca tanımlandıkları class’larda kullanılabilir. 

publicanahtar kelimesinin işlevini göstermek için projeye 2. bir form dahil ettik. Ardından bu formu ekrana getirebilmek için ilk formun üzerine bir düğme yerleştirip bu düğmenin Click olayını temsil eden metodu aşağıdaki gibi düzenledik. Üzerinde çalışılan projeye 2. bir form dahil etmek denilince bunu System.Windows.Forms adlı namespace’te yer alan Form sınıfının mirasçısı 2. bir sınıf hazırlamak olarak algılayabilirsiniz. 

privatevoid Goster_Click(object sender, EventArgs e) 
  { 
    Form2 Yeni_form = new Form2(); 
    Yeni_form.Show();  
  } 

Şimdi Form1 sınıfında tanımlayıp bilgi aktaracağımız string değişkenin içeriğini Form2’nin başlık metni olarak kullanacağız. Bu amaçla public deyimini kullanarak aşağıda yapıldığı gibi bir değişken tanımlayıp bilgi aktardık. public özelliği verilen değişkeni metotların içinde tanımlamak isterseniz hata meydana gelir. 

publicstring Baslik;
privatevoid Goster_Click(object sender, EventArgs e) 
  { 
    Baslik = "Fenerbahçe"; 
    Form2 Yeni_form = new Form2(); 
    Yeni_form.Show();  
 } 

Bu şekilde tanımlayıp bilgi aktarılan değişkenin diğer class’larda kullanılabilindiğini göstermek için Form2’nin Click olayıyla ilgili metodunu aşağıdaki gibi düzenledik. 

privatevoid Form2_Click(object sender, EventArgs e) 
  { 
    this.Text = Form1.Baslik; 
  } 

C# gibi nesneye yönelik programlama dillerinde değişken tanımlama işlemini Class’lardan bağımsız düşünmemek gerekiyor. Buna rağmen hem geleneksel alışkanlığa bağlı kalmak hem de konunun kolay anlaşılmasını sağlamak için değişken tanımlama işlemlerini Class’lardan bağımsız olarak ele aldık. Yoksa değişken tanımlamak bir bakıma söz konusu Class’ın alanlara sahip olmasını sağlamak gibi bir şeydir. 

Static Değişkenler 

Bu kitabı baştan okuyup bu sayfalara kadar gelen birisi ister istemez ileriki sayfalarda Class’lar ve metotlar hakkında yazılanlardan henüz habersizdir. Buna rağmen bu sayfada static değişkenlerden söz etmeden önce kısaca statik metotlardan söz etmek gerekiyor. 

Normalde herhangi bir sınıftaki bir metot işletilmek istendiğinde önce new anahtar kelimesi ile o sınıfın örneği alınır(yani Class’tan yol çıkılıp nesne hazırlanır). Daha sonra söz konusu metot işletilir. Ancak işletilmek istenen metot statikse sınıfın örneğini almaya yani nesne hazırlamaya gerek yoktur. 

Bu konuda bilgi vermek için .NET Framework gelen ve System.Collections adlı namespace’ye yer alan ArrayList sınıfının örneğini aldık. Başka bir deyişle ArrayList nesnesi hazırladık. Bu satır sayesinde başlangıç kapasitesi 10 olan bir ArrayList nesnesi hazırlanır. 

private void button1_Click(object sender, EventArgs e) 
 { 
   ArrayList dizi = new ArrayList(10); 
 } 

Bu şekilde new anahtar kelimesi ile bu sınıfın örneği alındıktan sonra ArrayList sınıfının statik olmayan metotları kullanılabilir. Örneğin bu koda aşağıdaki gibi bir satır eklenip ArrayList sınıfının Add() metodu ile bu nesneye eleman eklenebilir. 

private void button1_Click(object sender, EventArgs e) 
  { 
    ArrayList dizi = new ArrayList(10); 
    dizi.Add("Fenerbahçe"); 
    this.Text = dizi[0].ToString();   
  } 

ArrayList sınıfının Add() gibi statik olmayan metotları olduğu gibi statik metotları da bulunmaktadır. Dolayısıyla bu statik metotları kullanabilmek için yukarıda yapıldığı gibi new anahtar kelimesiyle sınıftan yola çıkıp nesne hazırlamak zorunda değilsiniz. Örneğin ArrayList sınıfının FixedSize() metodu statik bir metottur ve kendisine parametre olarak verilen mevcut ArrayList nesnesinin kapasitesi sayısı sabitlenmiş halini geri göndermektedir. Bu nedenle FixedSize() metodu direk aşağıdaki gibi kullanılabilir. 

private void button1_Click(object sender, EventArgs e) 
 { 
   ArrayList dizi = new ArrayList(2); 
   dizi.Add("Fenerbahçe"); 
   dizi.Add("Galatasaray"); 
   dizi = ArrayList.FixedSize(dizi); 
 } 

FixedSize() metodu ile yapılan bu işlemden sonra bu ArrayList nesnesine Add() metodu ile 3. bir eleman eklenemez.Yine .NET Framework ile gelen Math sınıfının bütün metotları statiktir. Örneğin bir sayının karekökü alınmak istendiği zaman Math sınıfının Sqrt() metodu aşağıdaki gibi nesne hazırlamaya gerek olmadan kullanılabilir. 

private void button1_Click(object sender, EventArgs e) 
 { 
   int sayi = 16; 
   double kok = Math.Sqrt(sayi); 
   this.Text = kok.ToString();  
 } 

Sınıflarda statik metotlar olduğu gibi statik değişkenler, nesneye yönelik programlık terimi ile söylemek gerekirse statik alanlar da olabilmektedir. Statik alanlar tıpkı statik metotlar gibi ilgili sınıfın örneğini almaya gerek olmadan kullanılabilmektedir. Statik değişkenler hakkında bilgi verirken kullandığımız projeye CS uzantılı bir kod dosyası dahil edip bu dosyanın içeriğini aşağıdaki gibi düzenledik.



Bu bölümde tercih edilen değişken adları başka yerli kitaplarda da kullanılmış olabilir. Olası benzer değişken adları tesadüften ibarettir. Yoksa “yil” yerine “year” adında değişken tanımlamak gerekirdi. Tabi bu bölümde kullanılan sayi1, sayi2, “i”, “j” gibi değişken adlarını unutmamak gerekir. Sayi1 yerine “Number1” kullanılabilir ama i yerine ne kullanılır bilinmez. 

Ayrı bir CS dosyası olarak düzenlenen bu sınıfta 2 statik değişken yani 2 alan bulunmaktadır. Statik değişkenler doğaları gereği ayrıca public olmalıdır. Yoksa başka sınıflardan erişilemezler. Bu şekilde 2 statik değişkene sahip bir sınıf hazırladıktan sonra bu sınıfın KDV adını verdiğimiz değişkenini aşağıdaki gibi kullandık. 

private void button1_Click(object sender, EventArgs e) 
  { 
    int fiyat = 1200; 
    double kdv = statikler.KDV; 
    double kdv_dahil = fiyat + fiyat * kdv; 
    this.Text = kdv_dahil.ToString();  
  } 

Başka bir sınıftaki statik değişkeni bu şekilde kullandığınız gibi içeriğini değiştirebilirsiniz. Aşağıda yapıldığı gibi statik değişkenin içeriği değiştirilirse uygulama sona erene kadar veya aynı şekilde tekrar değiştirilene kadar içeriğini korur. 

private void button1_Click(object sender, EventArgs e) 
 { 
   int fiyat = 1200; 
   statikler.KDV = 0.10f; 
   double kdv = statikler.KDV; 
   double kdv_dahil = fiyat + fiyat * kdv; 
   this.Text = kdv_dahil.ToString();  
 }

Sabit Tanımlamak ve Readonly Değişkenler 

Programcılar bazen tanımladıkları değişkenin içeriğinin değiştirilmesini istemezler. Bu gibi durumlarda normal değişken tanımlamak yerine const anahtar kelimesi ile sabit tanımlayabilirsiniz. Aşağıda 2 sabit tanımlama örneği bulunmaktadır. 

const string Takim = "Fenerbahçe";
const float Pi = 3.14f; 

constanahtar kelimesi ile sabit tanımlarken ilk değerin(aynı zamanda son) aktarılması gerekiyor. Sabitin ilk değeri aktarılmazsa hata meydana gelir. Başka bir deyişle derleme sırasında sabitin alacağı değerin belli olması gerekiyor. Tanımladığınız sabitin içeriğini sonradan değiştirmek isterseniz yine hata meydana gelir. 

Yukarıda anlatılanlara göre Const olarak tanımlanan değişkenin içeriği kod yazılırken bilinmelidir. Bazen programın yazımı sırasında değil de nesne oluşturulurken içeriği belirlenebilinen sabitlere gerek duyulur. Nesne oluşturma işlemi sırasında yapıcı metotta içeriği belirlenebilinen değişkenlere Readonly değişken denilmektedir. Bu konuda bilgi vermek için aşağıdaki gibi bir konsol uygulaması hazırladık.



Bu konsol uygulamasında reaadonly özelliğini verdiğimiz değişken veya alanın içeriği sınıfın yapıcı metodunda değiştirilmektedir. Readonly değişkenlerin içerikleri yalnızca yapıcı yani Constructor metotlarda değiştirebildiği için başka bir metotta bu değişkenin içeriği değiştirilmek istenirse hata meydana gelir. Bu Readonly değişkenden yararlanabilmek için 2. bir sınıf hazırlayıp yukarıda verilen sınıfın örneğini hazırladık.



Bu anlatılanlara göre Readonly değişkenlerin içerikleri new anahtar kelimesinden yararlanıp nesne hazırlanırken yapıcı metotlar aracılığı ile değiştirilebilmektedir. Bu örnekteki Sinif_2’nin yapıcı metodunun bir parametreye sahip olması sağlanıp readonly değişkenin içeriği kullanıcıdan istenebilir. Bunun nasıl yapıldığını aşağıda görebilirsiniz. 

using System;
public class Sinif_1 
 { 
   public static void Main() 
    { 
       Sinif_2 Nesne; 
       int i; 
       Console.Write("Yıl Girin"); 
       i = Convert.ToInt32(Console.ReadLine()); 
       Nesne = new Sinif_2(i); 
       Console.Write(Nesne.Yil.ToString());     
    } 
  }

public class Sinif_2 
 {  
   public readonly int Yil; 
   public Sinif_2(int i) 
    { 
       this.Yil = i; 
    }  
  } 

Const olarak işaret edilen değişkenler tıpkı static değişkenler gibi başka sınıflarda sınıfın örneğini almaya gerek olmadan kullanılabilir. Bunu size göstermek için yukarıda static alanları anlatmak için hazırladığımız Class’ta değişiklik yaptık. 

class statikler 
 { 
   public const double KDV = 0.18f; 
 } 

Bu şekilde hazırlanan sabit başka sınıflarda sanki statik bir değişkenmiş gibi kullanılabilir. Tabii statik değişkenlerden farklı olarak const olarak işaret edilen değişkenin içeriği sonradan değiştirilemez. 

private void button1_Click(object sender, EventArgs e) 
 { 
   int fiyat = 1200; 
   double kdv = statikler.KDV; 
   double kdv_dahil = fiyat + fiyat * kdv; 
   this.Text = kdv_dahil.ToString();  
 } 

Char Değişkenler 

Sınıfının dahilinde tek karakterlik bilgileri saklama gereğini duyuyorsanız char tipinden yararlanarak değişken tanımlayabilirsiniz. Char değişkenlerde ASCII ve Unicode karakter kümesindeki karakterlerden birisi saklanabilir. Char değişkenler bellekte 2 byte yer kaplamaktadır. char değişkenlere aktarılan karakterler tek tırnak(' ') içine alınmalıdır. 

char karakter = 'A';
karakter = "A"; // Hata oluşur. 

Char değişkene aktarılmak istenen bilgi birden fazla karaktere sahipse hata meydana gelir. C# derleyicisi birden fazla karakterden meydana gelen string bilgilerin char değişkenlere aktarılmasına izin vermez. String bilgi tek karakterden meydana geliyorsa aşağıda yapıldığı gibi dönüştürülüp char değişkene aktarılabilinir. String bilgiler çift tırnak içine alınmaktadır. 

char Cevap =Convert.ToChar("E"); 

char değişkene aktarmak istediğiniz karakterin Unicode ve ASCII kodunu biliyorsanız dönüştürme yaparak aktarabilirsiniz. Aşağıda verilen kod işletildiğinde “Cevap” değişkenine “A” harfi aktarılır. Çünkü ‘A’ harfinin ASCII kodu 65’tir. 

privatevoid Form1_Click(object sender, EventArgs e) 
 { 
    char cevap = Convert.ToChar(65); 
    textBox1.Text = cevap.ToString();  
 } 

Bu kodda char değişkenin içeriğini TextBox’ta görüntüleyebilmek için Object sınıfının ToString() metodu ile dönüştürme yaptık. 65 sayısını char tipine dönüştürürken burada yapıldığı gibi Convert sınıfını kullanmak yerine dönüştürülecek bilginin önüne aşağıdaki gibi ilgili tipi yazıp açık dönüştürme yapabilirsiniz. Bu satırlarda 65 sayısının önüne parantez içinde char yazıldığı için 65 sayısı char tipine dönüştürüp değişkene aktarılır. 

char Cevap =(char) 65;  // Cevap A olur.
textBox1.Text = Cevap.ToString(); 

Enter veya geriye silme tuşunu temsil eden kodu tırnak içine yazıp char değişkene aktarmak mümkün olmadığı için ilgili ASCII kodlarını char değişkenlere aynı şekilde aktarabilirsiniz. 

char Tus = (char)13; 

Şimdi örnek olması için bazı Ascii kodlarını elde edip bir ListBox’ta görüntüleyeceğiz. Bu amaçla forma bir ListBox yerleştirip aşağıda verilen kodu hazırladık. 

string Str;
for (int i=32; i<=255; i++) 
 {  
   Str = i.ToString() + " = " + (char)i;
   listBox1.Items.Add(Str);    
 } 

char değişkene aktarmak istediğiniz karakterin Unicode standardına göre kodunu biliyorsanız bu kodun önüne “u” harfini yazmalısınız. “A” harfinin Unicode’a göre kodu “0041” olduğu için aşağıda verilen kod işletilirse TextBox’a “A” aktarılır. Benzer şekilde “B” harfinin unicode’u \u0042’dir. 

char Cevap = '\u0041';
textBox1.Text = Cevap.ToString(); 

Türkçeye özgü karakterlerin Unicode’ları aşağıda tablo halinde verildi.