Function parameters

Önceki bölümde, fonksiyonlara bir göz attık. Parametreleri kısaca tartıştık, ancak kısaca. Parametreler oldukça basit ve kullanımı kolay olsa da, onları daha güçlü hale getirebileceğimiz püf noktaları vardır

İlk olarak inceleyeceğimiz şey: out ve ref değiştiricileridir. C# (ve diğer dillerde) iki parametre arasında farklı davranır: (out) "değere göre" ve (ref)"referansa göre". C# 'taki varsayılan değer "değere göre" dir. Bu, temel olarak bir işlev çağrısına bir değişken ilettiğinizde, aslında bir başvuru yerine nesnenin bir kopyasını (yani sadece değerini) gönderdiğiniz anlamına gelir. Bu ayrıca, fonksiyon içinde parametrede değişiklikler yaptığınızda; bu değişikliklerin parametre olarak geçirdiğiniz orijinal nesneyi etkilemeyeceği anlamına gelmektedir.

Bu temel davranışı 'ref' ve 'out' anahtar kelimeleri ile değiştirebiliriz, yani nesneye değeri yerine referansı göndeririz. Yazının devamında bulunan örnekte bu durum gayet iyi anlaşılacaktır.

'ref' Anahtar Kelimesi

Aşağıdaki örneği inceleyelim.

static void Main(string[] args)
{
    int number = 20;
    AddFive(number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(int number)
{
    number = number + 5;
}

Main sınıfı içinde 'integer'(tam sayı) tipinde number isimli bir değişken tanımladık. Ve bu tanımladığımız değişkene 20 değerini atadık. Ve daha sonra Addfive metodunu çağırırken parametre olarak gönderdik. Statik AddFive metodu içinde parametre olarak tanımlanan number değişkeni ile main metodu içinde tanımlanan number değişkeni aynı adresi göstermezler. Tanımlı oldukları alanda(scope) ulaşılabilirler. Number değişkenini adım adım değerini takip eder isek: main->number = 20 (fonksiyon çağrıldıktan sonra) Fonksiyon içinde ki Number değişkeni ise AddFive()->number = 25 olacaktır. Ancak tanımlanan değişkenler birbirlerine bağlanmadıkları için fonksiyon içinden number değerini değiştiremez. 'ref' anahtar kelimesini ekler isek:

static void Main(string[] args)
{
    int number = 20;
    AddFive(ref number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(ref int number)
{
    number = number + 5;
}

Görebileceğiniz üzere, 'ref' anahtar kelimesini fonksiyon bildirimine ve fonksiyonu çağırdığımız yere ekledik. Programı şimdi çalıştırırsanız, program fonksiyondan döndükten sonra number değerinin değiştiğini ve main içinde bulunan number değişkeninin yeni değerinin 25 olduğunu görürsünüz. Number değişkeninin çağrılan fonksiyon içinde aynı olmak zorunda olmadığını hatırlatmakta fayda var. static void AddFive(ref int num) { num = num + 5; } Ve ayrıca ref kullanımı ile yazılan örnek aşağıdaki ifadeye eşittir: number=AddFive(number); static int AddFive(int num) { num = num + 5; return num; }

'out' Anahtar Kelimesi

'out' anahtar kelimesi hemen hemen 'ref' anahtar kelimesi ile aynı çalışır. İkisi de parametreyi değerden ziyade referans ile geçirmeyi garanti eder, fakat ikisi de iki önemli fark ile gelirler. Birincisi, 'ref' anahtar kelimesi kullanılıyor ise değişkenin ilk değerinin verilmiş olması gerekir. Aksi takdir de değişkene değerin atanmadığı yönünde hata alırız. Aynı şekilde 'out' anahtar kelimesi kullanımında değişkene ilk değer atamaya gerek yoktur. Diğer taraftan, 'out' anahtar kelimesi kullanan fonksiyonda kesinlikle değişkene ilk değer atamasının yapılmış olması gerekir. İlk değeri atanmamış değerleri bir çıkış parametresi olarak iletebildiğiniz için, bir fonksiyon içinde gerçekten bir çıkış parametresi kullanamazsınız - buna sadece yeni bir değer atayabilirsiniz.

Whether to use out or ref really depends on the situation, as you will realize once you start using them. Both are typically used to work around the issue of only being able to return one value from a function, with C#.

Using the out modifier is just like using the ref modifier, as shown above. Simply change the ref keyword to the out keyword. In the example above, also remember to remove the value assigned to number in the method and declare it in the call function instead.

The params modifier

Şimdiye kadar, tüm fonksiyonlarımız sabit miktarda parametre kabul etti. Ancak, bazı durumlarda, rastgele sayıda parametre alan bir işleve ihtiyacınız olabilir. Elbette bu bir diziyi veya listeyi parametre olarak kabul ederek yapılabilir:

static void GreetPersons(string[] names) { }

However, calling it would be a bit clumsy. In the shortest form, it would look like this:

GreetPersons(new string[] { "John", "Jane", "Tarzan" });

It is acceptable, but it can be done even smarter, with the params keyword:

static void GreetPersons(params string[] names) { }

Calling it would then look like this:

GreetPersons("John", "Jane", "Tarzan");

Another advantage of using the params approach, is that you are allowed to pass zero parameters to it as well. Functions with params can even take other parameters as well, as long as the parameter with the params keyword are the last one. Besides that, only one parameter using the params keyword can be used per function. Here is a last and more complete example:

static void Main(string[] args)
{
    GreetPersons(0);
    GreetPersons(25, "John", "Jane", "Tarzan");
    Console.ReadKey();
}

static void GreetPersons(int someUnusedParameter, params string[] names)
{
    foreach(string name in names)
    Console.WriteLine("Hello, " + name);
}