Qual è la differenza tra metodi anonimi (C # 2.0) ed espressioni lambda (C # 3.0)? [duplicare]

Question

    

Questa domanda ha già una risposta qui:

    

        
•              parola chiave delegata vs. notazione lambda                                      6 risposte                          
    

    

Qual è la differenza tra metodi anonimi di C # 2.0 e espressioni lambda di C # 3.0.?

Answer 1

La pagina MSDN su metodi anonimi lo spiega

  

Nelle versioni di C # precedenti alla 2.0, l'unica   il modo per dichiarare un delegato era usare   metodi con nome. Introduzione di C # 2.0   metodi anonimi e in C # 3.0 e   più tardi, le espressioni lambda sostituiscono   metodi anonimi come il modo preferito   per scrivere il codice in linea. comunque, il   informazioni su metodi anonimi in   questo argomento vale anche per lambda   espressioni. C'è un caso in   che fornisce un metodo anonimo   funzionalità non trovata in lambda   espressioni. Metodi anonimi abilitati   omettere l'elenco dei parametri e   questo significa che un metodo anonimo   può essere convertito in delegati con a   varietà di firme. Questo non è   possibile con espressioni lambda. Per   ulteriori informazioni in particolare su   espressioni lambda, vedi Lambda   Espressioni (Guida per programmatori C #).

E riguardo alle espressioni lambda :

  

Un'espressione lambda è una funzione anonima che può contenere espressioni e istruzioni e può essere utilizzata per creare delegati o tipi di alberi di espressioni.   Tutte le espressioni lambda usano l'operatore lambda = & Gt ;, che viene letto come & Quot; passa a & Quot ;. Il lato sinistro dell'operatore lambda specifica i parametri di input (se presenti) e il lato destro contiene l'espressione o il blocco di istruzioni. L'espressione lambda x = & Gt; x * x viene letto " x passa a x volte x. " Questa espressione può essere assegnata a un tipo delegato come segue:

Answer 2

1. Le espressioni lambda possono essere convertite in delegati o alberi delle espressioni (con alcune restrizioni); i metodi anonimi possono essere convertiti in delegati
2. Le espressioni lambda consentono l'inferenza del tipo sui parametri:
3. Le espressioni lambda consentono al corpo di essere troncato solo a un'espressione (per restituire un valore) o a una singola istruzione (in altri casi) senza parentesi graffe.
4. Le espressioni lambda consentono di abbreviare l'elenco dei parametri solo al nome del parametro quando il tipo può essere dedotto e quando esiste un solo parametro
5. I metodi anonimi consentono di omettere completamente l'elenco dei parametri quando non viene utilizzato all'interno del corpo e non genera ambiguità

L'ultimo punto è l'unico vantaggio dei metodi anonimi rispetto alle lambda, credo. È utile creare un evento simile a un campo con un abbonamento no-op:

public event EventHandler Click = delegate{};

Answer 3

1. I metodi anonimi sono sostanzialmente funzioni senza nome, con la possibilità di creare chiusure.
2. Le espressioni lambda sono costrutti convertibili in metodi anonimi e alberi delle espressioni e seguono regole di inferenza del tipo più complesse rispetto ai metodi anonimi.

La gamma di differenze più o meno sottili è spiegata da Eric Lippert (designer del linguaggio C #) nel suo blog:

• Espressioni lambda e metodi anonimi, prima parte
• Espressioni lambda e metodi anonimi, seconda parte
• Espressioni lambda e metodi anonimi, terza parte
• Espressioni lambda e metodi anonimi, quarta parte
• Espressioni lambda e metodi anonimi, parte quinta

Answer 4

In primo luogo, convenienza: le lambda sono più facili da leggere e scrivere.

In secondo luogo, espressioni: lambdas può essere compilato in o un delegato, o un albero delle espressioni (Expression<T> per alcuni tipi di delegati T, come Func<int,bool> ). Gli alberi delle espressioni sono i più interessanti, in quanto è la chiave di LINQ per gli archivi di dati fuori processo.

Func<int,bool> isEven = i => i % 2 == 0;
Expression<Func<int,bool>> isEven = i => i % 2 == 0;

Nota che le espressioni lambda con i corpi delle istruzioni possono essere compilate solo per i delegati, non Expression s:

Action a = () => { Console.WriteLine(obj.ToString()); };