15. BÖLÜM : OBJECT SINIFI

Bu kitap metni içinde Object sınıfına sık sık gönderme yapılmak zorunda kalındığı için bu sınıf hakkında bilgi sahibi olmak gerek­mekte­dir. Bu bölüm bir bakıma nesneye yönelik programcılık kavramları hakkında bildiklerinizi test etmeye yaramaktadır. Bildiğiniz gibi .NET Framework ile gelen bütün class’lar Object class’ından türetilmek­tedir. Bu Class’ın orijinal yapısı aşağıda verildi.

namespace System
{
 public class Object    
  {
   protected virtual void Finalize()
     {
     }
   public virtual int GetHashCode()
     {
     }
   public virtual bool Equals(System.Object obj)
    {
    }
    public virtual string ToString()
     {
     }
   public static bool Equals(System.Object objA, System.Object objB)
   {
    }
   public static bool ReferenceEquals(System.Object objA, System.Object objB)
    {
    }
   public Type GetType()
    {
     }
   protected System.Object MemberwiseClone()
   {
   }
   public Object()
    {
    }
 }

Bu sınıfın private oldukları için kullanamadığımız FieldSetter(), FeildGetter(), InternalGetType(), GetFieldInfo() ve FastGetExisting() metotlarını bu yapıya dahil etmedik. Bildiğiniz gibi public static metotları herhangi bir hazırlık yapmadan istediği­niz yerde kullanabilirsiniz.

İlk olarak Equals() metodunu kullanmayı deneyeceğiz. Equals() metodu object veya başka bir tipteki 2 nesne veya değişkeni parametre olarak alıp birbirine eşit olup olmadı­ğını araştırmaktadır. Bu amaçla ilk olarak Object sınıfının 2 örneğini hazırladık. Object sınıfının yapıcı metodu boş bir nesne hazırlamaktadır. Hemen hatırlatmak gerekirse Object sınıfında Equals() metodunun 2 farklı sürümü bulunmaktadır. 

private void Form1_Click(object sender, EventArgs e)
 {
   Object Nesne1, Nesne2;
   Nesne1 = new Object();
   Nesne2 = new Object();
 }

Bu şekilde Object sınıfının 2 örneği hazırlanıp bu nesneler Equals() metodu ile karşılaştı­rılırsa nesneler birbirine eşit olmazlar. Bu nedenle aşağıda verilen kodda Equals() metodu “Nesne1” ile Nesne2’in birbirine eşit olmadıklarına hükmedir.

private void Form1_Click(object sender, EventArgs e)
 {
   Object Nesne1, Nesne2;
   Nesne1 = new Object();
   Nesne2 = new Object();
   bool sonuc;
   sonuc = Object.Equals(Nesne1, Nesne2);
   if (sonuc == true)
     MessageBox.Show("Bu nesneler birbirine eşit"); 
 }

Object tipindeki bu 2 nesneyi Equals() metodu ile birbiri ile karşılaştırmadan önce aşağıda yapıldığı gibi aynı değeri aktarmış olsaydık Equals() metodu bu kez geriye true gönderirdi. Bu kodda Object tipindeki bu 2 değişkene sayısal bilgi yerine null aktarmış olsaydık bile Equals metodu geriye true gönderirdi. 

private void Form1_Click(object sender, EventArgs e)
 {
   Object Nesne1 = new Object();
   Object Nesne2 = new Object();
   Nesne1 = 1234;
   Nesne2 = 1234;
   bool sonuc = Object.Equals(Nesne1, Nesne2);
   if (sonuc == true)
      MessageBox.Show("Bu nesneler birbirine eşit"); 
   else
      MessageBox.Show("Bu nesneler birbirine eşit değil");
  }     

Bu sonuca bakıp Equals() metodunun karşılaştırmayı yalnızca referans bazında yapmadı­ğına karar verebilirsiniz. Şimdi Object sınıfının Equals() adındaki statik metoduna biraz yakından bakalım. Bu metot kendisine parametre olarak verilen 2 nesne veya değişkenin(bu değiş­kenlerin object tipinde olması şart değildir) referanslarının aynı olup olmadığına bakar. Her 2 parametre veya nesne de aynı referansı işaret ediyorsa geriye true göndermektedir. Equals() metoduna parametre olarak verilen nesneler veya değiş­kenler aynı adreste saklanmıyorsa bu kez içeriklerinin aynı olup olmadığına bakılır.

Yukarıda Equals() metoduna direk Object tipindeki bilgileri parametre olarak verdik. Bu metot istenen tipteki bilgi veya nesneleri karşılaştırabilir. Aşağıda verilen örmekte ise Int32 tipindeki 2 değişkeni veya System.Int32 sınıfından oluşturulmuş 2 nesneyi Equals() metoduna parametre olarak verip birbiri ile karşılaştırdık. 

private void Form1_Click(object sender, EventArgs e)
 {
   System.Int32 Sayi1 = new System.Int32();
   System.Int32 Sayi2 = new System.Int32();
   Sayi1 = 100;
   Sayi2 = 100;
   bool sonuc = Object.Equals(Sayi1, Sayi2);
   if (sonuc == true)
      MessageBox.Show("Bu nesneler birbirine eşit"); 
 }

Equals() metodu System.Int32 sınıfından türetilmiş nesneleri karşılaştırırken onların refe­ransları yerine içeriklerine baktığı için burada yapılan karşılaştırma doğru değerini verir. Burada Int32 yapısının örneklerini new anahtar kelimesi ile aldıktan sonra bilgi aktardık. Eğer bu koddaki değişkenlere bilgi aktaran satırları kaldırırsanız değişen bir şey olmaz ve değişkenlerin birbirine eşit olduğuna hükmedilir. 

Çünkü değer tipindeki değişkenler new anahtar kelimesi ile hazırlandığında varsayılan başlangıç değer otomatik olarak aktarılıyor. Değişkenler adlı bölümden hatırlayabilece­ğiniz gibi double ve int gibi değişkenler new anahtar kelimesi tanımlanıp değer aktarıl­madan kullanılmak istenirse hata meydana gelmektedir. Konunun iyice anlaşılmasını sağlamak için aşağıda verilen örnekte TextBox sınıfından türetilmiş 2 nesneyi karşılaş­tırdık.

 private void Form1_Click(object sender, EventArgs e)
  {
     System.Windows.Forms.TextBox Text1;
     System.Windows.Forms.TextBox Text2;
     Text1 = new TextBox();
     Text2 = new TextBox();
     bool sonuc = Object.Equals(Text1, Text2);
     if (sonuc == true)
        MessageBox.Show("Bu nesneler birbirine eşit"); 
     else
       MessageBox.Show("Bu nesneler birbirine eşit değil");
  }

Bu örnekte TextBox’lara bilgi aktarmadan karşılaştırdık. Bu sırada her 2 TextBox’ın özellikleri aynı olsa veya aynı bilgileri içerseler bile bu karşılaştırmada nesnelerin birbirine eşit olmadığına hükmedilir. Çünkü Equals() metodu referans tipleri karşılaştı­rırken nesnele­rin referanslarına yani bellekteki adreslerine bakmaktadır. 

Bu şartlarda TextBox sınıfının Text1 ve Text2 adını verilen her iki örneği her şeyi ile aynı özelliklere sahip olsalar bile referansları farklı olduğu için Equals() metodu bu 2 nesnenin eşit olmadığını rapor eder. Ancak aşağıda yapıldığı gibi bu TextBox nesneleri birbirine eşitlenip bellekte aynı adresi kullanmaları sağlandığında Equals() metodu geriye true gönde­rir ve parametre olarak aldığı nesnelerin birbirine eşit olduğuna hükmeder.

TextBox Text1 = new TextBox();
TextBox Text2 = new TextBox();
Text1.Text = "Fenerbahçe";
Text2 = Text1; 
bool sonuc = Object.Equals(Text1, Text2);
if (sonuc == true)
  MessageBox.Show("Bu nesneler birbirine eşit"); 
 

Tekrar etmek gerekirse Equals() metodunu çağıran ve parametre olarak verilen nesne Refe­rans Type olmasaydı bu kez içeriklerinin aynı olup olmadığına bakılırdı. Bu nedenle aşağıda verilen kodda Equals() metodu geriye true gönderir. Çünkü int tipindeki 2 değişken veya nesneye aynı bilgiyi aktardık.

private void Form1_Click(object sender, EventArgs e)
 {
   int Sayi1 = 100;
   int Sayi2 = 100;
   bool sonuc = Sayi1.Equals(Sayi2);
   MessageBox.Show(sonuc.ToString());    
 }

Bu sayfaya kadar Object sınıfının Equals() metodunu anlatırken sürekli .NET Framework ile gelen hazır tip ve sınıfları kullandık. Equals() metodunun kendi hazırladı­ğınız tiplere davranışı farklı olduğu için aşağıdaki gibi bir Class hazırladık.

publicclass Takim
 {
   public string takim_adi;
   public string baskan;
   public Takim(string par1, string par2)
    {
      takim_adi = par1;
      baskan = par2; 
    }
  }

Bu şekilde 2 alana ve bir yapıcı metoda sahip sınıf hazırladıktan sonra aşağıdaki gibi kod yazıp bu sınıfın 2 örneğini alıp Equals() metodu ile karşılaştırdık. Beklenilenin aksine Object sınıfının Equals() metodu bu 2 nesnenin birbirinden farklı olduğunu rapor eder.

privatevoid Form1_Click(object sender, EventArgs e)
 {
   Takim T1 = new Takim("Fenerbahçe", "Aziz Yıldırım");
   Takim T2 = new Takim("Fenerbahçe", "Aziz Yıldırım");
   if (Object.Equals(T1, T2))
      MessageBox.Show("Bu nesneler birbiri ile aynı");
   else
      MessageBox.Show("Bu nesneler birbirinden farklı");
  }

Yukarıdaki sayfalarda .NET Framework ile değişik tipteki nesneleri karşılaştırırken nesneler aynı içeriğe sahip olduklarında Equals() metodu bu nesnelerin birbirine eşit olduğunu söylüyordu. T1 ve T2 adını verdiğimiz bu 2 nesnenin birbirinden farklı olarak görülmesinin nedeni Equals metodunu “Takim” adını verdiğimiz sınıfımız için yeni­den yazmamış olmamızdır. “Takim” adını verdiğimiz Class’ın Object sınıfından gelen Equals() metodunu override edip nasıl yeniden hazırladığımızı aşağıda görebilirsiniz. Bu hazırlıktan sonra Equals() metodu Compare işlemi yapıp yalnızca kendisine parametre olarak verilen nesnedeki alanla­rın içeriklerine göre karar verir.

publicclass Takim
  {
    public string takim_adi;
    public string baskan;
    public Takim(string par1, string par2)
     {
       takim_adi = par1;
       baskan = par2; 
     }
    public override bool Equals(object obj)
      {
       Takim T = (Takim)obj;
       if ((T.takim_adi == this.takim_adi) && (T.baskan == this.baskan))
         return true;
       else
        return false;
     }
  }

Bu hazırlıktan sonra yukarıda verilen “Object.Equals(T1, T2)” satırında Equals() metodu geriye true gönderir. Şimdi benzer ayarlamayı TextBox sınıfının mirasçısı kendi hazırlayaca­ğımız bir sınıfta yapacağız. Yapacağımız ayarlama sonucu birbirleri ile karşılaştı­rılan TextBox nesnelerinin Text özellikleri aynı ise bir birine eşit oldukları kabul edilecektir.

publicclass Edit : TextBox
 {
   public override bool Equals(object obj)
    {
      Edit Edit1 = (Edit)obj;
      if (Edit1.Text == this.Text)
         return true;
       else
         return false;
     }
  }

Bu kodu yazmamdaki amaç TextBox ve başka sınıfların Object sınıfından miras aldıkları metotların nasıl override edildiklerine dikkatinizi çekmektedir. Bu metodun nasıl kulla­nıldığını göstermek için aşağıda verdiğimiz kodu yazdık.

private void button1_Click(object sender, EventArgs e)
 {
   Edit Text1 = new Edit();
   Edit Text2 = new Edit();
   bool sonuc = Object.Equals(Text1, Text2);
   if (sonuc == true)
      MessageBox.Show("Bu nesneler birbirine eşit");
   else
     MessageBox.Show("Bu nesneler birbirine eşit değil");
 }

Şimdiye kadar Object sınıfının Equals() metodunu kullanırken karşılaştırmak istediğimiz 2 nesneyi bu metoda parametre olarak verdik. Şimdiye kadar kullandığımız Equals() metodu Object sınıfının static bir metodu olduğu için direk kullanıyorduk. 

Ancak isterseniz Object sınıfının static olmayan ve nesne üzerinden çağrılan Equals() metodunu aşağıdaki gibi kullanabilirsiniz. Burada Equals() metodunu çağıran nesne ile metoda parametre olarak verilen nesne ile aynı referansa veya içeriğe sahipse geriye true gönderilir. Bu örnekte bu nesnelerin referansları farklı olduğu için geriye false gönderilir.

TextBox Text1 = new TextBox();
TextBox Text2 = new TextBox();
bool sonuc = Text1.Equals(Text2);
MessageBox.Show(sonuc.ToString());

ReferanceEquals Metodu 

Bu bölümün ilk sayfasında verilen Object sınıfının yapısını incelediğinizde Equals() meto­dundan başka ReferanceEquals() adında static bir metodun olduğunu görürsünüz. Bu metot kendisine parametre olarak verilen 2 nesne veya değişkenin referanslarının yani bellekteki adreslerinin aynı olup olmadığını araştırmaktadır. 

Yukarıda hakkında bilgi verilen Equals() metodu konu Değer Tipleri olduğunda değiş­ken veya nesnenin içeriğiyle ilgileniyordu. ReferenceEquals() metodu ise kendisine parametre olarak verilen tiplerin referanslarının aynı olup olmadığını araştırmaktadır. Bu nedenle ReferenceEquals() metodu aşağıdaki gibi kullanıldığında geriye false gönderir. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   int sayi1 = 100; 
   int sayi2 = 100; 
   if (Object.ReferenceEquals(sayi1, sayi2)) 
     MessageBox.Show("Bu değişkenlerin referansları aynı"); 
   else 
     MessageBox.Show("Bu değişkenlerin referansları farklıdır"); 
 } 

Yine yukarıdaki sayfalarda Equals() metodu hakkında yazılanlardan bildiğiniz gibi Equals() metoduna aynı içeriğe sahip 2 string değişken parametre olarak verildiğinde geriye true gönderilmektedir. Ne var ki konu ReferenceEquals() metodu olduğunda bekle­nilenden farklı bir sonuç alınmaktadır. Yani aynı içeriğe sahip 2 string değişkeni aşağıda yapıldığı gibi ReferenceEquals() metoduna parametre olarak verirseniz bu 2 değişkenin referanslarının birbirine eşit olduğu rapor edilir. 

 string Takim1 ="Fener"; 
 string Takim2 = "Fener"; 
 if (Object.ReferenceEquals(Takim1, Takim2)) 
   MessageBox.Show("Bu değişkenler birbirine eşit"); 
 else 
   MessageBox.Show("Bu değişkenler birbirine eşit değil"); 

Bu sonucun açıklaması şu olabilir: .NET Framework ile gelen string sınıfında ReferenceEquals metodu override edilip aynı içeriğe sahip string değişkenlerin birbirine eşit olması sağlanmaktadır. Benzer durum object tipindeki değişkenler için de geçerlidir. Bu örnekte değişkenlerin tipi object yapılırsa ReferenceEquals() metodu geriye yine true gönderir. 

     object Takim1 ="Fener"; 
     object Takim2 = "Fener"; 
     if (Object.ReferenceEquals(Takim1, Takim2)) 
       MessageBox.Show("Bu değişkenler birbirine eşit"); 
     else 
       MessageBox.Show("Bu değişkenler birbirine eşit değil"); 

Tekrar etmek gerekirse; string ve object değişkenler hariç ReferenceEquals() metodu kendisine parametre olarak verilen değişken veya nesneleri karşılaştırırken referansları­nın aynı olup olmadığına bakıyor. Bu nedenle aşağıdaki gibi 2 TextBox nesnesi hazırlayıp bunları ReferenceEquals() metodu sayesinde birbirleri ile karşılaştırırsanız nesnelerin birbirine eşit olmadıkları rapor edilir. 

privatevoid Form1_Click(object sender, EventArgs e) 
 { 
   TextBox Nesne1 = new TextBox(); 
   TextBox Nesne2 = new TextBox(); 
   if (Object.Equals(Nesne1, Nesne2)) 
      MessageBox.Show("Bu nesneler birbirine eşit"); 
   else 
      MessageBox.Show("Bu nesneler birbirine eşit değil"); 
 }  

ReferenceEquals() metodu benzer davranışı kendi hazırladığınız sınıfların örneklerini karşılaştırırken de gösterir. Örneğin aşağıdaki gibi kısıtlı özelliklere sahip bir sınıf hazırla­yıp bu sınıftan yola çıkılarak alanları aynı olan 2 kopyası hazırlanıp bu kopyalar birbiri ile karşılaştırıldığı zaman birbirine eşit olmadıklarına karar verilir. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   Takim Takim1 = new Takim("Fenerbahçe", "Aziz Yıldırım"); 
   Takim Takim2 = new Takim("Fenerbahçe", "Aziz Yıldırım"); 
   if (Object.ReferenceEquals(Takim1, Takim2)) 
      MessageBox.Show("Bu nesneler eşit"); 
   else 
      MessageBox.Show("Bu nesneler eşit değil"); 
 }
public class Takim 
 { 
   public string takim_adi; 
   public string baskan; 
   public Takim(string par1, string par2) 
    { 
      takim_adi = par1; 
      baskan = par2; 
   } 
 }

ToString() ve GetType() Metotları 

Object sınıfı­nın en çok kullanılan metodu ToString() metodudur. Bütün sınıflar Object sınıfından türetildiği için ToString() metodu bütün yapılar ve Class’lar tarafından destek­lenmektedir. Örneğin aşağıda verilen satırda kullanılan ToString() metodu, Int32 yapısı­nın(struct) Object sınıfından miras aldığı metottur. 

Int32 Sayi = new Int32();  // veya int Sayi;
Sayi = 1234;
textBox1.Text = Sayi.ToString(); 

Her ne kadar Int32 yapısı ToString() metodunu Object sınıfından miras almış olsa bile bu metot override edilip yeniden yazılmıştır. Herhangi bir müdahalede bulunmadığınız sürece ToString() metodun orijinal hali kendi sınıfınızın tam adını verir. Bu konuda bilgi vermek için yukarıda verilen “Takim” sınıfını aşağıdaki gibi düzenledik. 

public class Takim 
 { 
   public string takim_adi; 
   public int kurulus; 
   public Takim(string par1, int par2) 
    { 
       takim_adi = par1; 
       kurulus = par2; 
    } 
 } 

Daha sonra bu sınıfın örneğini alıp nesneye ToString() metodunu aşağıdaki gibi uygular­sanız tahmin edeceğiniz gibi formun başlığına önce Class’ın dahil olduğu namespace’in, ardından Class’ın adı yazılır. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   Takim Takim1 = new Takim("Fenerbahçe", 1907); 
   this.Text = Takim1.ToString();  
 } 

Bu kod işletildiğinde aşağıdaki gibi bir sonuç alınır. Buradaki “Proje1” üzerinde çalıştığımız uygulama dahilinde hazırlanan namespace’in adıdır. Başka bir deyişle “Takim” tipindeki “Takim1” nesnesine ToString() metodu uygulandığında sınıfın adı elde edilmektedir.



Hal bu ki Int32 yapısının örneğine(değişken) ToString() metodu uygulandığı zaman değişkenin içerinin string halini elde ediyorduk. Kendi hazırladığınız sınıfta ToString() metodundan farklı işlevler bekliyorsanız Object sınıfından miras alınan bu metodu yeniden yazmalısınız. ToString() metodunu aşağıdaki gibi kullansaydık formun başlığına 1907 yazılırdı. Çünkü “Takim” sınıfının “kurulus” alanı Int32 tipinde olduğu için burada kullanı­lan ToString() metodu Int32 yapısına ait metottur. 

private void Form1_Click(object sender, EventArgs e) 
 { 
   Takim Takim1 = new Takim("Fenerbahçe", 1907); 
   this.Text = Takim1.kurulus.ToString();  
 } 

Şimdi Object sınıfından gelen ToString() metodunu “Takim” adını verdiğimiz kendi sınıfımızda override edip yani yeniden yazıp farklı bir işleve sahip olmasını sağlayacağız. Ancak ToString() metodunu yeniden yazmadan önce yukarıda “Takim1” nesnesine uyguladığımız ToString() metodunun neden Namespace adına sınıfımıza verdiğimiz adı ekleyip geriye gönderdiğini açıklayacağız. “Takim” sınıfının sınırları içinde public override yazıp boşluk tuşuna basınca Visual Studio aşağıdaki gibi 3 metot listeledi.