Spiega x = > x.ToString () // semplifica tante chiamate

Question

In una risposta alla domanda trovo il seguente suggerimento sul codice: -

2) lambdas semplici con un parametro:

x => x.ToString() //simplify so many calls

Come qualcuno che non ha ancora usato 3.0 non capisco davvero questo suggerimento ma sembra interessante, quindi apprezzerei una spiegazione su come ciò semplifichi le chiamate con alcuni esempi.

Ho studiato lambda, quindi penso so cosa fanno, tuttavia potrei non comprendere appieno, quindi un poco disimballaggio potrebbe anche essere in ordine.

Answer 1

Quando devi creare un'istanza di un delegato che ha un singolo parametro, le espressioni lambda ti consentono di creare quel delegato "inline". in modo molto conciso. Ad esempio, ecco il codice per trovare una persona in un elenco, con il suo nome:

List<Person> list = new List<Person>();
// [..] Populate list here
Person jon = list.Find(p => p.Name == "Jon");

In C # 2.0 potresti usare un metodo anonimo che era un po 'più lungimirante, ma non troppo cattivo:

List<Person> list = new List<Person>();
// [..] Populate list here
Person jon = list.Find(delegate(Person p) { return p.Name == "Jon"; });

In C # 1.0 dovresti creare un intero metodo extra. Inoltre, se si desidera parametrizzarlo, è necessario creare un tipo diverso, mentre metodi anonimi ed espressioni lambda catturano il loro ambiente di esecuzione (variabili locali ecc.) In modo che si comportino come chiusure:

public Person FindByName(List<Person> list, String name)
{
    return list.Find(p => p.Name == name); // The "name" variable is captured
}

C'è di più al riguardo in il mio articolo sulle chiusure .

Mentre passare i delegati ai metodi non è terribilmente comune in C # 2.0 e .NET 2.0, è gran parte della base di LINQ - quindi si tende a usarlo molto in C # 3.0 con .NET 3.5.

Answer 2

Questo si espande sostanzialmente a:

private string Lambda(object x) {
  return x.ToString();
}

Answer 3

Conosci i metodi anonimi di C # 2.0? Queste due chiamate sono equivalenti (supponendo che SomeMethod accetti un delegato ecc.):

SomeMethod(x => x.ToString());

SomeMethod(delegate (SomeType x) { return x.ToString();});

So quale preferirei digitare ...

Answer 4

string delegate(TypeOfX x)
{
  return x.ToString();
}