Bu makalemizde C# dilinde property kavramını ele alacağız. Property’ler, class içerisindeki bir alanın sadece okunması, sadece yazılabilmesi yada hem okunup hem yazılabilmesi amacıyla kullanılırlar. Aslında çoğu durumda Property’leri kullanıyorsunuz. Örneğin TextBox’ın Text, TabStop, Tag, Top… gibi özellikleri birer property’dir.
property-tanimlamak-1

property-tanimlamak-1

            Yada, biraz daha geniş düşünelim: Projeniz üzerine bir kontrol sürükleyip bıraktığınızda bu kontrolün özelliklerini Properties penceresinden değiştirebiliyorsunuz. İşte, Properties penceresinde tanımlı olan tüm seçenekler bir property’dir. Siz isterseniz bu özellikleri değiştirirsiniz, isterseniz de default olarak girilmiş bazı değerler vardır, değişiklik yapmaz onları kullanırsınız.
property-tanimlamak-2

property-tanimlamak-2

            Şimdi gelelim propertylerin tanımlanması işlemine. Burada şu noktaya dikkatinizi çekmek istiyorum: Aslında Property olmadan da property’nin yapacağı işi yapabilirsiniz. Böyle bir durumda varolan değeri almak için bir fonksiyon, değeri değiştirmek için ise bir procedure tanımlamanız gerekecektir. Şimdi öncelikle property kullanmadan bir örnek yapalım:
            Öncelikle bir Windows Application başlatalım ve Project à Add Class ile projemize yeni bir class ekleyelim. Class’ımıza ClassSayi ismini verelim ve aşağıdaki kod bloğunu bu class içerisine yazalım.
    class ClassSayi
    {
        private int sayi = 1;
        //sayi değişkenine dışarıdan erişebilmek için bir
        //fonksiyon tanımladık.
        public int GetSayi()
        {
            return sayi;
        }
        //sayi değişkenini değiştirebilmek için bir procedure
        //tanımladık.
        public void SetSayi(int yenisayi)
        {
            sayi = yenisayi;
        }
    }
Dikkat edilirse yukarıdaki Class içerisinde sayi isminde private bir değişken declare edilmiştir. Bu sayi değişkenini dışarıya gönderebilmek için public olarak GetSayi isminde bir fonksiyon tanımlanmış ve private olan sayi değişkenini dışarıdan değiştirebilmek için public olarak SetSayi isminde bir procedure tanımlanmıştır. İşte aslında propertylerin yaptığı işlemi property olmadan da yukarıdaki kod bloğuyla yapabilirsiniz. Şimdi sonucu görmek için Form’umuz üzerine 2 tane buton sürükleyip bırakalım ve butonların click eventine aşağıdaki kodu yazalım:
        private void button1_Click(object sender, EventArgs e)
        {
            ClassSayi yeni = new ClassSayi();
            //Burada ClassSayi Class’ı içerisindeki sayi isimli
            //private değişkenin default değerini görmek için
            //GetSayi isimli fonksiyonu çağırdık.Sonuç=1
            this.Text = yeni.GetSayi().ToString();
        }
        private void button2_Click(object sender, EventArgs e)
        {
            ClassSayi yeni = new ClassSayi();
            //SetSayi isimli procedure kullanılarak sayi değişkeninin
            //değeri değiştiriliyor.
            yeni.SetSayi(50);
            //Değiştirilen değer GetSayi isimli fonksiyon kullanılarak
            //alınıyor ve formun başlığına yazdırılıyor.Sonuç=50;
            this.Text = yeni.GetSayi().ToString();
        }
            Yukarıdaki örnekle artık bir fonksiyon ve procedure arasındaki farkı da net olarak anlamış bulunuyorsunuz. Fonksiyon ve Procedure’ler anlatılırken aradaki fark olarak hep şu denilir: “Procedure geriye değer döndürmez, Fonksiyon geriye değer döndürür”. Mesela button2’nin click eventindeki kodu this.Text=yeni.SetSayi(50).ToString() şeklinde yazarsanız hata alacaksınız. Çünkü procedureler geriye değer döndürmez. Onun için bu değiştirdiğimiz değeri alabilmek için GetSayi() şeklinde bir fonksiyon tanımladık.
Şimdi de yukarıdaki örneği Property ile yapalım:
Project à Add Class ile PropertyClass isminde projemize yeni bir Class ekleyelim ve Classımız içerisini aşağıdaki şekilde düzenleyelim.
    class PropertyClass
    {
        private int sayi = 1;
        public int Sayim
        {
            get
            {
                return sayi;
            }
            set
            {
                sayi = value;
            }
        }
    }
            Genel olarak property’ler yukarıdaki gibi tanımlanırlar. Bir get ve bir set bloğundan oluşurlar. Get bloğu bir önceki örneğimizdeki fonksiyonu, set bloğu ise procedure’yi temsil eder. Dikkat edilirse property’ler bizi kod karmaşasından da kurtarmaktadır. Şimdi Formunuz üzerine 2 adet buton koyunuz ve butonların click eventini aşağıdaki gibi düzenleyiniz.
        private void button3_Click(object sender, EventArgs e)
        {
            PropertyClass yeni = new PropertyClass();
            //Sonuç 1 olacaktır. Sadece get bloğunu çalıştırdık.
            this.Text = yeni.Sayim.ToString();
        }
        private void button4_Click(object sender, EventArgs e)
        {
            PropertyClass yeni = new PropertyClass();
            yeni.Sayim = 20;
            //Sonuç 20 olacaktır
            this.Text = yeni.Sayim.ToString();
        }
Read-Only Property:
            Sadece get bloğundan oluşurlar. Read-Only olarak tanımlanan property’lerin değeri değiştirilemez. Bunu da bir örnek üzerinden anlatalım. Projemize yeni bir Class ekleyelim ve Class’ımıza ReadOnly ismini verelim. Class’ın içerisine aşağıdaki kodu ekleyelim:
    class ReadOnly
    {
        private string adi = “Nihat Demirli”;
        public string Yonetici
        {
            get
            {
                return adi;
            }
        }
    }
Buton’un Click event’ine de aşağıdaki kodu yazalım.
        private void button5_Click(object sender, EventArgs e)
        {
            ReadOnly oku = new ReadOnly();
            //Sonuç, Nihat Demirli olacaktır.
            this.Text = oku.Yonetici;
        }
Aşağıdaki gibi bir kod hatalı olacaktır:
            ReadOnly oku = new ReadOnly();
            //Read-Only bir property tanımladığımız için
            //değeri değiştiremeyiz
            oku.Yonetici = “Ali”;
            this.Text = oku.Yonetici;
Write-Only Property:
            Sadece set bloğundan oluşurlar. Dolayısıyla değeri değiştirilebilir. Projemize yeni bir class ekleyelim ve ismini WriteOnly verelim. Class’ımızı aşağıdaki gibi düzenleyelim:
    class WriteOnly
    {
        private string adi;
        public string Adi
        {
            set
            {
                adi = value;
            }
        }
    }
Formumuzun üzerine 1 tane buton ekleyelim ve kodumuzu aşağıdaki gibi düzenleyelim:
        private void button6_Click(object sender, EventArgs e)
        {
            WriteOnly yaz = new WriteOnly();
            yaz.Adi = “Ahmet Sait”;
        }
 Dikkat edilirse Write-Only Property’lerin sonucunu göremiyoruz. Aşağıdaki şekilde bir kullanım hatalı olacaktır:
            WriteOnly yaz = new WriteOnly();
            yaz.Adi = “Ahmet Sait”;
            //hata
            this.Text = yaz.Adi;
Çünkü, Write-Only property’ler, bir procedure gibi çalışırlar. Dolayısıyla geriye değer döndürmezler.
Auto-Implemented Property:
            C# 3.0 ile gelen bir yeniliktir. Temel manada, daha az kod kullanarak bir property tanımlamak amacıyla kullanabilirsiniz. Örneğimiz için AutoImplemented isminde bir Class oluşturalım ve aşağıdaki kodu yazalım:
    class AutoImplemented
    {
        public string Adi { get; set; }
    }
Daha sonra bir butonun click’ine de aşağıdaki kodu yazalım:
        private void button8_Click(object sender, EventArgs e)
        {
            AutoImplemented yeni = new AutoImplemented();
            yeni.Adi = “Ahmet Sait Duran”;
            this.Text = yeni.Adi;
        }
            Dikkat ederseniz propertymizi tanımlarken sadece 1 satırlık kod kullandık. Aynı işi yapacak kodu Auto-Implemented property tanımlamadan aşağıdaki gibi de yapabilirdiniz. Tabii ki daha fazla kod yazmanız gerekecekti.
    class Normal
    {
        private string ad;
        public string Adi
        {
            get
            {
                return ad;
            }
            set
            {
                ad = value;
            }
        }
    }
Başka bir makalede tekrar görüşmek dileğiyle. İyi çalışmalar…