Herkese merhabaa. 😊 Bu yazıda modüler programlamaya giriş yapacağım. Modüler programlama; bir bütünün elemanlarının birbirlerinden bağımsız çalışması olarak açıklanabilir. Modüler programlamanın en küçük parçasıdır. Bizi kod tekrarından kurtararak programın daha hızlı çalışmasına yardımcı olur. C# içerisinde birçok gömülü metot olduğu gibi kendi metotlarımızı da yazabiliriz. Lafı daha fazla uzatmadan metotlara giriş yapalım.

Metotlara Giriş

Metotların modüler programlamanın en küçük parçası olduğunu söylemiştim. Programımızı metotlar ile parçalara ayırarak daha basit bir yapı oluşturabiliriz. Metot kullanmanın avantajları;

  • Tekrar kullanılabilir kod,
  • Kolay test edilebilirlik,
  • Metotta yapılan değişiklikler programı baştan sona etkilemez,
  • Farklı değişkenleri girdi olarak verebiliriz.

Metodu sadece bir işi yapacak şekilde tasarlamalıyız. Bu şekilde tasarlanan bir metot en fazla 15 satırdan oluşmalı. Ayrıca metot içerisine metot yazılmaz, sadece başka bir metodu çağırabiliriz.

Metot Tanımlama

Metodu kullanmak için önce tanımlamak sonra çağırmak gerekiyor. Metotlara giriş yapmadan önce nasıl tanımlandığını bir formülle belirteyim.

erişim belirleyici + niteleyici + geri dönüş tipi + metodun adı + parametre

Erişim Belirleyici: public, private, internal, protected ve protected internal. Bunlardan birisini kullanarak metoda nasıl erişim sağlanacağını belirtiyoruz. Erişim belirleyicileri başka bir yazıda detaylı olarak anlatacağım. Bu yazıda erişim belirleyici olarak public kullanacağım.

Niteleyici: static, abstract, virtual ve sealed. Bunları da ayrı bir yazıda detaylı olarak anlatacağım.

Geri Dönüş Tipi: Metodun geri dönüş tipi için bildiğimiz bütün tiplerini kullanabiliriz. var değişken tipi geri dönüş tipi olarak kullanılamaz ama dynamic olabilir. Metodun her zaman bir değer geri döndürmesi gerekmez.

Metodun Adı: Metoda isim verirken yapacağı işi niteleyen bir isim konmalı. İsim koyarken PascalCase isimlendirme tekniği tercih ediliyor.

Parametre: Metodun çalışması için illa parametre almasına gerek yok. Bütün tipler ya da kendi tiplerimiz parametre olarak kullanılabilir. (Kendi tiplerimizi de daha sonrasında yazmayı göreceğiz. 😅)

Metot Yazımı

Örnek bir metot ile konumuza devam edelim. Aslında Programlamaya giriş yaptığımızdan beri bütün kodlarımızı bir metodun içerisine yazıyoruz. Main metodu programın ilk başlayan metodudur. Mobil uygulama, web sitesi, masaüstü uygulaması kısaca C# kullanarak yazacağınız pek çok uygulamanın mutlaka bir main metodu olacaktır. Main metodunun içerisine kendi çalıştırmak istediğiniz metotları yazabilirsiniz. Ufak bir örnek ile metotlara giriş yapalım.

static void Main(string[] args)
{
    HelloWorld();
    Console.ReadKey();
}

public static void HelloWorld()
{
    Console.WriteLine("Merhaba Dünya!");
}

Örneğimizde ekrana Merhaba Dünya yazdıran bir metot oluşturduk. Metot yazımı aslında bu kadar kolay. Örneklerimizi biraz daha arttırmak için Toplama işleminin metodunu yazalım.

public static void Toplama()
{
    int a = 5;
    int b = 9;

    int sum = a + b;

    Console.WriteLine(sum);
}

Örneğimizde Toplama isminde parametresiz bir metot oluşturduk. Main içerisinde bu metodu çağırdığımızda ekrana 5 ve 9 rakamlarının toplamı olan 14 yazacaktır. Bu metodun parametre alan bir versiyonunu da yazalım.

static void Main(string[] args)
{
    Console.WriteLine("Toplama işlemi için iki sayı giriniz:");
    int a = 0, b = 0;
    a = int.Parse(Console.ReadLine());
    b = int.Parse(Console.ReadLine());
    Toplama(a, b);
    Console.ReadKey();
}
public static void Toplama(int a, int b)
{
    int sum = a + b;
    Console.WriteLine("Toplam {0}",sum);
}

Paremetreli Metot Ornegi

Geriye Dönüş Tipine Göre Metotlar

Metotlar aynı zamanda geriye dönüş değerine göre de ayrılırlar. Geriye değer döndürmeyen metotlar aslında bu zamana kadar yazdığımız void metotlardan oluşuyor. Metot içerisinde yapılan işlem son işlemse ve geriye bir şey döndürmeye gerek kalmıyorsa genellikle geriye değer döndürmeyen metotlar tercih ediliyor.

Geriye dönüş tipini içeride yapacağımız işleme bağlı olarak seçebiliriz. C# içerisinde bulunan bütün tipleri ve kendi tiplerimizi geri dönüş tipi olarak kullanabiliriz. var keyword’ü hem geri dönüş tipi hem de parametre olarak kullanılamaz. Çünkü var değişken tipi tür belirtmeden değişken oluşturabilmemizi sağlar. Kendi başına bir tür belirtmez. Genel kapsayıcı bir geri dönüş tipi istiyorsak object kullanabiliriz. Çünkü C# içerisinde yer alan her şey objectten türer. Kullanıcıdan ismini alan ve geriye merhaba + kullanıcı adı döndüren basit bir metot yazalım.

public static string HelloUser(string user)
{
    string message = "Merhaba " + user + "!";
    return message;
    //return "Merhaba " + user + "!"; //Tek satırda bu şekilde geriye değer döndürebiliriz.
}

Metotlara giriş için basit bir hesap makinesi tasarlayalım. Hesap makinesinde toplama, çıkarma, bölme ve çarpma işlemleri için ayrı ayrı metotlar oluşturalım.

public static int Addition(int a, int b)
{
    return a + b;
}

public static int Subtraction(int a, int b)
{
    return a - b;
} 

public static int Multiplication(int a, int b)
{
    return a * b;
}

public static double Division(int a, int b)
{
    return a / b;
}

static void Main(string[] args)
{
    Console.WriteLine("Yapmak istediğiniz işlemi seçiniz :)");
    Console.WriteLine("1 Toplama");
    Console.WriteLine("2 Çıkarma");
    Console.WriteLine("3 Çarpma");
    Console.WriteLine("4 Bölme");
    short secim = short.Parse(Console.ReadLine());
    switch (secim)
    {
        case 1:
            Console.Write("İlk sayı: ");
            int tsayi1 = int.Parse(Console.ReadLine());
            Console.Write("İkinci sayı: ");
            int tsayi2 = int.Parse(Console.ReadLine());
            int toplama = Addition(tsayi1, tsayi2);
            Console.WriteLine("Sonuç: {0}", toplama);
            break;
        case 2:
            Console.Write("İlk sayı: ");
            int csayi1 = int.Parse(Console.ReadLine());
            Console.Write("İkinci sayı: ");
            int csayi2 = int.Parse(Console.ReadLine());
            int cikarma = Subtraction(csayi1, csayi2);
            Console.WriteLine("Sonuç: {0}", cikarma);
            break;
        case 3:
            Console.Write("İlk sayı: ");
            int cpsayi1 = int.Parse(Console.ReadLine());
            Console.Write("İkinci sayı: ");
            int cpsayi2 = int.Parse(Console.ReadLine());
            int carpim = Multiplication(cpsayi1, cpsayi2);
            Console.WriteLine("Sonuç: {0}", carpim);
            break;
        case 4:
            Console.Write("İlk sayı: ");
            int bsayi1 = int.Parse(Console.ReadLine());
            Console.Write("İkinci sayı: ");
            int bsayi2 = int.Parse(Console.ReadLine());
            double bolme = 0;
            if (bsayi2 > 0)
            {
                bolme = Division(bsayi1, bsayi2);

            }
            Console.WriteLine("Sonuç: {0}", bolme);
            break;
        default:
            Console.WriteLine("Yanlış tuşa bastınız :(");
            break;
    }
    Console.ReadKey();
}

Bu hesap makinesi örneğini biraz daha geliştirerek kullanabilirsiniz. Do While döngüsü kullanarak program kapanmadan sürekli bir döngü halinde çalıştırabilir, yüzde, üs alma ve karekök alma gibi detaylı fonksiyonları yazabilirsiniz. Detaylı fonksiyonlar için blogumun reposuna bakabilirsiniz. 😊

Metotlara Giriş: Params Keyword

Metotlara istediğimiz kadar parametre yazabiliriz. Ancak genellikle 3’ten fazla parametre olması çok tercih edilen bir durum değil. Burada da imdadımıza params keyword’ü yetişiyor. Kaç adet parametre geleceği belli olmayan durumlarda tercih ediliyor. Params, metoda eklenen parametreleri metot içerisinde dizi olarak kullanmamızı sağlar. Bu da argüman olarak dizi yollamaya gerek kalmıyor demek. Params arka planda dinamik bir dizi oluşturur.

Eğer metodun içerisinde params haricinde parametre kullanılacaksa params en sona yazılır. Bunun nedeni params’tan sonra gelecek olan değer params’a ait mi değil mi derleyici bunu anlayamaz. Şimdi ufak bir örnek ile params’a bakalım.

public static int Sum(params int[] number)
{
    int a = 0;

    for (int i = 0; i < number.Length; i++)
    {
        a += number[i];
    }

    return a;
}

static void Main(string[] args)
{
    int toplam = Sum(12, 36, 32, 8, 7, 3);
    Console.WriteLine("Toplam {0}", toplam);

    Console.ReadKey();
}

Params keyword’ünü kullanarak kendi ekrana yaz metodunuzu yazabilirsiniz. Console.Writeline metodu da params kullanılarak yazılmıştır. 😊

Opsiyonel ve İsimlendirilmiş Parametreler

Opsiyonel parametreler metot argümanı olarak default değer atanan parametrelerdir. Metodu her çağırışımızda bazı değerleri vermeye gerek duymuyorsak bu yöntem kullanılabilir. Dışarıdan bu değeri çağırdığımızda değiştirilebilir. Opsiyonel parametre sona konulmalıdır.

public static int Power(int num, int pow = 1)
{
    int result = 1;

    for (int i = 0; i < pow; i++)
    {
        result *= num;
    }

    return result;
}


static void Main(string[] args)
{
    int us = Pow(12);
    Console.WriteLine("Sonuç {0}", us);

    Console.ReadKey();
}

Bu şekilde çalıştırırsak ekrana 12 değerini verdiğini görürüz.

İsimlendirilmiş parametreler metot çağırılırken parametrelerini : nokta ile belirten kullanımdır. Verilen paremetre isimlerine göre değer verilir. İsimlendirme bir kere yapıldıysa devamının öyle olmasına gerek yok. Ancak daha doğru bir kullanım için hepsini isimlendirerek tanımlamak iyi olur.


public static int Carpim(int num1, int num2)
{
    return num1 * num2;
}

static void Main(string[] args)
{
    int carpim = Carpim(num1: 12, num2: 3);
    Console.WriteLine("Sonuç {0}", carpim);

    Console.ReadKey();
}

Metotlara giriş konusu bu kadar. Modüler programlamanın yapı taşlarından birisi olduğu için kodlarımızda metotlara bolca yer vermeliyiz. Programda sık yaptığımız bir işlemi metot olarak tanımlayarak perfomansı daha hızlandırabiliriz. Bir sonraki yazıya kadar kendinize iyi bakın. 😊

Görüntülenme Sayısı: 579