Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C#

Fonctions et paramètres : application partielle et fermetures

Découvrez les méthodes, les fonctions locales et les lambdas en C#. Apprenez la différence entre paramètres et arguments, comment créer une fonction dont un argument est fixé, et pourquoi une fermeture observe les modifications d’une variable capturée.

Version : .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification

Syntaxe

static int Add(int left, int right) => left + right;
Func<int, int> addTen = value => Add(10, value);

En C#, un comportement peut être exprimé par une méthode, une fonction locale ou une fonction anonyme, comme une lambda. Une méthode appartient à un type. Une fonction locale peut être déclarée dans le corps d’un membre ou parmi les instructions de niveau supérieur, sans déclaration de membre englobante dans le code source. La forme value => expression est un exemple de lambda qui prend un seul paramètre et dont le corps est une expression. Une lambda peut prendre zéro, un ou plusieurs paramètres, et son corps peut être une expression ou un bloc d’instructions. Un paramètre est une variable nommée dans une déclaration ; un argument est une valeur ou une expression fournie lors d’un appel. Par défaut, les arguments sont passés par valeur ; pour un type référence, c’est la référence qui est copiée, pas l’objet.

Un délégué permet de stocker et de transmettre un comportement appelable. Func<int, int> désigne un délégué qui accepte un int et renvoie un int ; Action<int> ne renvoie aucune valeur. Une lambda peut être convertie en un type de délégué compatible. Les fonctions locales conviennent aux opérations auxiliaires nommées, tandis que les lambdas conviennent aux comportements courts transmis comme arguments.

L’application partielle consiste à fixer certains arguments et à créer une fonction qui accepte les autres. C# ne le fait pas automatiquement lorsqu’on omet un argument obligatoire : on peut créer explicitement une lambda qui encapsule l’appel. Dans l’exemple, BindLeft(10) renvoie un délégué qui n’a plus besoin que de right. Cela diffère d’un paramètre facultatif, qui fournit une valeur par défaut lors de l’appel.

Une fermeture associe une fonction aux variables capturées dans sa portée environnante. C’est la variable qui est capturée, et non un instantané de sa valeur : après offset = 20, l’appel de addOffset(3) produit 23. Une variable capturée peut vivre plus longtemps que l’appel qui l’a créée, comme left dans BindLeft. Attention à l’état mutable partagé et aux objets conservés en mémoire plus longtemps. Une lambda ou une fonction locale marquée static ne peut pas capturer de variables locales ni l’état d’une instance.

Identifiants de référence couverts par cette entrée : Partial application and closures.

Exemples

using System;

internal static class Program
{
    private static int Add(int left, int right) => left + right;

    private static Func<int, int> BindLeft(int left) =>
        right => Add(left, right);

    private static void Main()
    {
        Func<int, int> addTen = BindLeft(10);
        Console.WriteLine(addTen(3));

        int offset = 10;
        Func<int, int> addOffset = value => Add(offset, value);
        offset = 20;
        Console.WriteLine(addOffset(3));
    }
}

Résultat

13
23

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources