Expressions Lambda en C# : Pourquoi les utiliser ?

Question

J'ai lu rapidement les Expression Lambda Microsoft la documentation.

Ce type d'exemple m'a cependant aidé à mieux comprendre :

delegate int del(int i);
del myDelegate = x => x * x;
int j = myDelegate(5); //j = 25

Pourtant, je ne comprends pas pourquoi il s'agit d'une telle innovation. C'est juste une méthode qui meurt lorsque la "variable méthode" se termine, n'est-ce pas ? Pourquoi devrais-je l'utiliser au lieu d'une vraie méthode ?

Answer 1

Expressions lambda constituent une syntaxe plus simple pour les délégués anonymes et peuvent être utilisés partout où un délégué anonyme peut être utilisé. Cependant, l'inverse n'est pas vrai ; les expressions lambda peuvent être converties en arbres d'expression, ce qui permet de réaliser une grande partie de la magie de LINQ to SQL.

Voici un exemple de LINQ to Objects Nous avons utilisé des délégués anonymes, puis des expressions lambda pour montrer à quel point elles sont plus faciles à comprendre :

// anonymous delegate
var evens = Enumerable
                .Range(1, 100)
                .Where(delegate(int x) { return (x % 2) == 0; })
                .ToList();

// lambda expression
var evens = Enumerable
                .Range(1, 100)
                .Where(x => (x % 2) == 0)
                .ToList();

Les expressions lambda et les délégués anonymes présentent un avantage par rapport à l'écriture d'une fonction distincte : ils mettent en œuvre la fonction fermetures qui peut vous permettre de transmettre l'état local à la fonction sans ajouter de paramètres à la fonction ou la création d'objets à usage unique.

Arbres d'expression sont une nouvelle fonctionnalité très puissante de C# 3.0 qui permet à une API d'examiner la structure d'une expression au lieu d'obtenir simplement une référence à une méthode qui peut être exécutée. Une API n'a qu'à transformer un paramètre délégué en un paramètre Expression<T> et le compilateur générera un arbre d'expression à partir d'une lambda au lieu d'un délégué anonyme :

void Example(Predicate<int> aDelegate);

appelé comme :

Example(x => x > 5);

devient :

void Example(Expression<Predicate<int>> expressionTree);

Ce dernier se verra transmettre une représentation de la arbre syntaxique abstrait qui décrit l'expression x > 5 . LINQ to SQL s'appuie sur ce comportement pour transformer les expressions C# en expressions SQL souhaitées pour le filtrage, l'ordonnancement, etc. du côté du serveur.

Answer 2

Les fonctions et expressions anonymes sont utiles pour les méthodes ponctuelles qui ne nécessitent pas le travail supplémentaire requis pour créer une méthode complète.

Prenons l'exemple suivant :

 List<string> people = new List<string> { "name1", "name2", "joe", "another name", "etc" };
 string person = people.Find(person => person.Contains("Joe"));

par rapport à

 public string FindPerson(string nameContains, List<string> persons)
 {
     foreach (string person in persons)
         if (person.Contains(nameContains))
             return person;
     return null;
 }

Ils sont fonctionnellement équivalents.

Answer 3

Je les ai trouvés utiles dans une situation où je voulais déclarer un gestionnaire pour l'événement d'un certain contrôle, en utilisant un autre contrôle. Pour le faire normalement, vous auriez dû stocker les références des contrôles dans des champs de la classe afin de pouvoir les utiliser dans une méthode différente de celle dans laquelle ils ont été créés.

private ComboBox combo;
private Label label;

public CreateControls()
{
    combo = new ComboBox();
    label = new Label();
    //some initializing code
    combo.SelectedIndexChanged += new EventHandler(combo_SelectedIndexChanged);
}

void combo_SelectedIndexChanged(object sender, EventArgs e)
{
    label.Text = combo.SelectedValue;
}

grâce aux expressions lambda, vous pouvez l'utiliser comme suit :

public CreateControls()
{
    ComboBox combo = new ComboBox();
    Label label = new Label();
    //some initializing code
    combo.SelectedIndexChanged += (s, e) => {label.Text = combo.SelectedValue;};
}

C'est beaucoup plus facile.

Answer 4

Lambda a nettoyé la syntaxe des délégués anonymes de C# 2.0... par exemple

Strings.Find(s => s == "hello");

Il a été réalisé en C# 2.0 comme suit :

Strings.Find(delegate(String s) { return s == "hello"; });

Fonctionnellement, ils font exactement la même chose, c'est juste une syntaxe beaucoup plus concise.

Answer 5

Ce n'est qu'une façon d'utiliser une expression lambda. Vous pouvez utiliser une expression lambda n'importe où vous pouvez utiliser un délégué. Cela vous permet de faire des choses comme ceci :

List<string> strings = new List<string>();
strings.Add("Good");
strings.Add("Morning")
strings.Add("Starshine");
strings.Add("The");
strings.Add("Earth");
strings.Add("says");
strings.Add("hello");

strings.Find(s => s == "hello");

Ce code recherchera dans la liste une entrée correspondant au mot "hello". L'autre façon de procéder consiste à passer un délégué à la méthode Find, comme ceci :

List<string> strings = new List<string>();
strings.Add("Good");
strings.Add("Morning")
strings.Add("Starshine");
strings.Add("The");
strings.Add("Earth");
strings.Add("says");
strings.Add("hello");

private static bool FindHello(String s)
{
    return s == "hello";
}

strings.Find(FindHello);

EDITAR :

En C# 2.0, cela pouvait se faire en utilisant la syntaxe des délégués anonymes :

  strings.Find(delegate(String s) { return s == "hello"; });

Lambda a considérablement nettoyé cette syntaxe.