Newsgroup: it.comp.dotnet
Titolo: Lambda expressions e performance

Buonasera a tutti,
ho una situazione del genere: una classe "EventManager" che espone un 
metodo "HandleEvent(int) : string". Se il numero è pari, richiama un 
gestore, altrimenti ne richiama un altro.
Prima soluzione:
interface IEventHandler
{
	string Handle(int n);
}
class OddEventHandler : IEventHandler { ... }
class EvenEventHandler : IEventHandler { ... }
class EventManager {
	public EventManager(IEventHandler odd, IEventHandler even) { ... }
	public void HandleEvent(int n)
	{
		if (n % 2 == 0) even.Handle(n);
		else odd.Handle(n);
	}	
}
in sintesi: strategy pattern. Ora, siccome tutto ciò che è 
simil-funzionale esercita su di me una attrazione spasmodica, mi 
chiedevo: e se facessi così?
class EventManager
{
	public EventManager(Func<int, string> odd, Func<int, string> even) { ... }
	public void HandleEvent(int n)
	{
		if (n % 2 == 0) even.Handle(n);
		else odd.Handle(n);
	}	
}
A livello concettuale cambia solo il fatto che la stretgy è iniettata 
come lambda expression (o "puntatore a funzione", per usare un'immagine 
arcaica ma a cui tutti vogliamo tanto bene) piuttosto che come 
interfaccia di cui si richiama un metodo. Ma - mi chiedo - c'è 
differenza a livello di performance?
Grazie,
Giulio
-- 

 richiama un metodo. Ma - mi chiedo - c'è differenza a livello di performance?
a naso direi proprio di no.
.m
-- 
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com
blog @ 
http://milestone.topics.it
whynot [ at ] topics [ dot ] it

 richiama un metodo. Ma - mi chiedo - c'è differenza a livello di performance?
Lambda ==> anonymous delegate
Quindi si applica tutto ciò che riguarda i delegate ...
-- 
Raffaele Rialdi  
http://www.iamraf.net
Weblog: 
http://blogs.ugidotnet.org/raffaele
Microsoft MVP profile 
https://mvp.support.microsoft.com/profile/raffaele
UGIdotNET - 
http://www.ugidotnet.org/

 }
oltre a quello che giustamente ha detto Raff aggiungo che non c'è 
nessuna lambda expression nel tuo esempio, semplicemente potresti 
chiamare il costruttore di EventManager usando la sintassi della lambda 
ma non usando una lambda expression. Altrimenti dovresti avere questo:
EventManager( Expression<Func<int, string>> odd, Expression<Func<int, 
string>> even)
che è cosa molto diversa.


 Quindi si applica tutto ciò che riguarda i delegate ...
Uhm... a occhio ti direi che non ho capito molto quello che vuoi dire. :-)
Puoi girarmi qualche link o indicarmi cosa cercare in rete?
Grazie,
Giulio
-- 

 che è cosa molto diversa.
Ok... credo di cominciare a capire. Dunque (con riferimento all'inizio 
di questo articolo qui 
http://www.elguille.info/NET/futuro/firmas_octavio_ArbolesExpresiones_EN.htm
) 
i delegate anonimi (i.e. Func<>) vengono compilati, mentre le 
espressioni (i.e. Expression<Func<>>) vengono interpretate secondo un 
AST costruito in memory, right?
Quali sono le differenze tra i due approcci in termini di performances, 
occupazione di memoria, ecc ecc... ? C'è qualche documento ufficiale?
Ciao,
Giulio
-- 

 Puoi girarmi qualche link o indicarmi cosa cercare in rete?
Ciao Giulio,
dicevo solo che le lambda sono un modo conveniente per esprimere 
l'equivalente di un delegate. Quindi tutto ciò che riguarda le 
performance va letto in chiave delegate.
Questo articolo è un overview da delegate a lambda:
http://msdn.microsoft.com/en-us/library/bb397687.aspx


 occupazione di memoria, ecc ecc... ? C'è qualche documento ufficiale?
nel tuo scenario le Expression non servono a nulla, ti servono i 
delegati, in generale, a parte le similitudini sintattiche, non ha 
senso confrontare delegate ed expression, sono un po' mele e pere :-P


 delegati,
Perfetto. :-)
Grazie,
Giulio
--