Programmation fonctionnelle en C# : de A à Z — guide complet

Programmation fonctionnelle en C# : de A à Z

La programmation fonctionnelle (PF) est un paradigme qui considère le calcul comme l'évaluation de fonctions mathématiques et évite les états modifiables et les effets de bord. Bien que C# soit un langage multi-paradigme avec un fort support de la programmation orientée objet (POO), ses versions modernes (à partir de C# 3.0 et suivantes) intègrent activement des éléments de style fonctionnel. Cela permet d'écrire un code plus concis, prévisible et facilement testable.

Dans cet article, nous parcourrons le chemin des bases aux techniques avancées de programmation fonctionnelle en C# dans le contexte de .NET. Vous apprendrez à utiliser les expressions lambda, LINQ, les types de données immuables et les patrons pour créer des applications robustes.

1. Bases : Expressions lambda et Délégués

Le cœur de l'approche fonctionnelle en C# sont les expressions lambda — ce sont des fonctions anonymes qui peuvent être utilisées pour créer des délégués ou des arbres d'expression. Elles permettent de passer le comportement comme des données.

Considérons un exemple classique de tri d'une liste. Au lieu de créer une méthode de comparaison séparée, nous utilisons une lambda :

using System;using System.Collections.Generic;

public class LambdaExample{    public static void Main()    {        var numbers = new List<int> { 5, 3, 8, 1, 9 };                // Tri décroissant à l'aide d'une expression lambda        numbers.Sort((x, y) => y.CompareTo(x));                Console.WriteLine(string.Join(", ", numbers));         // Affichage : 9, 8, 5, 3, 1    }}

Les concepts clés qui interviennent ici :

• Délégués Func<> et Action<> : Func<T, TResult> retourne une valeur, Action<T> non. Les lambdas sont implicitement converties en ces types.
• Fermetures (Closures) : Une lambda peut capturer des variables de la portée externe, ce qui en fait un outil puissant, mais nécessite de la prudence en raison des effets de bord possibles.

2. LINQ : Style déclaratif de travail avec les données

Language Integrated Query (LINQ) est sans doute l'exemple le plus frappant de l'application de la PF en C#. Il permet d'écrire des requêtes déclaratives sur des collections, des bases de données et du XML, en utilisant des chaînes de méthodes.

Au lieu de boucles impératives foreach, nous utilisons des opérations fonctionnelles :

using System;using System.Linq;using System.Collections.Generic;

public class LinqExample{    public static void Main()    {        var people = new List<Person>        {            new Person { Name = "Alice", Age = 30 },            new Person { Name = "Bob", Age = 17 },            new Person { Name = "Charlie", Age = 25 }        };

        // Requête fonctionnelle : filtrage, projection, tri        var result = people            .Where(p => p.Age >= 18)                    // Filtrage (prédicat)            .OrderBy(p => p.Name)                       // Tri            .Select(p => new { p.Name, IsAdult = true }) // Projection (type anonyme)            .ToList();

        foreach (var item in result)        {            Console.WriteLine($"{item.Name} - Adult: {item.IsAdult}");        }        // Affichage : Alice - Adult: True, Charlie - Adult: True    }

    public class Person    {        public string Name { get; set; }        public int Age { get; set; }    }}

Opérateurs LINQ clés :

• Where — filtrage (analogue à filter).
• Select — transformation (analogue à map).
• Aggregate — réduction (analogue à reduce).
• Any, All — vérification de conditions.

Il est important de se souvenir de l'exécution différée