C# Academy · Leçon

Fonctions locales ou lambdas

Choisissez entre les fonctions locales et les lambdas.

Fonctions locales ou lambdas est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Fonctions locales et lambdas

Les fonctions locales et les lambdas permettent toutes deux de définir de petites fonctions dans une méthode. Elles ont beaucoup de points communs, mais diffèrent par leur syntaxe, leurs capacités et leurs performances. Choisir la bonne option permet de garder un code clair et efficace.

Deux façons d'écrire une fonction auxiliaire

Ici, la même fonction auxiliaire de mise au carré est écrite à la fois comme fonction locale et comme lambda affectée à un délégué. Les deux produisent le même résultat.

using System;

public class Program
{
    public static void Main()
    {
        int SquareFn(int n) => n * n;       // local function
        Func<int, int> squareLambda = n => n * n; // lambda

        Console.WriteLine(SquareFn(4));
        Console.WriteLine(squareLambda(4));
    }
}

Les fonctions locales permettent facilement la récursivité

Une fonction locale peut s'appeler par son nom. Une lambda ne peut pas faire référence à sa propre variable pendant son initialisation ; la récursivité est donc moins naturelle avec les lambdas.

using System;

public class Program
{
    public static void Main()
    {
        // Clean recursion with a local function
        int Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
        Console.WriteLine(Factorial(5));
    }
}

Les fonctions locales peuvent être génériques

Les fonctions locales prennent en charge leurs propres paramètres de type. Les lambdas ne peuvent pas être génériques ; pour des fonctions auxiliaires typées et réutilisables, choisissez donc une fonction locale.

using System;

public class Program
{
    public static void Main()
    {
        T First<T>(T[] items) => items[0]; // generic local function

        Console.WriteLine(First(new[] { 9, 8, 7 }));
        Console.WriteLine(First(new[] { "a", "b" }));
    }
}

Performances : éviter l'allocation de délégués

Une lambda affectée à un délégué peut allouer un objet délégué et, si elle capture, une fermeture. Une fonction locale appelée directement évite ces deux allocations, ce qui compte dans les boucles très sollicitées.

using System;

public class Program
{
    public static void Main()
    {
        // Direct call, no delegate or closure allocation
        static int Add(int a, int b) => a + b;

        int total = 0;
        for (int i = 0; i < 5; i++) total = Add(total, i);
        Console.WriteLine(total);
    }
}

Paramètres out et ref

Les fonctions locales peuvent déclarer des paramètres out et ref ; les lambdas utilisant les délégués courants Func/Action ne le peuvent pas. Les fonctions locales sont donc naturelles pour les fonctions auxiliaires de type tentative d'analyse.

using System;

public class Program
{
    public static void Main()
    {
        bool TryGetFirstDigit(string s, out int digit)
        {
            digit = 0;
            foreach (var c in s)
                if (char.IsDigit(c)) { digit = c - '0'; return true; }
            return false;
        }

        if (TryGetFirstDigit("abc4", out int d))
            Console.WriteLine(d);
    }
}

Les expressions lambda comme arguments directs

Lorsque vous devez transmettre directement un comportement à une méthode comme LINQ Where ou Select, une expression lambda constitue l’option la plus concise et la plus lisible.

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

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
        var evens = nums.Where(n => n % 2 == 0).Select(n => n * 10);
        Console.WriteLine(string.Join(", ", evens));
    }
}

La capture fonctionne dans les deux cas

Les deux formes peuvent capturer des variables englobantes. La différence tient principalement à la syntaxe et au coût des allocations, et non à la possibilité d’effectuer une capture.

using System;

public class Program
{
    public static void Main()
    {
        int bonus = 10;
        int WithBonusFn(int n) => n + bonus;     // captures
        Func<int, int> withBonusLambda = n => n + bonus; // captures

        Console.WriteLine(WithBonusFn(5));
        Console.WriteLine(withBonusLambda(5));
    }
}

Affectation définie et ordre

Une fonction locale peut être appelée avant sa déclaration dans la méthode ; une variable lambda doit être affectée avant son utilisation. Les fonctions locales peuvent ainsi être placées de manière plus flexible.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Triple(4)); // allowed before declaration

        int Triple(int n) => n * 3;
    }
}

Choisir entre les deux

Utilisez une fonction locale pour les fonctions utilitaires nommées, réutilisables, récursives, génériques ou situées sur un chemin critique. Utilisez une expression lambda pour un comportement court intégré directement comme argument d’une autre méthode. Ce sont deux outils : choisissez selon votre intention.

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

public class Program
{
    public static void Main()
    {
        static bool IsPrime(int n)
        {
            if (n < 2) return false;
            for (int i = 2; i * i <= n; i++)
                if (n % i == 0) return false;
            return true;
        }

        var primes = Enumerable.Range(2, 20).Where(IsPrime);
        Console.WriteLine(string.Join(", ", primes));
    }
}

À vous de jouer

Utilisez une fonction locale récursive pour la logique principale et une expression lambda pour la projection LINQ intégrée, afin que chaque construction soit utilisée là où elle est la plus efficace.

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

public class Program
{
    public static void Main()
    {
        // Local function: recursive, named, reusable
        static int DigitCount(int n) => Math.Abs(n) < 10 ? 1 : 1 + DigitCount(n / 10);

        var nums = new List<int> { 5, 42, 1000, 7, 88 };
        // Lambda: concise inline projection
        var report = nums.Select(n => n + " has " + DigitCount(n) + " digits");
        foreach (var line in report) Console.WriteLine(line);
    }
}

Vérification rapide

Comparez les deux constructions.

Récapitulatif

Les fonctions locales et les expressions lambda se recoupent, mais présentent des différences importantes.

Les fonctions locales peuvent être récursives, génériques et utiliser out/ref.
Lorsqu’elles sont appelées directement, elles évitent les allocations de délégués et de fermetures.
Les expressions lambda sont particulièrement concises comme arguments directs de méthodes telles que LINQ.
Choisissez selon votre intention : fonction utilitaire nommée et réutilisable ou comportement court intégré.

Questions Fréquemment Posées

La leçon « Fonctions locales ou lambdas » est-elle gratuite ?

Oui — le texte complet de « Fonctions locales ou lambdas » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions locales ou lambdas » ?

Choisissez entre les fonctions locales et les lambdas. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Fonctions locales ou lambdas » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy