C# Yöntemler ve Alanlar - I
Yöntemler ve Alanlar - I
.net Framework içerisinde mevcut olmayan bir yönteme ihtiyaç duyduğumuz zamanlar olur. Kendi ihtiyacımız doğrultusunda özel bir yöntem hazırlamamız gerekir.
Mesela, dik üçgende hipotenüz hesabı yapan bir yöntem .net Framework içerisinde mevcut değildir. Biz pisagor teoremi ile hipotenüsün nasıl hesaplanacağını biliriz. Bunun için bir program yazmamız gerekiyor. Kısa kenarların her birinin kareleri toplamının karekökünü alırsak bu bize hipotenüs uzunluğunu verir.
Karekök hesabı yapabilen ve herhangi bir sayının karesini hesaplayabilen yöntemler System.Math sınıfı içerisinde mevcuttur. Program aşağıdaki şekildedir.
// -----------------------------------------------------------------
// Hipotenus projesinin kaynak kod dosyası Hipotenus.cs
// -----------------------------------------------------------------
using System;
class Hipotenus
{
static void Main()
{
Console.Write("Birinci kenarı giriniz: ");
double dKenar1 = Double.Parse(Console.ReadLine());
Console.Write("İkinci kenarı giriniz: ");
double dKenar2 = Double.Parse(Console.ReadLine());
double dSonuc = Math.Sqrt(Math.Pow(dKenar1, 2) + Math.Pow(dKenar2, 2));
Console.WriteLine("Hipotenüs: {0}", dSonuc);
Console.ReadLine();
}
}
Eğer programımız birkaç tane hipotenüs hesabı yapacaksa kopyala yapıştır işlemleriyle bu ifadeyi çoğaltabiliriz. Ama bu etkin bir yol değildir. Üçgenin hipotenüsünü bulurken kısa kenarlar yerine taban ve yükseklik bilgilerini kullanmamız gerekirse hesap yapan ifadelerin tamamını değiştirmek gerekir. Bu çözüm hiç de esnek bir çözüm olmaz. Bir de ileride daha etkin bir hesaplama yolu bulduğumuzu düşünürsek o zaman kopyala yapıştır yaparak çoğalttığımız hesaplama satırları içinden çıkılmaz bir hal alır.
Aslında Hipotenus.cs programını daha etkin bir şekilde yapmak da mümkündür. Mesela
Math.Pow(dKenar1, 2)
şeklinde Math sınıfının Pow yöntemini kullanmak yerine
dKenar * dKenar
yazarsak daha az bellek ve işlemci gücü kullanmış oluruz.
Dışarıdan baktığımızda bu iki hesaplama şekli aynı gibi görünüyor. Ama Math sınıfı ve onun double türündeki her sayının istenilen kuvvetini alabilen Pow yöntemine göre çarpma işlemi yapmak daha az işlemci ve bellek kullanımı sağlayarak daha etkin bir yol sunar. Pow yönteminde genelleştirilmiş bir kuvvet alma algoritması kullanılmaktadır, oysa çarpma işlemi çok basittir ve kullanacağı bellek bölgesi çok küçüktür.
Program kodu yazmaktan zevk alan bir programcı iseniz bile kopyala yapıştır yapmak yerine daha az kod kullanarak aynı işi yapmanın yolunu aramanız gerekiyor. Genellikle daha az kod daha az hata demektir.
Defalarca hipotenüs hesabı yapacaksanız, bunu özel bir yöntem yazarak yapmak güzel bir yoldur.
Yöntem Yöntem, küçük bir algoritmik mekanizmadır, işlenmemiş materyalleri içine gönderip ürün olarak geriye aldığımız bir fabrika gibi düşünebilirsiniz. Eğer bir yöntem yeteri kadar iyi tasarlanmış ve programlanmışsa, yöntemi kapalı bir kutu olarak görebiliriz. Yöntem doğru sonuçlar ürettiği ve anlamsız hatalar vermediği sürece hiç kimse nasıl tasarlandığı ve içerisindeki mekanizmanın nasıl işlediği ile ilgilenmez.
Bir yöntem oluşturulurken izlenecek iki önemli aşama vardır. Bu aşamalardan en önemlisi yöntemin algoritmasını tasarlamak ve yapacağı işi gerçekleştirmektir ama daha önce karar verilmesi gereken diğer aşama ise yöntemin ara yüzüdür. Yöntemin ara yüzünü tasarlama işlemi, yöntemin içine neler gireceğini ve sonuçta dışarıya ne çıkacağını tanımlama işlemidir.
Daha önce incelediğimiz yöntemlerde dikkat etti iseniz bir yönteme birden çok argüman girer ama geriye sadece bir tek şey döner, o da yöntemin dönen değeri olarak adlandırılır.
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
Bir yöntemin birden çok parametresi olabilir, hiç parametresi olmayan yöntem de olabilir. Ama muhakkak bir değer dönmesi gerekir. Eğer hiç değer dönmeyecekse, dönen değer olarak hiç değer dönmeyecek anlamına gelen void yazılır.
Hipotenus yöntemi için giren ve çıkan değerler oldukça basittir. Yöntem üçgenin iki kenarını parametre olarak alacak ve yöntemden geriye hipotenus değeri dönecektir.
Math.Pow yöntemini aşağıdaki gibi çağırabiliriz.
double dSonuc = System.Math.Pow(dTaban, dUs);
>
Eğer using direktifiyle System isim uzayı programa dahil edilmişse, Pow yöntemini aşağıdaki şekilde çağırabiliriz.
double
dSonuc = Math.Pow(dTaban, dUs); Kendi yazdığımız Hipotenus yöntemini de aşağıdaki şekilde çağırırız.
double dHipotenus = Hipotenus(dKenar1, dKenar2);
Birden çok yönteme sahip olan, belki de birkaç tane ayrı sınıftan oluşan bir program yazdığımızı varsayalım. Hipotenus yöntemini birçok farklı yere yerleştirebiliriz. Şimdi bunlara farklı sürümler diyelim. Yöntemimizin ilk sürümü Main yöntemi ile aynı sınıfın içinde olacak ve ayrı bir sınıf ile isim uzayına ihtiyaç duymayacaktır.
Aşağıda tipik bir sınıf tanımlaması var.
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
class BenimSinif
{
static void Main()
{
// Main isimli yöntemin gövdesi
}
}
Eğer bu sınıfın içine başka bir yöntem eklemek istiyorsak sınıfı başlatan ve bitiren küme parantezlerinin arasına eklemeliyiz, Main yöntemini başlatan ve bitiren küme parantezlerinin arasına değil. Yeni yöntemin eklenebileceği yer olarak iki seçeneğimiz var. Bu seçenekler aşağıda gösterilmiştir.
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
class BenimSinif
{
// Yeni yöntem buraya eklenebilir
static void Main()
{
// Main isimli yöntemin gövdesi
}
// Yeni yöntem buraya eklenebilir
}
Bir yöntem, sınıf ile aynı isme sahip olamaz. (Aslında olabilir. Ama o zaman özel bir yöntem türü olur. Bu özel yöntemi başka bir yazıda anlatacağız.)
C#, yeni yöntemin Main yönteminden önce ya da sonra tanımlanmasıyla ilgilenmez. Ama Main yöntemini en başta ya da en sonda yazmış olmamız bizim programlamaya yaklaşımımızı ortaya koyar.
Bazı programcılar önce daha temel işlemleri yapan yöntemleri yazarlar. Daha sonra onlarla bağlantılı olan diğerlerini ve en sonunda hepsini kullanacak olan Main yöntemini. Buna tabandan tavana programlama ya da tümevaran programlama diyebilirsiniz. Bu yöntem daha çok pascal programlama dili ile ilişkilidir. Çünkü pascal dilinde bir yöntem ya da fonksiyon tanımlanmadan kullanılamaz, doğal olarak da en son ana program vardır.
Bazı programcılar ise önce Main yöntemini yazarlar ve daha sonra sırasıyla diğerlerini. Buna da tavandan tabana programlama ya da tümdengelen programlama diyebilirsiniz. Bu sanki C geleneğinden gelen dillere daha yakın gibi görünüyor. Biz de bundan sonraki yazacağımız programlarda bu biçimi kullanacağız.
Şimdi Hipotenus yöntemini tanımlayalım. Yöntemi Main yöntemindeki gibi static anahtar kelimesiyle tanımlamaya başlarız.
static
Daha sonra yöntemden geri dönen değerin tipini yazarız. Aşağıdaki örnekte Hipotenus yönteminden geriye double tipinde bir değer döner.
static double
Yönteme bir isim veririz. Yöntem isminden sonra parantez açarız.
static double Hipotenus(
Hipotenus yöntemi de aynı Main yöntemi gibi tanımlandı. Main yönteminden geriye bir değer dönmez, bu yüzden dönüş tipi void olarak tanımlandı. Aynı zamanda Main yönteminde parantezlerin içinde hiçbir şey kullanmayız. Çünkü dışardan aldığı bir değer yok.
Aslında Main yöntemine de dışardan değer gelebilir ama bu çok özel bir durumdur. Bu özel durumu başka bir yazıda anlatacağız. Visual Studio 2005 ile bir konsol projesi oluşturduğumuz zaman otomatik oluşan Main yönteminin parantezleri arasında bir takım değerler yazılı olur. Biz şu anda ilgilenmiyoruz. Bizim şu anda yaptığımız gibi hiçbir şey yazmazsak da olur.
Biz Hipotenus yöntemine iki tane argüman geçmek istiyoruz.
Parametre ve argüman kelimeleri birbirinin yerine kullanılıyor gibi olsalar da aralarında bir nüans var. Bizim açımızdan yönteme gönderdiğimiz değerler argümadır, biz yönteme argüman geçeriz. Yöntem açısından bakıldığında ise bu değerler parametredir, yöntem dışardan parametre alır.
Hipotenus yöntemine geçeceğimiz ilk parametre, d1’dir. Açtığımız parantezin içine ilk olarak bu parametrenin tipini ve adını yazarız.
static double Hipotenus(double d1
Hipotenus yöntemine geçeceğimiz ikinci parametre, d2’dir. Aralarına virgül koyarak ayırırız. Parametrelerimiz bittiğine göre parantezi kapatırız.
static double Hipotenus(double d1, double d2)
Şimdi Main yöntemindeki gibi yöntemin gövde kısmını oluşturmak için bir çift küme parantezi eklememiz gerekiyor.
static double Hipotenus(double d1, double d2)
{
//Yöntemin gövdesi buraya gelecek.
}
Yöntemlerde kullanacağımız değişkenler daha çok kendi içlerinde tanımlanır. Bu sebeple dSonuc olarak adlandırdığımız üçgenin hipotenüs uzunluğunu tutacağımız değişkeni tanımlamak istiyoruz. dSonuc’un hesaplanması dışardan aldığı iki parametre kullanılarak gerçekleştirilir.
static double Hipotenus(double d1, double d2)
{
double dSonuc = Math.Sqrt(d1 * d1 + d2 * d2);
return dSonuc;
//Yöntem gövdesinin kalan kısmı buraya gelecek.
}
dSonuc isminde double türünde bir değişken tanımladık ve yaptığımız işlemin sonucunu bu değişkende tutuyoruz. Bu iki ifadeyi aslında birlikte yazabiliriz. Atama ve ilk değer işlemlerini birlikte yapabilmeyi daha önce atama işlemleri yazısında örneklerle açıklamıştık. Şimdi bu işlemi yapalım.
Bu arada dönen değer kavramını biraz açalım. Yazının başlarında da söz ettiğimiz dönen değer kavramını hatırlayalım. Yöntemi tanımlarken zaten ilk olarak yöntemin dış dünyaya göndereceği dönen değerin tipini tanımlamıştık. Bu dönecek olan değer yöntem içerisinde return anahtar kelimesi ile belirtilir.
return ifadesi aynı zamanda yöntemin çalışmasını sona erdirir. Bu yüzden return kelimesini yöntemin son ifadesi olarak kullanırız. Bununla beraber daha karmaşık durumlarda yöntem çoklu return ifadesine sahip olabilir.
Aşağıda Hipotenus yönteminin tamamı ve Main yöntemi içinde kullanılmış şekli gösterilmiştir.
// -----------------------------------------------------------------
// HipotenusHesaplama projesinin kaynak kod dosyası HipotenusHesaplama.cs
// -----------------------------------------------------------------
using System;
class HipotenusHesaplama
{
static void Main()
{
Console.Write("Birinci kenarı giriniz: ");
double dKenar1 = Double.Parse(Console.ReadLine());
Console.Write("İkinci kenarı giriniz: ");
double dKenar2 = Double.Parse(Console.ReadLine());
double dHipotenus = Hipotenus(dKenar1, dKenar2);
Console.WriteLine("Hipotenüs uzunluğu " + dHipotenus);
Console.ReadLine();
}
static double Hipotenus(double d1, double d2)
{
double dSonuc = Math.Sqrt(d1 * d1 + d2 * d2);
return dSonuc;
}
}
Sınıf bildirimine, iki ayrı yöntemin tanımlanmasına ve programın yapısında tanımlanan küme parantezlerinin nasıl kullanıldığına dikkat edelim. Her iki yöntem de aynı sınıfın içinde yer alıyor. Bunun için sınıfın başlangıcını ve bitişini belirten küme parantezlerinin arasında bulunuyor. Her ikisi de kendi gövdelerini başlatan ve bitiren küme parantezlerine sahip.
Bir yöntemi kullanırken önce onun ait olduğu isim uzayını ve o isim uzayında yöntemi barındıran sınıfın ismini yazarız. Eğer programın başında isim uzayı deklarasyonu yapılmışsa o zaman sadece sınıf adı ile birlikte yazarız. Bizim Hipotenus ve Main yöntemlerimizde olduğu gibi her ikisi de aynı sınıfın içerisinde ise sadece yöntemin adını kullanarak çağırabiliriz.
Hipotenus, Main ile aynı sınıfın içinde olduğu için, Main içinde sadece yöntemin adını (Hipotenus) kullanılarak kolayca çağırdık.
double dHipotenus = Hipotenus(dKenar1, dKenar2);
İsterseniz Hipotenus isimli yöntemi sınıf ismini kullanarak da çağırabilirsiniz.
double dHipotenus = HipotenusHesabi.Hipotenus(dKenar1, dKenar2);
Şimdi adım adım programın çalışmasını inceleyelim.
dHipotenus değişkeninin değer ataması işlemine kadar her şey normal işler. dHipotenus değişkenine ilk değer ataması yapılırken Hipotenus isimli yöntem çağrılır. Bunu yaparken de Hipotenus yöntemine dKenar1 ve dKenar2 adlı iki argüman geçilir.
Bu noktada, artık programın işleyişi Hipotenus yöntemine geçer. Hipotenus yöntemine dışarıdan gelen dKenar1 ve dKenar2 değişkenlerini d1 ve d2 parametreleri karşılar. Yani dKenar1 ve dKenar2’nin değerleri artık d1 ve d2 parametrelerine aktarılmıştır. Hipotenus yöntemi gerekli işlemi yapar.
return ifadesi Hipotenus yönteminin işleyişini durdurur. Main yöntemine işlemin sonucu return ifadesi vasıtasıyla gönderilir ve programın işleyişi Main yöntemine geçer. dHipotenus değişkeni de Hipotenus yönteminden dönen değeri karşılar, artık işlemin sonucu dHipotenus değişkeninde tutulmaktadır.
Anlatılanları daha iyi kavramak için aşağıdaki şekil yardımcı olacaktır.
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.