Delegates from .NET 1.0 to .NET 4.0

Mai mult ca sigur ati folosit delegate. Sunt utili cand trebuie sa specificam un comportament la runtime si nu la compile time. Prin acest mecanism putem sa scapam de mostenire in locurile unde aceasta a fost folosita pentru a definii un comportament specific.
Exista mai multe tipuri de delegates definite core-ul de .NET:

• Predicate
• Action
• Func

O sa incerc sa descriu pe scurt fiecare tip de delegate:
Action reprezinta o actiune care nu returneaza nici un rezultat. Header-ul la metoda ar fi de forma urmatoare

void fx(T)

Exista mai multe implementari de Action, se pot definii pana la maxim 16 parametrii. In cazul in care avem nevoie de mai mult de 16 parametri, ne putem definii noi propile actiuni, dar nu cred ca este sanatos sa avem o actiune cu 16 parametrii sau mai multi.
Predicate reprezinta o conditie care se ruleaza si care returneaza TRUE sau FALSE

bool fx(T)

Atat Action cat si Predicate apar odata cu .NET 2.0, dar ajung sa fie folosite la adevarata lor valoare abia in .NET 3.5 cand apare si Func impreuna cu expresiile lambda.
Func<T1...,TResult> specifica un delegate care accepta de la 0 la 16 parametrii si returneaza un rezultat de tipul TResult. Este bine de retinut faptul ca tipul rezultatului este definit mereu ca si ultimul parametru.

TResult fx(T1,...)

Acuma ca stim ce reprezinta fiecare din ele, ar fi interesant sa vedem cum au aparut si evoluat in timp.
In .NET 1.0 si .NET 1.1 daca aveai nevoie de un delegate era nevoie sa iti declari un delegate de forma:

delegate bool GetHalfDelegate(int number);

Urmatorul pas era declari o metoda care are aceiasi semnatura cu delegatul pe care l-ai declarat si apoi sa instantiezi o variabila de tipul respectiv.

public bool GetHalf(int number) { ... }
...
GetHalfDelegate getHalf = new GetHalfDelegate(this.GetHalf);

Pentru a putea apela acest delegate era nevoie de un apel de forma:

int result = getHalf(97);

Odata cu aparitia la .NET 2.0 apare si conceptul de metode anonime. Prin acest mecanism putem sa ne definim o logica fara a scrie o metoda. In cazul nostru nu mai este nevoie sa ne definim medoda GetHalf, ajunge doar ca in momentul in care instantiem variabila getHalf sa scriem codul care vrem sa se execute.

GetHalfDelegate getHalf = delegate(int number)
                        {
                              return number/2;
                        };

Lucruriile se simplifica umpic, dar cu .NET 3.5 totul ajunge mult mai simplu. Putem sa ne folosim de Func. Orice metoda definita cu acest antet o sa poata sa fie folosita. Cel care defineste metoda nu va mai avea nevoie sa aibe o referinta la tipul delegat-ului Tot ce mai este nevoie sa scriem este:

Func<int,int> getHalf = (number) => number/2;

Mi s-a parut destul de interesant modul in care sintaxa a evoluat de la 1.0 la 3.5.
In .NET 4.0 nu a mai aparut nimic special la acest nivel, dar cu ajutorul lui var putem sa rescriem codul sub forma

var getHalf = (number) => number/2;

Trebuie avut grija cat de mult folosim aceste elemente. Viteza de executie a codului poate sa scada in care face exces, iar nu in ultimul rand codul scris poate sa fie mult mai greu de inteles.