Expliquez x = > x.ToString () // simplifie beaucoup d'appels

Question

Dans une réponse à une question , je trouve le conseil de codage suivant: -

2) lambdas simples avec un paramètre:

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

En tant que personne n'ayant pas encore utilisé la version 3.0, je ne comprends pas vraiment cette astuce, mais elle a l'air intéressante. J'apprécierais donc de vous expliquer comment cela simplifie les appels avec quelques exemples.

J'ai fait des recherches sur les lambdas, donc je pense que je sais ce qu'ils font. Cependant, je ne peux pas bien comprendre pourquoi un petit déballage peut également être en ordre.

Answer 1

Lorsque vous devez créer une instance d'un délégué comportant un seul paramètre, les expressions lambda vous permettent de créer ce délégué " inline " de manière très concise. Par exemple, voici le code permettant de rechercher une personne particulière dans une liste, par son nom:

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

En C # 2.0, vous pouvez utiliser une méthode anonyme qui était un peu plus longue, mais pas trop bad:

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

En C # 1.0, vous devez créer une méthode complète supplémentaire. De plus, si vous souhaitez le paramétrer, vous devez créer un type différent, alors que les méthodes anonymes et les expressions lambda capturent leur environnement d'exécution (variables locales, etc.) afin qu'ils agissent comme des fermetures:

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

Vous trouverez plus d'informations à ce sujet dans mon article sur les fermetures .

Bien que transmettre des délégués aux méthodes ne soit pas très courant en C # 2.0 et .NET 2.0, il constitue une grande partie de la base de LINQ. Vous avez donc tendance à l'utiliser beaucoup en C # 3.0 avec .NET 3.5.

Answer 2

Cela étend essentiellement à:

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

Answer 3

Connaissez-vous les méthodes anonymes en C # 2.0? Ces deux appels sont équivalents (en supposant que SomeMethod accepte un délégué, etc.):

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

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

Je sais lequel je préfère taper ...

Answer 4

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