Parametri ai metodelor

În tema anterioară a fost definită metoda SayHello, care afișează un mesaj pe consolă:

void SayHello()
{
   Console.WriteLine("Hello");
}

SayHello(); // Hello

Dar dezavantajul unei astfel de metode este că afișează același mesaj. Ar fi util dacă am putea să definim dinamic ce mesaj va afișa metoda pe ecran, adică să transmitem din exterior acest mesaj în metodă. Pentru aceasta, în C# putem folosi parametri.

Parametrii permit transmiterea unor date de intrare în metodă. Parametrii sunt definiți prin virgulă în paranteze după numele metodei astfel:

tip_metodă nume_metodă (tip_parametru1 parametru1, tip_parametru2 parametru2, ...)
{
   // acțiuni ale metodei
}

Definiția unui parametru constă din două părți: mai întâi este tipul parametrului și apoi numele acestuia.

De exemplu, să definim metoda PrintMessage, care primește mesajul de afișat din exterior:

void PrintMessage(string message)
{
   Console.WriteLine(message);
}

PrintMessage("Hello work");           // Hello work
PrintMessage("Hello FDC.COM");    // Hello FDC.COM
PrintMessage("Hello C#");             // Hello C#

Aici metoda PrintMessage() primește un parametru numit message și de tip string.

Pentru a apela o metodă care are parametri, după numele metodei în paranteze se transmit valorile parametrilor, de exemplu:

PrintMessage("Hello work");

Aici parametrului message i se transmite șirul "Hello work". Valorile transmise parametrilor se numesc argumente. Adică șirul "Hello work" transmis în acest caz este un argument.

Uneori întâlnim definițiile de parametri formali și parametri reali. Parametrii formali sunt parametrii metodei (în acest caz message), iar parametrii reali sunt valorile transmise parametrilor formali. Adică parametrii reali sunt argumentele metodei.

Să definim o altă metodă, care adună două numere:

void Sum(int x, int y)
{
   int result = x + y;
   Console.WriteLine($"{x} + {y} = {result}");
}

Sum(10, 15);    // 10 + 15 = 25

Metoda Sum are doi parametri: x și y. Ambii parametri sunt de tip int. Prin urmare, la apelarea acestei metode, trebuie să transmitem în locul acestor parametri două numere. În interiorul metodei se calculează suma numerelor transmise și se afișează pe consolă.

La apelarea metodei Sum, valorile sunt transmise parametrilor prin poziție. De exemplu, în apelul Sum(10, 15), numărul 10 este transmis parametrului x, iar numărul 15 - parametrului y.

De asemenea, parametrii pot fi utilizați în versiunea prescurtată a metodei:

void Sum(int x, int y) => Console.WriteLine($"{x} + {y} = { x + y }");

Sum(10, 15);    // 10 + 15 = 25

Valorile transmise parametrilor pot reprezenta valori ale variabilelor sau rezultatul unor expresii complexe care returnează o valoare:

void Sum(int x, int y) => Console.WriteLine($"{x} + {y} = { x + y }");

int a = 10, b = 15, c = 6;
Sum(a, b);                  // 10 + 15 = 25
Sum(3, c);                  // 3 + 6 = 9
Sum(14, 4 + c);             // 14 + 10 = 24

Dacă parametrilor metodei li se transmit valori ale variabilelor, atunci astfel de variabile trebuie să aibă o valoare atribuită. De exemplu, următorul program nu se va compila:

void Sum(int x, int y)
{
   Console.WriteLine($"{x} + {y} = { x + y }");
}

int a;
int b = 15;
Sum(a, b);  // ! Eroare

Corelarea parametrilor și argumentelor după tipul de date

La transmiterea valorilor parametrilor, este important să se țină cont de tipul parametrilor: între argumente și parametri trebuie să existe o corespondență după tip. De exemplu:

void PrintPerson(string name, int age)
{
   Console.WriteLine($"Name: {name}  Age: {age}");
}

PrintPerson("Tom", 24); // Name: Tom  Age: 24

În acest caz, primul parametru al metodei PrintPerson() este de tip string, deci la apelarea metodei trebuie să transmitem acestui parametru o valoare de tip string, adică un șir. Al doilea parametru este de tip int, deci trebuie să transmitem un număr întreg, care corespunde tipului int.

PrintPerson("Tom", 24);

De asemenea, putem transmite parametrilor valori de tipuri care pot fi convertite automat la tipul parametrilor. De exemplu:

void PrintPerson(string name, int age)
{
   Console.WriteLine($"Name: {name}  Age: {age}");
}

byte b = 37;
PrintPerson("Tom", b); // Name: Tom  Age: 37

Aici parametrului de tip int i se transmite o valoare de tip byte, dar compilatorul poate converti automat valoarea de tip byte la tipul int. De aceea, aici nu va apărea nicio eroare. Ce tipuri de conversii pot fi efectuate automat a fost discutat într-unul dintre subiectele anterioare: Conversii ale tipurilor de date de bază.

Nu putem transmite parametrilor valori de alte tipuri. De exemplu, următorul apel al metodei PrintPerson va fi eronat:

PrintPerson(45, "Bob"); // Eroare! nesocotirea tipurilor parametrilor

Parametri opționali

Implicit, la apelarea metodei trebuie să furnizăm valori pentru toți parametrii săi. Dar C# permite și utilizarea parametrilor opționali. Pentru astfel de parametri trebuie să declarăm o valoare implicită. De asemenea, trebuie să ținem cont că după parametrii opționali, toți ceilalți parametri trebuie să fie de asemenea opționali:

void PrintPerson(string name, int age = 1, string company = "Undefined")
{
   Console.WriteLine($"Name: {name}  Age: {age}  Company: {company}");
}

Aici parametrii age și company sunt opționali, deoarece li s-au atribuit valori. Prin urmare, la apelarea metodei, putem să nu transmitem date pentru acești parametri:

void PrintPerson(string name, int age = 1, string company = "Undefined")
{
   Console.WriteLine($"Name: {name}  Age: {age}  Company: {company}");
}

PrintPerson("Tom", 37, "Microsoft");  // Name: Tom  Age: 37  Company: Microsoft
PrintPerson("Tom", 37);               // Name: Tom  Age: 37  Company: Undefined
PrintPerson("Tom");                   // Name: Tom  Age: 1   Company: Undefined

Ieșirea pe consolă a programului:

Name: Tom  Age: 37  Company: Microsoft
Name: Tom  Age: 37  Company: Undefined
Name: Tom  Age: 1   Company: Undefined

Parametri denumiți

În exemplele anterioare, la apelarea metodelor, valorile pentru parametri erau transmise în ordinea declarării acestor parametri în metodă. Adică, argumentele erau transmise parametrilor prin poziție. Dar putem să încălcăm această ordine folosind parametri denumiți:

void PrintPerson(string name, int age = 1, string company = "Undefined")
{
   Console.WriteLine($"Name: {name}  Age: {age}  Company: {company}");
}

PrintPerson("Tom", company: "Microsoft", age: 37);  // Name: Tom  Age: 37  Company: Microsoft
PrintPerson(age: 41, name: "Bob");                  // Name: Bob  Age: 41  Company: Undefined
PrintPerson(company: "Google", name: "Sam");        // Name: Sam  Age: 1   Company: Google

Pentru a transmite valorile parametrilor după nume, la apelarea metodei se specifică numele parametrului și, după două puncte, valoarea acestuia: name: "Tom".

Ieșirea pe consolă a programului:

Name: Tom  Age: 37  Company: Microsoft
Name: Bob  Age: 41  Company: Undefined
Name: Sam  Age: 1   Company: Google