Metodlar, parametreler ve overloading nasıl çalışır?

Question

IT Interview Practice · Accepted Answer

**Metodlar** bir sınıfta tanımlanan fonksiyonlardır. C# zengin parametre özelliklerini destekler — isteğe bağlı/adlandırılmış argümanlar, `ref`/`out`/`in` değiştiricileri, `params` dizileri — ve **metod overloading**'i (aynı ada sahip ancak farklı parametrelere sahip birden fazla metod).

## Metodları tanımlama

```csharp
public int Add(int a, int b) => a + b;          // expression-bodied (concise)

public string Greet(string name, string greeting = "Hello")   // default parameter
{
    return $"{greeting}, {name}";
}
Greet("Ann");                       // "Hello, Ann"
Greet("Ann", greeting: "Hi");        // named argument
```

Metodlar dönüş tipi, ad ve parametreleri belirtir. **Varsayılan parametreler** argümanları isteğe bağlı yapar ve **adlandırılmış argümanlar** ada göre geçişe izin verir (daha net, isteğe bağlı olanları atlayabilirsiniz).

## Parametre değiştiricileri: ref, out, in

```csharp
// ref — pass by reference (method can modify the caller's variable)
void Increment(ref int x) { x++; }
int n = 5; Increment(ref n);   // n is now 6

// out — for returning multiple values (must be assigned in the method)
bool TryParse(string s, out int result) { result = ...; return true; }
if (int.TryParse("42", out int value)) { }   // the common TryX pattern

// in — pass by reference but READ-ONLY (performance for large structs)
void Process(in LargeStruct data) { }
```

`out` geniş bir şekilde **TryParse düzeninde** kullanılır (başarı bayrağı artı sonucu güvenli bir şekilde döndürmek); `ref` arayan kişinin değişkenini değiştirmeyi sağlar; `in` büyük yapıları kopyalamadan etkili bir şekilde aktarır.

## params ve overloading

```csharp
// params — variable number of arguments
int Sum(params int[] numbers) => numbers.Sum();
Sum(1, 2, 3, 4);    // any number

// OVERLOADING — same name, different parameters
void Print(int x) { }
void Print(string s) { }
void Print(int x, int y) { }
Print(5);           // calls the int version — resolved by argument types
```

**Overloading** birden fazla metodu aynı ada paylaştırmanıza izin verir, parametre tipleri/sayısı ile ayırt edilirler — derleyici eşleşen olanı seçer. `params` değişken sayıda argüman kabul eder.

## Neden önemli

Metodlar C#'da davranışın temel yapı taşlarıdır ve zengin parametre özelliklerini anlamak, esnek ve ifadeli kod yazmak için önemlidir.

Metodları nasıl tanımlayacağınızı (kısa expression-bodied sözdizimi dahil), **varsayılan ve adlandırılmış parametreleri** nasıl kullanacağınızı (isteğe bağlı argümanlar ve okunabilir çağrılar için) ve **metod overloading**'i nasıl uygulayacağınızı (aynı ad, farklı parametreler — farklı argüman türlerini işleyen sezgisel API'ler için) anlamak günlük bilgidir.

**Parametre değiştiricileri** özellikle anlaşılması önemlidir: **`out`** yaygın olarak kullanılan **TryParse düzeninde** kullanılır (`int.TryParse(s, out var result)` — başarı bayrağı ve sonucu güvenli bir şekilde istisnalar olmadan döndürmek, yaygın, idiyomatik bir C# desenidir), **`ref`** arayan kişinin değişkenini değiştirmeyi sağlar ve **`in`** büyük yapıları performans için referans yoluyla aktarır.

Bunları anlamak — metodlar, parametre özellikleri (isteğe bağlı/adlandırılmış/params), esnek API'ler için overloading ve ref/out/in değiştiricileri (özellikle out tabanlı TryParse deyimi) — C# metodları yazma ve bu özelliklerle ilişkili birçok .NET API'sini kullanma için temeldir.

Metodlar ve parametreleri tüm C# kodunun merkezinde olduğundan ve overloading, isteğe bağlı parametreler ve TryX deseni gibi özellikler sürekli göründüğünden, bunlara hakim olmak etkili C# geliştirme için temel, zorunlu bilgidir.

Metodları tanımlama

Parametre değiştiricileri: ref, out, in

params ve overloading

Neden önemli

İlgili sorular