Expressions Lambda en C#

En C#, les expressions lambda permettent d’écrire des méthodes anonymes (sans nom) de manière concise et lisible. Elles sont définies avec l’opérateur => (opérateur lambda). Les expressions lambda sont particulièrement utilisées dans les requêtes LINQ, les abonnements aux événements et dans le style de programmation fonctionnelle.

Syntaxe de base des Lambdas

Une expression lambda se compose d’une liste de paramètres et d’un corps. Pour les expressions simples, les accolades ne sont pas nécessaires ; pour les corps multi-lignes, les accolades et return peuvent être utilisés.

// Un paramètre, expression sur une seule ligne
Func<int, int> carre = x => x * x;
Console.WriteLine(carre(5)); // 25

// Lambda avec plusieurs paramètres
Func<int, int, int> addition = (a, b) => a + b;
Console.WriteLine(addition(3, 4)); // 7

// Lambda multi-lignes
Func<int, int, int> multiplication = (a, b) =>
{
    Console.WriteLine($"Multiplication : {a} * {b}");
    return a * b;
};
Console.WriteLine(multiplication(2, 6)); // 12

Lambda avec Action et Func

Les expressions lambda sont souvent utilisées avec les types Action et Func :

• Action : Représente des méthodes sans valeur de retour.
• Func<T,..., TResult> : Représente des méthodes qui retournent une valeur.

Action saluer = () => Console.WriteLine("Bonjour !");
saluer(); // Bonjour !

Func<string, int> longueur = s => s.Length;
Console.WriteLine(longueur("Lambda")); // 6

Lambda et LINQ

Les expressions lambda sont le plus souvent utilisées dans les requêtes LINQ. Elles permettent de filtrer, trier et projeter des collections facilement.

var nombres = new List<int> { 1, 2, 3, 4, 5, 6 };

// Filtrer les nombres pairs
var pairs = nombres.Where(x => x % 2 == 0);

Console.WriteLine(string.Join(", ", pairs)); // 2, 4, 6

// Calculer les carrés
var carres = nombres.Select(x => x * x);
Console.WriteLine(string.Join(", ", carres)); // 1, 4, 9, 16, 25, 36

Utilisation des Lambdas avec des Événements

Les expressions lambda offrent une méthode pratique pour gérer les événements. Elles permettent de capturer un événement rapidement sans définir une méthode séparée.

public class Button
{
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("Bouton cliqué !");
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Capturer l’événement avec une lambda
        btn.Click += (s, e) => Console.WriteLine("Événement : le bouton a été cliqué.");

        btn.SimulateClick();
    }
}

Fermeture (Closure) et Capture de Variables

Les expressions lambda peuvent accéder aux variables dans la portée où elles sont définies. Cela s’appelle une closure.

int compteur = 0;

Action incrementer = () =>
{
    compteur++;
    Console.WriteLine($"Compteur : {compteur}");
};

incrementer(); // Compteur : 1
incrementer(); // Compteur : 2

Ici, l’expression lambda “capture” la variable externe compteur et continue à l’utiliser.

Exemple : Filtrage et Rapport

Dans une application de magasin, les expressions lambda peuvent être utilisées pour filtrer les produits selon leur prix et générer des rapports.

public class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

class Program
{
    static void Main()
    {
        var produits = new List<Product>
        {
            new Product { Name = "Ordinateur portable", Price = 25000m },
            new Product { Name = "Souris", Price = 300m },
            new Product { Name = "Clavier", Price = 600m },
            new Product { Name = "Moniteur", Price = 4500m }
        };

        // Trouver les produits de plus de 1000 EUR
        var produitsChers = produits.Where(p => p.Price > 1000);

        foreach (var p in produitsChers)
        {
            Console.WriteLine($"{p.Name} - {p.Price} EUR");
        }

        // Calculer le prix moyen
        var moy = produits.Average(p => p.Price);
        Console.WriteLine($"Prix moyen : {moy:0.00} EUR");
    }
}

TL;DR

Articles connexes