Daha önceki konulardan bildiğiniz gibi en küçük C# uygulaması bile Class şeklinde düzenlenmektedir. Class’lar ise metot, alan, özellik, interface ve delagate’lerden meydana gelmektedir. Class’lar hakkında temel bilgi verilen bir önceki bölümde ister istemez metotlardan biraz söz edildi. Bu bölümde ise metotlar ayrıntılı bir şekilde incelenecektir.
Olay ve metot kavramını hatırlatmak için üzerinde çalıştığımız forma bir Button yerleştirdik. Button nesnesini forma yerleştirip çift tıklarsanız Visual Studio, button nesnesinin Click olayı için metot hazırlamak istediğinizi varsayıp kod yazılabilinen pencereyi açar ve çalışma anında düğme tıklandığı zaman işletilmek üzere bir metot kalıbı hazırlanır. Bu şekilde hazırlanan metot geriye değer göndermediği için metot adının önüne void yazılır.
privatevoid button1_Click(object sender, EventArgs e)
{
}
Form veya diğer nesnelerle ilgili olarak Visual Studio tarafından hazırlanan metotların dışında yapmak istediğiniz işlemler için kendiniz metot hazırlayabilirsiniz. Şimdi “Mesaj_yaz” adında geriye değer göndermeyen bir metot hazırlayacağız. Bu amaçla “Form1” sınıfında aşağıdaki gibi bir metot hazırladık. Bu metodun başına erişim belirteci olarak public veya private yazılmadığı için metodun private yani sınıfa özel olduğuna karar verilir.
Bu metodun form tıklandığı zaman işletilmesini istiyoruz. Bu nedenle Form1 sınıfının Form1_Click metoduna Mesaj_yaz() metodunu işletecek bir satırın yazılması gerekir. Bir metodu işletmek için metot adını yazmak yeterlidir. Örneğin aşağıda verilen Form1_Click() metodundaki “Form1” class adını, Click ise olayını işaret etmektedir.
void Mesaj_yaz()
{
MessageBox.Show("Visual C#");
}
private void Form1_Click(object sender, EventArgs e)
{
Mesaj_yaz();
}
Bu şekilde metot hazırlanıp çalışma anında form tıklanırsa “Form1” sınıfıyla ilgili olarak Click olayı meydana gelir ve bu olayla ilişkilendirilen Form1_Click() metodu işletilir. Bu metotta kendi hazırladığımız Mesaj_yaz() metodunu çağıran bir satır olduğundan “Mesaj_yaz()” metodu sayesinde bir diyalog kutusu içinde ekrana mesaj verilir.
Metotlar İçin Parametre Tanımlamak
Daha önceki konulardan bildiğiniz gibi .NET Framework ile gelen sınıfların(kontrollerin) olaylarını temsil etmek üzere hazırlanan metotlarda parametreler mutlaka kullanılıyor. Örneğin daha önce TextBox sınıfının KeyPress olayından söz edilmişti. KeyPress olayı çalışma anında kullanıcının klavyenin bir tuşuna bastığında meydana gelmekte ve söz konusu nesnenin KeyPress olayını temsil eden bir metot hazırlandıysa işletilmektedir.
private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
{
}
KeyPress olayını temsil eden metot adından sonra parantezlerin içinde “e” adında ve KeyPressEventArgs tipinde bir parametre vardır. KeyPress olayı meydana geldiğinde hangi tuşa basılmışsa basılan tuşla ilgili bilgi “e” parametresiyle metoda gönderilir.
Yukarıda hazırladığımız metot geriye değer göndermediği gibi metot çağrılırken metoda bilgi gönderilmedi. Şimdi yukarıda verilen Mesaj_yaz() metodunun parametreye sahip olmasını sağlayacağız. Metot dışarıdan bilgi alacaksa veya parametrelere sahip olacaksa bu parametreler değişken tanımlanıyor gibi parantezin içine yazılmalıdır.
void Mesaj_yaz(string text)
{
MessageBox.Show(text);
}
Mesaj_yaz() metodu dışarıdan string tipte bilgi alacağı için parantezin içinde string bir değişken tanımladık. Metot birden fazla parametreye sahipse parantezin içinde birden fazla değişken tanımlanır. Mesaj_yaz() metodunu bu şekilde değiştirdikten sonra formun Click olayını temsil eden metodu aşağıdaki gibi düzenledik.
private void Form1_Click(object sender, EventArgs e)
{
string mesaj = Microsoft.VisualBasic.Interaction.InputBox(
"Mesaj Girin", "Bilgi Girişi", "", 200, 200);
Mesaj_yaz(mesaj);
}
Şimdi ise kendisine parametreler aracılığı ile gönderilen 2 sayıyı toplayıp sonucu MessageBox ile ekrana getiren “Topla()” adında bir metot hazırlayacağız. Bu metot int tipinde 2 bilgi alacağı için parantezlerin içine parametrelerin tipilerini ve adlarını aşağıdaki gibi yazdık.
void Topla(int sayi1, int sayi2)
{
int sonuc = sayi1 + sayi2;
MessageBox.Show(Convert.ToString(sonuc));
}
Mevcut bir metodu çağırmak için metot adını yazmak yeterlidir. İşletilecek metot parametreye sahipse metodun çağrıldığı satırda metot adından sonra içerikleri metoda aktarılmak istenen değişkenler veya bilgiler yazılır.
private void Form1_Click(object sender, EventArgs e)
{
int maas = 1250;
int mesai = 125;
Topla(maas, mesai);
}
Çalışması anında form tıklanırsa Click olayı meydana gelir ve Form_Click() metodu işletilir. Bu metottaki Topla( maas, mesai); satırı ile “maas” ve “mesai” değişkenlerin içerikleri Topla() metoduna aktarılır ve Topla() metodu işletilir. Burada Topla() metodunu herhangi bir hazırlık yapılmadan direk metodun adı yazılarak işletildiğini fark etmiş olmalısınız. Çünkü bu metodu Form1 adlı sınıf dahilinde hazırladık.
Metotların Geriye Bilgi Göndermeleri
Yukarıda hazırladığımız 2 metot geriye bilgi göndermiyorlardı. Bu nedenle metot adından önce void anahtar kelimesini kullandık. Şimdi yukarıda verilen Topla() metodunda değişiklik yapıp kendisine gönderilen 2 sayının toplanıp sonucun geriye gönderilmesini sağlayacağız. Bu amaçla metot adının önüne yazdığımız void kelimesini silip int yazdık.
int Topla(int sayi1, int sayi2)
{
int sonuc = sayi1 + sayi2;
return sonuc;
}
Metot geriye ne tür bilgi gönderecekse o bilgi tipinin metot adının önüne yazılması gerekmektedir. Bu metot geriye int tipinde bilgi göndereceği için metot adının önüne int yazdık. Metotlarda geriye bilgi gönderme işlemi return deyimi ile yapılmaktadır.
Bu metot kendisine gönderilen 2 bilgiyi toplayıp “sonuc” değişkenine aktardıktan sonra bu değişkenin içeriğini return ile geriye göndermektedir. Topla() adını verdiğimiz metotta bu değişiklik yapıldıktan sonra bu metodun çağrılma şeklinde değişiklik yapılması gerekir.
private void Form1_Click(object sender, EventArgs e)
{
int maas, mesai, yekun;
maas = 1250;
mesai = 125;
yekun = this.Topla(maas, mesai);
}
Konunun iyice anlaşılmasını sağlamak için şimdi başka bir metot hazırlayacağız. Konsol uygulaması dahilinde hazırlayacağız bu metot int tipinde bir bilgiyi parametre olarak vereceğimiz için metot adından sonra parantezlerin arasına “int X” yazdık. Bu metot geriye double tipinde bilgi göndereceği için metot adından önce double yazdık. Bu metodu, dahil ettiğimiz sınıfın örneğini almadan kullanmak istediğimiz için ayrıca static olmasını sağladık.
static double karekok(int X)
{
double kok = Math.Sqrt(X);
return kok;
}
Bu metotta kullanılan Sqrt() metodu Math sınıfında tanımlıdır. Bu nedenle metot adından önce sınıfın adını yazdık. Yukarıda belirtildiği gibi metotlarda geriye değer gönderme işlemi return deyimi ile yapılmaktadır. Bu metodu ve bu metodu çağıran satırları konsol uygulamasına yazdık.
Bu konsol uygulaması derlenip çalıştırıldığında kullanıcıdan karekökü alınacak sayı istenir. Kesirli bir sayının karekökü alınmak istenirse hata meydana gelir. Çünkü bu metodu int tipinde bilgi almak üzere düzenledik.
Bunun önüne geçmek için girilen sayının int tipine dönüştürülmesi veya bu örnekte kullanılan karekok() metodunun geriye double bilgi göndermesi sağlanabilir Diğer yandan eksi bir sayının karekökünü almak mümkün değildir. Bu şekilde düzenlenen uygulama çalıştırılıp eksi bir sayı girildiğinde programın çalışması kırılmaz ama kullanıcının bu konuda bilgilendirilmesi gerekir. Bu amaçla hazırlamış olduğumuz metodu aşağıdaki gibi düzenledik.
static double karekok(double X)
{
double kok;
if (Math.Sign(X) < 1)
{
Console.WriteLine("girdiğiniz sayi negatif");
return 0;
}
else
{
kok = Math.Sqrt(X);
return kok;
}
}
Sayısal bilginin negatif olup olmadığı öğrenilmek istendiği zaman Math sınıfının Sign() metodundan yararlanılmaktadır. Sign() metodu parametre olarak aldığı bilgi negatif ise geriye -1 göndermektedir.
Dizi Değişkenleri Parametre Olarak Kullanmak
Metoda göndermek istediğiniz bilgileri bir dizi değişkene aktarıp bu dizi değişkeni metoda parametre olarak verebilirsiniz. Bu işlemin nasıl yapıldığını basit bir örnek üzerinde anlatacağız. Bu amaçla aşağıda verilen konsol uygulamasında string tipte 5 elemanlı bir dizi değişken tanımlayıp elemanlarına bilgi aktardık.
public static void Main()
{
string[] basket = new string[4];
basket[0] = "Fenerbajçe";
basket[1] = "Efes Pilsen";
basket[2] = "Türk Telekom";
basket[3] = "Karşıyaka";
takim_yaz(basket);
}
static void takim_yaz(string[] takimlar)
{
foreach(string takim in takimlar)
{
Console.WriteLine(takim);
}
}
Metoda dizi değişken aracılığıyla bilgi gönderileceği için parantezin içinde parametre olarak kullanılacak dizi değişkeni tanımlamak gerekir. “takim_yaz” adını verdiğimiz bu metot bu şekli ile dizi değişkenin içeriğini WriteLine() ile ekrana yazacaktır. Metotlara dizi değişkenler parametre olarak verilebildiği gibi metotlar geriye dizi değişken gönderebilir. Bu konuda bilgi vermek için aşağıdaki gibi basit bir metot hazırladık.
private string[] Liste()
{
string[] dizi = new string[3];
dizi[0] = "Fenerbahçe";
dizi[1] = "Galatasaray";
dizi[2] = "Beşiktaş";
return dizi;
}
Geriye string tipte dizi değişken gönderen bu metotta dizi değişken tanımlayıp bilgi aktardık. Bu metodu işletmek için forma ListBox yerleştirip aşağıda verilen kodu yazdık.
private void Form1_Click(object sender, EventArgs e)
{
string[] Takimlar;
Takimlar = this.Liste();
foreach (string takim in Takimlar)
{
listBox1.Items.Add(takim);
}
}
Değer ve Referans Parametreleri
Şimdiye kadar metotlarla ile ilgili olarak verilen örneklere göre int, char, long vs gibi belleğin stack adı verilen kısmında saklanan bilgiler metotlara değer olarak gönderilmektedir. Şimdi bu cümleyi anlaşılır kılmak için bir örnek vereceğiz.
public static void Main()
{
int Sayi = 100;
Console.WriteLine(Sayi);
Procedure1(Sayi);
Console.WriteLine(Sayi);
}
static void Procedure1(int X)
{
X=200;
return;
}
Bu konsol uygulamasında Main() metodu içinde önce “Sayi” adında int tipinde bir değişken tanımladık ve değer aktarıp içeriğini WriteLine() metodu ile ekrana yazdık. Ardından uygulamadaki “Procedure1” adını verdiğimiz metodu işletip “Sayi” değişkenin içeriğini tekrar ekrana yazdırdık.
Bu konsol uygulamasındaki “Procedure1” adını vermiş olduğumuz metot, başlangıçta 100 değerini içeren “X” adlı parametresinin içeriğini 200 olarak değiştirmektedir. Bu şartlarda konsol uygulaması derlenip çalıştırıldığında ekrana 2 kez 100 yazılır.
Bu olaya günlük hayattan karşılık bulmak istersek şöyle bir örnek verebiliriz: Elinizdeki bir evrakın fotokopisini çekip birisine veriyorsunuz. O kişi o kopyada sonradan değişiklik yapıyor. Bu şartlarda evrakın sizdeki kopyası yapılan değişiklikten etkilenmez. Yukarıda verilen örnekte yapılan budur; 100 sayısı metoda gönderiliyor. Metotta bu değer 200 ile değiştiriliyor ancak elinizdeki sayı bundan etkilenmiyor.
Kişiye evrakın fotokopisi yerine aslını vermiş olsaydık durum farklı olurdu. Bazen içeriği metoda gönderilen değişkenin içeriğinin metotta yapılan işlemlerden etkilenmesi istenir. Bu gibi durumlarda parametrenin başına ref deyiminin eklenmesi gerekir. ref deyiminin nasıl kullanıldığını aşağıda görebilirsiniz.
public static void Main()
{
int Sayi = 100;
Console.WriteLine(Sayi);
Procedure1(ref Sayi);
Console.WriteLine(Sayi);
}
static void Procedure1(ref int X)
{
X=200;
return;
}
refanahtar kelimesi sayesinde metotlara parametre ile değer yerine referansı gönderilir. Başına ref yazılan parametrelere referans parametreleri adı verilmektedir. Referans derken “Sayi” değişkenin bellekteki adresinden söz etmekteyiz. Bu şartlarda bu konsol uygulaması derlenip çalıştırıldığında ekrana önce 100 ardından 200 yazılır. Çünkü “Sayi” değişkeni metoda referans olarak gönderildi ve “Procedure1” adını vermiş olduğumuz metotta bu bellek adresinin veya referansın içeriği değiştirildi.
Yukarıda hazırladığımız konsol uygulamasında int tipindeki “Sayi” değişkenine ilk değer vermeden metodu işletmiş olsaydık hata meydana gelirdi. Bu özelliği hatırlatmak için yukarıda verilen konsol uygulamasını aşağıdaki gibi değiştirdik.
public static void Main()
{
int Sayi;
Procedure1(ref Sayi);
Console.WriteLine(Sayi);
}
static void Procedure1(ref int X)
{
X=200;
return;
}
Bu metodu düz mantıkla incelediğinizde hata meydana gelmemesi gerekir diye düşünebilirsiniz. Çünkü referans olarak gönderilen değişkene metotta zaten bilgi aktarılıyor ve bilgi aktarıldıktan sonra bu bellek adresinin içeriği ekrana yazılmaya çalışılıyor. Buna rağmen bu konsol uygulaması çalıştırıldığında hata meydana gelir.
Bu tip hataların önüne geçmek için ref deyiminin yerine out deyimini kullanabilirsiniz. Out deyiminin nasıl kullanıldığını aşağıda görebilirsiniz. Diğer yandan dizi değişkenler zaten referans tipler oldukları için ref deyimini kullanmaya gerek yoktur.
public static void Main()
{
int Sayi;
Procedure1(out Sayi);
Console.WriteLine(Sayi);
}
static void Procedure1(out int X)
{
X=200;
return;
}
Metotları Aşırı Yüklemek
Şimdiye kadar metotlar hakkında verilen bilgilere göre metotlar eksik veya fazla parametre ile işletilmek istendiğinde hata meydana gelmektedir. Bu konuda bilgi vermek için aşağıda verilen konsol uygulamasını hazırladık. Bu örnekte “Procedure1” adını verdiğimiz metot static olduğu için sınıfın örneğini almadan kullanabildik.
class sinif_1
{
public static void Main()
{
int Sayi1 = 100;
int Sayi2 = 200;
int Toplam = Procedure1(Sayi1, Sayi2);
Console.WriteLine(Toplam);
}
static int Procedure1(int X, int Y)
{
return (X+Y);
}
}
Bu konsol uygulamasındaki “Procedure1” adı verilen metot çağırılırken 2 yerine 1 veya 3 parametre gönderilirse hata meydana gelir. Ancak bazen hazırlanan metodun kaç parametreye ile çağrılacağı önceden belli değildir. Örnek olsun diye hazırladığımız bu metot 2 sayıyı toplamaktadır. Ya toplanmak üzere 3 sayı bu metoda gönderilmek istenirse? Bu gibi durumlarda aynı metodun 2. veya 3. kopyası hazırlanır. Her kopyanın parametreleri farklı olur. Aynı ada sahip birden fazla metot hazırlamaya metodun aşırı yüklenmesi(overload) denilmektedir.
static int Procedure1(int X, int Y)
{
return (X + Y);
}
static int Procedure1(int X, int Y, int Z)
{
return (X + Y + Z);
}
Programcı int tipinde 2 sayıyı toplamak istiyorsa metodu 2 parametre ile çağırır. Bu durumda bu metodun 2 parametreli kopyası devreye girer. Metot 3 parametre ile çağrıldığında ise 3 parametreye sahip 2. kopyası işlev görür. Metodun çağrıldığı satırda kullanılan parametre yapısına bakılarak metodun hangi kopyasının kullanacağına karar verilir. Aşağıda verilen uygulama derlenip işletildiğinde metodun 3. parametreye sahip versiyonu işletilir.
Yukarıda hazırladığımız metodun her 2 kopyası da int tipinde bilgiler alıyordu. Ancak bazen hazırladığınız metot ile değişik tipteki bilgileri toplamak isteyebilirsiniz. Nasıl ki aynı metodun değişik sayıda parametreye sahip versiyonlarını hazırlamak mümkün oluyorsa, değişik tipte bilgiler üzerinde işlem yapan kopyalarını hazırlayabilirsiniz. Aşağıda verilen metot hem float hem de int bilgileri toplayabilir.
static int Procedure1(int X, int Y)
{
return (X + Y);
}
static float Procedure1(float X, float Y)
{
return (X + Y);
}
Bu metoda parametre olarak 2 float sayıyı gönderirseniz metodun 2. kopyası işletilir. Yukarıda verilen uygulamanın Main() metodu aşağıdaki gibi düzenlediğinde bu metodun float bilgiler üzerinde işlem yapan kopyası işletilir.
public static void Main()
{
object Toplam = Procedure1(100.25f, 200.75f);
Console.WriteLine(Toplam);
}
Aynı örnekten yola devam edecek olursak: Bazen toplanacak sayıların kaç adet olduğu programın yazımı sırasında belli değildir. Bu durumda her ihtimal için metodun ayrı bir kopyasını hazırlamak gerekir ki bu pratik değildir. Bu gibi durumlarda parametreler dinamik bir diziye yerleştirilir. Çalışma anında dinamik dizinin içeriğine bağlı olarak metot işlev görür. Bu işlemin nasıl yapıldığını anlatmak için yukarıda verdiğimiz konsol uygulamasını aşağıdaki gibi düzenledik. Aşağıda verilen kodu dikkatlice incelerseniz params anahtar kelimesinden yararlandığımı fark edersiniz.
class sinif_1
{
public static void Main()
{
int Toplam = Procedure1(100, 200);
Console.WriteLine(Toplam);
}
static int Procedure1(params int[] X)
{
int T = 0;
foreach(int i in X)
T = T + i;
return T;
}
}
Bu şekilde düzenlenen metot istenilen sayıda parametre ile çağrılıp işletilebilir. Bu metot ile float tipindeki sayısal bilgileri de toplayabilmek istiyorsanız bu metodun aşağıdaki gibi 2. bir kopyasını hazırlamanız gerekir.
static int Procedure1(params int[] X)
{
int T = 0;
foreach( int i in X)
T = T + i;
return T;
}
static float Procedure1(params float[] X)
{
float T = 0;
foreach( float i in X)
T = T + i;
return T;
}
Metotların Kendi Kendilerini Çağırması
C# derleyicisi metotların kendi kendilerini çağırmalarına izin vermektedir. Bu işlemin nasıl yapıldığını anlatmak için aşağıda verilen basit metodu hazırladık. Bu metot kendi kendisini 5 kez çağırarak belirtilen mesajı 5 kez ekrana yazmaktadır.
class Sinif
{
public static void Main()
{
int sayi =5;
procedure1(sayi);
}
static void procedure1(int X)
{
if (X>0)
{
Console.WriteLine("Bu metot {0:X}. kez çağrıldı", 6-X);
X = X - 1;
procedure1(X);
}
return;
}
}
Belli bir şarta bağlı olarak metottan çıkılmadığı zaman metot kendisini sürekli olarak çağıracağı için sorun çıkar. Pratik değeri olmayan bu konsol uygulaması çalıştırıldığı zaman aşağıdaki gibi bir sonuç alınır.
Metotların kendi kendilerini çağırmaya örnek olması için faktöriyel hesabı yapan bir örnek hazırlayacağız. Bu amaçla forma 2 TextBox yerleştirip aşağıda verilen kodu hazırladık. Kullanıcı ilk TextBox’a faktöryelini bulmak istediği sayıyı yazıp bu kodu işletecek.
private void Faktoryel_bul_Click(object sender, EventArgs e)
{
int sayi = Convert.ToInt32(textBox1.Text);
int sonuc = Faktoryel(sayi);
textBox2.Text = sonuc.ToString();
}
int Faktoryel(int i)
{
if (i == 0)
return 1;
else
return (i * Faktoryel(i - 1));
}
Metotlara Nesneleri Parametre Olarak Vermek
Yukarıdaki sayfalarda metotlara int ve string gibi değişkenleri parametre olarak verdik. Ancak metotlar nesneleri parametre olarak alabilmektedir. Bu konuda bilgi vermek için forma 2 ListBox yerleştirip ilk ListBox’ın içeriğini diğerine aktaracak bir metot hazırladık. Bu metot ListBox sınıfının Items koleksiyonunu parametre olarak almaktadır.
private void aktar(ListBox Liste)
{
foreach (string i in Liste.Items)
listBox2.Items.Add(i);
}
Benzer şekilde parametre olarak istediğiniz nesneyi metotlara gönderebilirsiniz. Bu metodu kullanmak için formun Click olayını temsil eden metodu aşağıdaki gibi düzenledik.
private void Form1_Click(object sender, EventArgs e)
{
aktar(listBox1);
}
Şimdi yukarıda yaptığımız işlemin tersini yapıp metodun geriye nesne göndermesini sağlayacağız. Bu amaçla ilk olarak bir dizi değişken tanımlayıp bilgi aktardık. Devamında bu dizi değişkeni Gonder() adı verilen metoda parametre olarak verdik.
private void Form1_Click(object sender, EventArgs e)
{
ListBox List = new ListBox();
string[] Dizi = new string[3];
Dizi[0] = "Fenerbahçe";
Dizi[1] = "Galatasaray";
Dizi[2] = "Beşiktaş";
List = Gonder(Dizi);
foreach (string i in List.Items)
listBox1.Items.Add(i);
}
Gonder() metodu geriye ListBox nesnesi gönderdiği için önceden “List” adında bir ListBox nesnesi hazırladık. Gonder() metodunun geriye gönderdiği ListBox nesnesinin elemanlarını formdaki ListBox’a aktardık. String tipinde dizi değişkeni parametre olarak alıp geriye ListBox nesnesi gönderen metodu aşağıda verdik.
private ListBox Gonder(string[] Diz)
{
ListBox Liste = new ListBox();
int Sayi = Diz.Length;
for (int i = 0; i < Sayi; i++)
{
Liste.Items.Add(Diz[i]);
}
return Liste;
}