Akis Forum

Welcome to AkisForum.com! Register your free account today and become a member! Once signed in, you'll be able to dive into learning to code, discovering new tools, and keeping up with the latest trends. AkisForum is where benefit, knowledge, and sharing come together. Join us to add your own topics and posts, and connect with other members through your private inbox!

C# ile Metotlar (Fonksiyonlar): Kod Tekrarını Azaltma ve Modüler Programlama

  • Konuyu Başlatan Konuyu Başlatan Admin
  • Başlangıç tarihi Başlangıç tarihi

Admin

Herşeyi Burada Bulabilirsin
Yönetici
Administrator
Akisor
C# ile Metotlar (Fonksiyonlar): Kod Tekrarını Azaltma ve Modüler Programlama

Merhaba sevgili C# öğrenicileri,

Program yazarken aynı kod parçacığını birden fazla yerde kullanmak zorunda kaldığımızı fark etmişsinizdir. Ya da karmaşık bir işlemi tek bir büyük blokta toplamak yerine, daha küçük, yönetilebilir parçalara ayırmak isteyebiliriz. İşte tam da bu noktada metotlar (veya diğer programlama dillerinde fonksiyonlar) devreye girer! Metotlar, belirli bir görevi yerine getiren, adlandırılmış kod bloklarıdır.

Metotlar sayesinde kod tekrarını azaltır, programlarımızı daha okunabilir, daha sürdürülebilir ve hata ayıklaması daha kolay hale getiririz. Buna modüler programlama denir.

Hazırsanız, kodumuzu nasıl daha düzenli ve etkili hale getireceğimizi öğrenelim!

-- -- --​

Metot Nedir ve Neden Kullanırız?

Basitçe ifade etmek gerekirse, metotlar bir "iş yapan" kod parçalarıdır.

Neden Kullanırız?

  • Kod Tekrarını Azaltma (Don't Repeat Yourself - DRY): Aynı görevi yapan kodu tekrar tekrar yazmak yerine, bir kez metot olarak tanımlar ve istediğimiz yerde çağırırız.
  • Kod Okunabilirliği ve Anlaşılırlık: Uzun ve karmaşık kod bloklarını küçük, anlamlı metotlara ayırarak programı daha okunur hale getiririz. Her metot kendi içinde belirli bir görevi anlattığı için kodu anlamak kolaylaşır.
  • Modülerlik ve Bakım Kolaylığı: Programı parçalara ayırdığımız için, bir kısımda hata olduğunda sadece o metodu incelememiz yeterli olur. Değişiklik yapmak da çok daha kolaylaşır.
  • Hata Ayıklama (Debugging): Hata ayıklama süreçleri, küçük metotlar üzerinde çalışırken çok daha basittir.

-- -- --​

Metot Yapısı ve Tanımlama

Bir metot temel olarak şu kısımlardan oluşur:

C#:
[Erişim Belirleyici] [Dönüş Tipi] [Metot Adı]([Parametreler])
{
    // Metot gövdesi (yapılacak işlemler)
    // return [dönüş değeri]; (eğer dönüş tipi 'void' değilse)
}

* Erişim Belirleyici: Metoda nereden erişilebileceğini belirler (
Kod:
public
,
Kod:
private
,
Kod:
protected
vb.). Şimdilik genellikle
Kod:
public
veya
Kod:
private
kullanacağız.
* Dönüş Tipi: Metodun işlem sonunda ne tür bir değer döndüreceğini belirtir (
Kod:
int
,
Kod:
string
,
Kod:
bool
vb.). Eğer metot hiçbir değer döndürmeyecekse
Kod:
void
kullanılır.
* Metot Adı: Metodun benzersiz ismidir. Genellikle bir fiil ile başlar ve camelCase yazılır (
Kod:
Hesapla
,
Kod:
BilgiGoster
).
* Parametreler: Metodun dışarıdan alacağı giriş değerleridir. Parantez içine virgülle ayrılarak yazılır. Eğer metot parametre almıyorsa parantezler boş kalır:
Kod:
()
.
* Metot Gövdesi: Metodun yapacağı işi içeren kod bloğudur.

-- -- --​

Metot Türleri ve Örnekleri

Metotları temelde dört ana kategoriye ayırabiliriz:

1. Parametre Almayan, Değer Döndürmeyen Metotlar (void)

En basit metot türüdür. Sadece belirli bir görevi yerine getirir ve herhangi bir sonuç değeri geri vermez.

C#:
public class OrnekSinif
{
    // Ekrana hoş geldiniz mesajı yazdıran metot
    public void HosGeldinMesajiGoster()
    {
        Console.WriteLine("Uygulamamıza Hoş Geldiniz!");
        Console.WriteLine("İyi günler dileriz.");
    }

    public static void Main(string[] args)
    {
        // Metodu çağırmak için önce sınıfın bir nesnesini oluşturmamız gerekir (static olmayan metotlar için)
        OrnekSinif ornek = new OrnekSinif();
        ornek.HosGeldinMesajiGoster(); // Metodu çağır
    }
}

2. Parametre Alan, Değer Döndürmeyen Metotlar (void)

Dışarıdan veri alır, bu verilerle bir işlem yapar ama geriye bir değer döndürmez.

C#:
public class Hesaplayici
{
    // İki sayının toplamını ekrana yazdıran metot
    public void ToplamYazdir(int sayi1, int sayi2)
    {
        int toplam = sayi1 + sayi2;
        Console.WriteLine($"Sayıların toplamı: {toplam}");
    }

    public static void Main(string[] args)
    {
        Hesaplayici hesap = new Hesaplayici();
        hesap.ToplamYazdir(15, 20); // Metodu çağırırken parametreleri gönder
        hesap.ToplamYazdir(5, 7);
    }
}

3. Parametre Almayan, Değer Döndüren Metotlar

Dışarıdan veri almaz ancak bir işlem yapar ve bir sonuç değeri geri döndürür.

C#:
public class BilgiUretici
{
    // Rastgele bir sayı döndüren metot
    public int RastgeleSayiUret()
    {
        Random rnd = new Random();
        int sayi = rnd.Next(1, 101); // 1 ile 100 arasında rastgele bir sayı
        return sayi; // Üretilen sayıyı geri döndür
    }

    public static void Main(string[] args)
    {
        BilgiUretici uretici = new BilgiUretici();
        int uretilenSayi = uretici.RastgeleSayiUret(); // Metodu çağır ve dönen değeri değişkene ata
        Console.WriteLine($"Üretilen rastgele sayı: {uretilenSayi}");

        int baskaSayi = uretici.RastgeleSayiUret();
        Console.WriteLine($"Başka bir sayı: {baskaSayi}");
    }
}

4. Parametre Alan, Değer Döndüren Metotlar

Bu en yaygın ve en güçlü metot türüdür. Dışarıdan veri alır, bu verilerle bir işlem yapar ve bir sonuç değeri geri döndürür.

C#:
public class HesaplayiciGelistirilmis
{
    // İki sayının çarpımını hesaplayıp döndüren metot
    public int CarpimHesapla(int sayi1, int sayi2)
    {
        int carpim = sayi1 * sayi2;
        return carpim;
    }

    // Kullanıcının yaşını hesaplayıp döndüren metot
    public int YasHesapla(int dogumYili)
    {
        int mevcutYil = DateTime.Now.Year;
        int yas = mevcutYil - dogumYili;
        return yas;
    }

    public static void Main(string[] args)
    {
        HesaplayiciGelistirilmis hesap = new HesaplayiciGelistirilmis();

        int sonucCarpim = hesap.CarpimHesapla(8, 6);
        Console.WriteLine($"8 ile 6'nın çarpımı: {sonucCarpim}");

        Console.Write("Doğum yılınızı girin: ");
        int yil = Convert.ToInt32(Console.ReadLine());
        int kullaniciYasi = hesap.YasHesapla(yil);
        Console.WriteLine($"Yaşınız: {kullaniciYasi}");
    }
}

-- -- --​

Static Metotlar ve Main Metodu

Yukarıdaki örneklerde
Kod:
Main
metodu
Kod:
static
olarak tanımlanmıştır.
Kod:
static
metotlar, bir sınıfın nesnesini oluşturmadan doğrudan sınıf adı üzerinden çağrılabilir.
Kod:
Main
metodu programın başlangıç noktası olduğu için
Kod:
static
olmak zorundadır.

Kendi metotlarınızı
Kod:
static
olarak tanımlarsanız, o sınıfın bir nesnesini oluşturmanıza gerek kalmadan direkt çağırabilirsiniz:

C#:
public class StaticOrnek
{
    public static void BilgiMesaji()
    {
        Console.WriteLine("Bu static bir metot. Nesne oluşturmadan çağrılabilir.");
    }

    public static int KaresiniAl(int sayi)
    {
        return sayi * sayi;
    }

    public static void Main(string[] args)
    {
        // Nesne oluşturmadan doğrudan sınıf adıyla çağırıyoruz
        StaticOrnek.BilgiMesaji();

        int kare = StaticOrnek.KaresiniAl(7);
        Console.WriteLine($"7'nin karesi: {kare}");
    }
}

-- -- --​

Metotlara Parametre Geçme Yöntemleri

C#'ta metotlara parametre geçişi farklı şekillerde olabilir:

  • Değer ile Geçme (Pass by Value - Varsayılan): Parametrenin bir kopyası metoda gönderilir. Metot içinde yapılan değişiklikler orijinal değeri etkilemez. (Yukarıdaki örneklerin çoğu bu şekildedir.)
  • Referans ile Geçme (Pass by Reference -
    Kod:
    ref
    anahtar kelimesi):
    Parametrenin bellek adresi gönderilir. Metot içinde yapılan değişiklikler orijinal değeri etkiler.
  • Çıkış Parametresi (Output Parameter -
    Kod:
    out
    anahtar kelimesi):
    Metodun birden fazla değer döndürmesi gerektiğinde kullanılır.
    Kod:
    ref
    gibi çalışır ama parametrenin metot çağrılmadan önce başlatılmasına gerek yoktur.

C#:
public class ParametreOrnek
{
    // Değer ile geçme (sayı1 ve sayı2'nin kopyası gönderilir)
    public void DegerArtir(int sayi)
    {
        sayi += 10;
        Console.WriteLine($"Metot içinde sayı: {sayi}"); // Yeni değer
    }

    // Referans ile geçme (orijinal 'gelenSayi' değişkeni etkilenir)
    public void ReferansIleArtir(ref int sayi)
    {
        sayi += 10;
        Console.WriteLine($"Metot içinde sayı (ref): {sayi}"); // Yeni değer
    }

    // Çıkış parametresi (birden fazla değer döndürme)
    public void HesaplaVeDondur(int a, int b, out int toplam, out int fark)
    {
        toplam = a + b;
        fark = a - b;
    }

    public static void Main(string[] args)
    {
        ParametreOrnek po = new ParametreOrnek();

        int x = 5;
        po.DegerArtir(x);
        Console.WriteLine($"Metot sonrası x (değer ile): {x}"); // Hala 5

        int y = 10;
        po.ReferansIleArtir(ref y); // ref anahtar kelimesini hem tanımlarken hem çağırırken kullanırız
        Console.WriteLine($"Metot sonrası y (referans ile): {y}"); // Artık 20

        int toplamaSonucu;
        int farkSonucu;
        po.HesaplaVeDondur(20, 5, out toplamaSonucu, out farkSonucu); // out ile çağırma
        Console.WriteLine($"Toplam: {toplamaSonucu}, Fark: {farkSonucu}");
    }
}

---

Metotlar, bir C# programcısının en temel ve güçlü araçlarından biridir. Kodunuzu bölümlere ayırmak, her bölümün belirli bir işi yapmasını sağlamak ve bu bölümleri programınızın farklı yerlerinde tekrar tekrar kullanmak, yazılım geliştirme sürecinizi çok daha verimli hale getirecektir.

Bu konuda sormak istediğiniz veya eklemek istediğiniz başka bir şey var mı?

İyi kodlamalar!
 
Geri
Üst