Declararea metodelor și a funcțiilor este de fapt un proces format din trei etape: declararea, implementarea și apelarea metodei sau funcției noastre.
- Declararea este procesul de scriere a tipului metodei, numele ei și a eventualilor parametri, astfel încât programul să o poată identifica cu succes.
- Implementarea a unei metode înseamnă scrierea codului în sine, care va fi executat atunci când metoda este executată.
- Apelarea este procesul de invocare a metodei deja declarate și implementate de către o anumită parte a programului, unde trebuie rezolvată o problemă pe care metoda o poate rezolva.
Declararea unei metode nu se poate face oriunde vrem. Cu toate că încă nu au învățat despre clase, le vom menționa aici pentru că metodele pot fi declarate doar în interiorul blocului unei clase. După cum ați văzut deja în unele dintre exemplele noastre anterioare, metoda noastră Main a fost declarată în interiorul acoladelor unei clase (corpul acelei clase). Deci, pentru moment, imaginați-vă o clasă ca fiind o structură definită de un nume, având un corp delimitat prin deschiderea și închiderea de acolade. În acest context, o declarație de metoda ar arăta astfel:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
using
System;
namespace
BunaLume
{
class
Program
{ // acolada de deschidere a clasei
// declarare a metodei noastre in interiorul corpului clasei
static void SalutaLumea()
{ // acolada de deschidere a metodei
} // acolada de inchidere a metodei
} // acolada de inchidere a clasei
}
|
În exemplul de mai sus, am declarat o clasă numită Program, în interiorul blocului căreia am declarat o metoda numită SalutaLumea. Această metodă este numai declarată, dar încă nu face nimic, deoarece corpul său nu conține niciun cod. Acest lucru se face prin implementarea metodei:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
using
System;
namespace
BunaLume
{
class
Program
{ // acolada de deschidere a clasei
// declarare a metodei noastre in interiorul corpului clasei
static void SalutaLumea()
{ // acolada de deschidere a metodei
Console.WriteLine("Buna Lume!"); // implementare a unui cod de executat
Console.ReadLine();
} // acolada de inchidere a metodei
} // acolada de inchidere a clasei
}
|
Prin plasarea celor două instrucțiuni în interiorul corpului metodei noastre, am “implementat” metoda noastră, adica am adăugat metodei noastre ceva de executat atunci când este apelată. Totuși, chiar dacă declarăm și implementăm metoda noastră, ea încă nu face nimic cu de la sine putere. Aici intervine “apelarea” metodei noastre. Pentru ca metoda noastră să ruleze codul din interiorul blocului său, trebuie apelăm (chemăm) mai întâi metoda noastră:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
using
System;
namespace
BunaLume
{
class
Program
{ // acolada de deschidere a clasei
static void Main(string[] args)
{
SalutaLumea(); // apelare a metodei
Console.Read();
}
// declarare a metodei noastre in interiorul corpului clasei
static void SalutaLumea()
{ // acolada de deschidere a metodei
Console.WriteLine("Buna Lume!");
} // acolada de inchidere a metodei
} // acolada de inchidere a clasei
}
|
În exemplul de mai sus, am declarat și implementat metoda noastră. Exceptând acest lucru, puteți observa o a doua metodă pe care am folosit-o într-o mulțime din lecții noastre anterioare, numită Main() (aceasta este prima metodă care se execută atunci când se pornește un program de consolă). In interiorul blocului metodei noastre Main(), am apelat a doua metodă, SalutaLumea().
Vom descrie aceste aspecte separat în lecții viitoare, pentru moment trebuie doar să știți că o metodă poate fi declarată, implemetată și apelată.
Declarațiile de funcții sunt oarecum identice cu declarațiile de metode, cu singura diferență că acestea trebuie să returneze o valoare, așa cum am explicat în lecția precedentă. Considerați următorul exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
using
System;
namespace
BunaLume
{
class
Program
{ // acolada de deschidere a clasei
static void Main(string[] args)
{
string salut = SalutaLumea(); // apelare a functiei si preluare a valorii sale returnate
Console.WriteLine(salut); // afisare a salutului la consola
Console.Read();
}
// declarare a functiei noastre in interiorul corpului clasei
static string SalutaLumea()
{ // acolada de deschidere a functiei
string salutare = "Buna Lume!"; // implementare a functiei
return salutare; // returneaza obligatoriu o valoare (de tip string)
} // acolada de inchidere a functiei
} // acolada de inchidere a clasei
}
|
În C# 6 și versiunile ulterioare, putem folosi membri cu corp de expresie pentru a oferi o sintaxă mai concisă metodelor și funcțiilor care constau dintr-o singură expresie. O funcție cu corp de expresie constă într-o singură expresie care returnează o valoare (sau efectuează o acțiune în cazul unei metode), fără a necesita acolade și instrucțiunea return. În schimb, folosește o săgeată (=>) urmată de expresia care reprezintă implementarea metodei sau a funcției.
Iată cum putem converti metoda noastră SalutaLumea() de mai devreme într-o metodă cu corp de expresie:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
using
System;
namespace
BunaLume
{
class
Program
{ // acolada de deschidere a clasei
static void Main(string[] args)
{
SalutaLumea(); // apelare a metodei
Console.Read();
}
// declararea și implementarea metodei cu corp de expresie
static void SalutaLumea() => Console.WriteLine("Buna Lume!");
} // acolada de inchidere a clasei
}
|
După cum puteți vedea, declararea și implementarea metodei sunt acum într-un singur rând. Am folosit săgeata (=>) pentru a indica implementarea metodei, care în acest caz este doar instrucțiunea Console.WriteLine().
Similar, putem folosi sintaxa cu corp de expresie pentru funcția noastră SalutaLumea() arătată anterior:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
using
System;
namespace
BunaLume
{
class
Program
{ // acolada de deschidere a clasei
static void Main(string[] args)
{
string salut = SalutaLumea(); // apelare a functiei si preluare a valorii sale returnate
Console.WriteLine(salut); // afisare a salutului la consola
Console.Read();
}
// declararea și implementarea funcției cu corp de expresie
static string SalutaLumea() => "Buna Lume!";
} // acolada de inchidere a clasei
}
|
Aici, am eliminat acoladele și instrucțiunea return din funcția noastră și am folosit săgeata (=>) pentru a indica implementarea funcției, care în acest caz este doar șirul de caractere "Buna Lume!".
Dacă este necesară mai mult de o singură instrucțiune într-o metodă cu corp de expresie, le puteți înconjura într-un bloc de cod, exact ca într-o metodă normală. Încă puteți folosi operatorul săgeată, dar pentru funcții, trebuie să utilizați cuvântul cheie return.
Rețineți că membrii cu corp de expresie sunt potriviți în special pentru metode și funcții simple, cu implementări scurte și directe. Pentru implementări mai complexe, sintaxa tradițională cu acolade și declarație și implementare separate este mai potrivită. Este de asemenea important de menționat că programatorii pun mult accent pe consistență. Nu declarați jumătate din metodele voastre într-un mod și cealaltă jumătate în alt mod.
Conceptele explicate în această lecție sunt prezentate și vizual, ca parte a următorului videoclip:
