Function parameters

In capitolul anterior am discutat despre functii. Parametrii acestora au fost mentionati in treacat, doar cat sa fie clar despre ce era vorba in exemplele de cod prezentate. Desi parametrii sunt simplu si usor de folosit, exista cateva trucuri care ii pot face mult mai puternici.

Primele detalii de care ne vom ocupa sunt modificatorii out si ref. Ca si in alte limbaje, C# trateaza in mod diferit doua categorii de parametrii: "prin valoare" si "prin referinta". In mod implicit, parametrii in C# sunt transmisi "prin valoare", ceea ce inseamna ca la transmiterea unei variabile catre o functie se va trimite de fapt o copie a obiectului corespunzator acelei variabile, si nu o referinta la acesta. Drept consecinta, in interiorul functiei se vor putea efectua modificari asupra parametrului, fara a afecta obiectul original care fusese transmis ca parametru.

Folosind cuvintele-cheie ref si out se modifica acest comportament, iar ceea ce se va transmite catre functie va fi o referinta catre obiectul respectiv si nu doar valoarea acestuia.

The ref modifier

Pentru urmatorul exemplu:

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

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

Este creat un numar de tip integer, i se atribuie valoarea 20, dupa care se apeleaza metoda AddFive(), ceea ce pare a adauga 5 numarului cu care lucram. Dar oare asa se intampla? Nu. Valoarea pe care o atribuim parametrului in interiorul functiei nu ajunge inapoi in exterior, deoarece s-a transmis o copie a valorii si nu o referinta catre numarul initial. Asa functioneaza C#-ul, si de multe ori acesta este comportamentul dorit. Dar, in cazul de fata, vrem sa se pastreze modificarea efectuata in interiorul functiei. Astfel ca vom folosi cuvantul-cheie ref:

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;
}

Dupa cum se observa, nu am schimbat decat foarte putin: am adaugat cuvantul-cheie ref in declaratia functiei si in apelul acesteia. Acum la executia programului se va afisa valoarea modificata, ramasa in variabila locala number si dupa revenirea din apelul metodei.

The out modifier

Modificatorul out functioneaza aproape ca si cel ref. Ambele asigura ca parametrul este inserat prin referinta si nu prin valoare, dar exista doua diferente importante intre ele: O valoare inserata prin modificatorul ref trebuie sa fie initializata inainte de a apela metoda - acest lucru nu este adevarat pentru modificatorul out, unde putem folosi valori ne-initializate. Pe de alta parte, nu poti folosi o functie fara a folosi un parametru de out, fara a atribui o valoare acestuia. In timp ce poti insera valori ne-initializate prin parametrul out, nu poti folosi un parametru out in interiorul unei functii - poti doar sa atribui o valoare noua acestuia.

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

So far, all of our functions have accepted a fixed amount of parameters. However, in some cases, you might need a function which takes an arbitrary number of parameters. This could of course be done by accepting an array or a list as a parameter, like this:

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" });

Functioneaza, dar putem realiza acelasi lucru si intr-un mod mai eficient, folosind cuvantul-cheie params:

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

Apelul poate arata acum astfel:

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);
}