În lecția anterioară scriam că putem îmbunătăți în continuare codul folosind expresii lambda. O expresie lambda este o modalitate convenabilă de a defini o funcție anonimă (fără nume) care poate fi transmisă ca variabilă sau ca parametru la un apel de metodă. Pentru început, acesta era codul cu care am rămas în lecția anterioară:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
using System; using System.Collections.Generic; namespace BunaLume { public class Program { delegate bool DelegatFiltru(int _numar); static bool MaiMicDeCinci(int _numar) { return _numar < 5; } static bool MaiMicDeZece(int _numar) { return _numar < 10; } static bool MaiMareDeTreisprezece(int _numar) { return _numar > 13; } public static void Main() { int[] _numere = { 2, 7, 3, 9, 5, 7, 1, 8, 13, 17, 5 }; IEnumerable<int> _rezultat = FiltreazaNumere(_numere, MaiMareDeTreisprezece); foreach (int _numar in _rezultat) Console.WriteLine(_numar); Console.Read(); } static IEnumerable<int> FiltreazaNumere(IEnumerable<int> _numere, DelegatFiltru _filtru) { foreach (int _numar in _numere) if (_filtru(_numar)) yield return _numar; } } } |
Deci, cele trei metode pe care le-am declarat candidate la delegatul FilterDelegate, MaiMicDeCinci, MaiMicDeZece, MaiMareDeTreisprezece, sunt foarte similare una cu alta. Ori de câte ori avem coduri care arată izbitor de similar, facem ceva greșit. De fapt, ce diferă în cele trei metode? Dacă analizați sintaxa, veți observa că singura diferență vine în această bucată de cod: _numar <5 ;. Asta este tot ceea ce avem cu adevărat nevoie de la aceste metode, și asta este tot ceea ce este relevant și trebuie să fie parametrizat.
O expresie lambda ne permite să declaram o metodă fără un nume care este utilizată într-un singur loc și este declarată local. Și, dacă ne uităm la codurile noastre, folosim cele trei metode într-un singur loc, ca parametru al metodei FiltreazaNumere. Deci, dacă o expresie lambda este declarată doar la nivel local, să facem exact asta, să mutăm una dintre declarațiile metodelor noastre în locul în care avem nevoie de fapt de ea:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, static bool MaiMicDeCinci(int _numar) { return _numar < 5; }); // ... |
În acest moment, veți primi erori de compilare, dar ignorați-le, vom clarifica puțin lucrurile. Deoarece, dacă stați să vă gândiți, cuvântul cheie static nu are niciun sens în contextul local, deci, îl putem șterge:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, bool MaiMicDeCinci(int _numar) { return _numar < 5; }); // ... |
În continuare, cuvântul cheie bool, care ne spune tipul de returnare al metodei: ei, bine, pot privi această expresie și văd că în mod evident, returnează o valoare booleană: _numar <5. Deci, nu am nevoie nici de cuvântul cheie bool:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, MaiMicDeCinci(int _numar) { return _numar < 5; }); // ... |
Acum, metoda MaiMicDeCinci, întrucât o convertim într-o expresie lambda, iar expresiile lambda sunt declarate și utilizate doar local, există doar în bucata de cod unde o declarăm, direct în interiorul apelului la funcția FiltreazaNumere. Nu o vom apela nicăieri altundeva. Deci, nu avem nevoie de un nume nici pentru acesta:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, (int _numar) { return _numar < 5; }); // ... |
Vedem că declarația afirmă că _numar este un int. Știu deja că este un int, deoarece DelegatFiltru primește un int. Trecem metoda noastră ca parametru la parametrul DelegatFiltru al metodei FiltreazaNumere, iar FiltreazaNumere preia un int. Nu prea trebuie să specific tipul variabil _numar:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, (_numar) { return _numar < 5; }); // ... |
Am voie să păstrez parantezele acestei expresii: (_numar), dar parantezele în acest context mi-ar permite doar să pun mai mult de un argument. Din moment ce am doar argumentul _numar, nu prea am nevoie de acestea:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, _numar { return _numar < 5; }); // ... |
Acum, cuvântul cheie return, am o singură expresie în cadrul acestei metode, deci compilatorul poate deduce și ce să returneze. Îl pot elimina:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, _numar { _numar < 5; }); // ... |
Dacă metoda mea ar fi avut mai mult de o declarație, aș fi fost forțată să scriu declarația return, astfel încât compilatorul să înțeleagă care dintre declarații trebuie returnată.
Am spus deja că avem o singură afirmație, și puteți vedea că folosim acolade. Vă amintiți că acoladele definesc doar un bloc de cod care ne permite să scriem mai multe enunțuri, nu? Deci, dacă am o singură instrucțiune, le pot elimina și de asemenea, pot elimina punctul și virgula de la sfârșitul afirmației mele, deoarece un punct și virgulă doar separă mai multe instrucțiuni una de alta:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, _numar _numar < 5); // ... |
În această etapă, s-ar putea să vă gândiți că am ciopârțit metoda atât de mult încât n-a mai rămas cine știe ce din ea. Și ați avea dreptate, iar asta este de fapt tot ce avem nevoie din această metodă. Avem nevoie de _numar, deoarece este numele argumentului pe care îl utilizăm pentru a trece parametrii la funcția noastră ciopârțită, și expresia în sine, _numar <5, care folosește numitul argument și returnează o valoare. Poate fi evident faptul că, evident, compilatorul trebuie să știe unde se termină argumentul(ele) metodei noastre și unde începe corpul său, și faptul că nu putem folosi o virgulă sau ceva de genul acesta, deoarece ar părea că trecem încă o altă parametru, separat prin virgulă. În schimb, C# ne oferă un simbol special pe care l-a moștenit din alte limbaje funcționale, un semn egal urmat de o săgeată la dreapta:
|
1 2 3 4 5 |
// ... IEnumerable<int> _rezultat = FiltreazaNumere(_numere, _numar => _numar < 5); // ... |
Această bucată de cod este de fapt o expresie lambda: _numar => _numar <5. Să vă traduc sintaxa: „folosește variabila _numar ca parametru de metodă, trimite acest parametru la această expresie, și dă-mi valoarea pe care o returnează expresia”. Sau, forma scurtată, „folosește _numar și spune-mi când _numar este mai mic de cinci”. Sau, cea mai scurtă formă, „_numar unde _numar este mai mic de 5″.
Dacă o integrez în codurile mele în această etapă:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
using System; using System.Collections.Generic; namespace BunaLume { public class Program { delegate bool DelegatFiltru(int _numar); public static void Main() { int[] _numere = { 2, 7, 3, 9, 5, 7, 1, 8, 13, 17, 5 }; IEnumerable<int> _rezultat = FiltreazaNumere(_numere, n => n < 5); foreach (int _numar in _rezultat) Console.WriteLine(_numar); Console.Read(); } static IEnumerable<int> FiltreazaNumere(IEnumerable<int> _numere, DelegatFiltru _filtru) { foreach (int _numar in _numere) if (_filtru(_numar)) yield return _numar; } } } |
tot primesc numerele mai mici de cinci:
Este minunat că nu suntem obligați să declaram cele trei metode la începutul clasei noastre. Acum, doar schimbăm un semn și o valoare, pentru a schimba complet numerele pe care le filtrăm.
Dacă aveți vreodată nevoie de o expresie lambda care nu preia argumente, sunteți obligați să specificați două paranteze, astfel:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
using System; using System.Collections.Generic; namespace BunaLume { public class Program { delegate void UnDelegat(); public static void Main() { int i = 0; UnDelegat _delegat; _delegat = () => i++; Console.Read(); } } } |
În acest caz, am declarat variabila i în afara expresiei lambda, în interiorul corpului metodei mele Main. Prin urmare, nu a fost nevoie să declar o expresie lambda care să accepte niciun parametru, deoarece în interiorul corpului său incrementez valoarea declarată extern. Totuși, a trebuit să folosesc () când am declarat expresia lambda, astfel încât compilatorul să înțeleagă că aceasta nu are parametri.
Dacă doriți să știți ce se întâmplă sub capotă, expresiile lambda nu funcționează în MSIL. Când compilatorul vede o expresie lambda, acesta o va converti într-o metodă normală:
Deci, când vă gândiți la expresii lambda, gândiți-vă la ele ca la metode. Dar, ceea ce e interesant, gândiți-vă la ele ca metode fără nume. Nu ne interesează numele, pentru că le folosim o singură dată, acolo unde sunt declarate. Acesta este motivul pentru care unii programatori le numesc metode anonime, chiar dacă metodele anonime sunt un concept diferit în C#.
Tags: delegați, expresie lambda, funcții, metodă anonimă, metode, parametri functii
