C# Academy · Leçon

Fonctions locales statiques

Empêchez les captures pour gagner en clarté et en performances.

Fonctions locales statiques est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 static

Marquer une fonction locale avec static lui interdit de capturer des variables englobantes ou this. La fonction est ainsi autonome, plus claire et exempte d'allocations de fermeture cachées.

Déclarer une fonction locale static

Ajoutez le modificateur static avant le type de retour. La fonction peut toujours prendre des paramètres et retourner des valeurs ; elle ne peut simplement pas accéder aux variables locales externes.

using System;

public class Program
{
    public static void Main()
    {
        static int Square(int n) => n * n; // captures nothing

        Console.WriteLine(Square(6));
    }
}

Aucune capture autorisée

Une fonction locale static ne peut pas utiliser les variables locales englobantes. Tout ce dont elle a besoin doit lui être transmis comme paramètre, ce qui rend ses entrées explicites.

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        // factor must be passed in, not captured
        static int Scale(int n, int f) => n * f;

        Console.WriteLine(Scale(5, factor));
    }
}

Éviter les allocations cachées

Les fonctions locales non static qui capturent des variables peuvent allouer un objet de fermeture caché. Une fonction locale static ne capture rien et évite donc entièrement cette allocation.

using System;

public class Program
{
    public static void Main()
    {
        // Pure helper, no closure object created
        static bool IsEven(int n) => n % 2 == 0;

        for (int i = 0; i < 5; i++)
            Console.WriteLine(i + ": " + IsEven(i));
    }
}

Une intention explicite

Le mot-clé static indique aux lecteurs que la fonction auxiliaire dépend uniquement de ses arguments. Cette garantie la rend plus facile à comprendre et à tester.

using System;

public class Program
{
    public static void Main()
    {
        static int Clamp(int value, int lo, int hi)
            => value < lo ? lo : value > hi ? hi : value;

        Console.WriteLine(Clamp(15, 0, 10));
        Console.WriteLine(Clamp(-3, 0, 10));
    }
}

Le compilateur interdit la capture

Si vous faites accidentellement référence à une variable locale englobante dans une fonction locale static, le compilateur signale une erreur. Cela permet de détecter rapidement les dépendances involontaires.

using System;

public class Program
{
    public static void Main()
    {
        int seed = 7;
        // Correct: seed is passed explicitly, not captured
        static int Mix(int x, int s) => x * 31 + s;

        Console.WriteLine(Mix(2, seed));
    }
}

Fonctions locales static avec récursivité

Les fonctions locales static prennent toujours en charge la récursivité, car s'appeler elles-mêmes n'est pas la même chose que capturer une variable.

using System;

public class Program
{
    public static void Main()
    {
        static int Power(int baseN, int exp)
            => exp == 0 ? 1 : baseN * Power(baseN, exp - 1);

        Console.WriteLine(Power(2, 10));
    }
}

Combiner avec des paramètres out

Comme n'importe quelle méthode, les fonctions locales static peuvent utiliser des paramètres out, ce qui s'associe bien à leur absence de capture pour les fonctions auxiliaires de type tentative d'analyse.

using System;

public class Program
{
    public static void Main()
    {
        static bool TryParsePositive(string s, out int value)
        {
            value = 0;
            return int.TryParse(s, out value) && value > 0;
        }

        if (TryParsePositive("42", out int n))
            Console.WriteLine("got " + n);
        Console.WriteLine(TryParsePositive("-1", out _));
    }
}

Passer des fonctions locales static comme délégués

Comme elles ne capturent rien, les fonctions locales static se convertissent en délégués sans allouer de fermeture, ce qui peut être important dans les chemins très sollicités.

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

public class Program
{
    public static void Main()
    {
        static bool IsBig(int n) => n > 100;

        var nums = new List<int> { 50, 150, 200, 10 };
        Console.WriteLine(nums.Count(IsBig));
    }
}

Quand préférer static

Préférez une fonction locale static lorsque la fonction auxiliaire n'a pas besoin de l'état englobant. Cela documente sa pureté, empêche les captures accidentelles et peut améliorer l'efficacité. Omettez static uniquement lorsque vous devez réellement capturer des variables locales.

using System;

public class Program
{
    public static void Main()
    {
        static string Describe(int score)
        {
            if (score >= 90) return "A";
            if (score >= 80) return "B";
            return "C";
        }

        Console.WriteLine(Describe(95));
        Console.WriteLine(Describe(82));
    }
}

À vous de jouer

Écrivez une fonction locale static pure et transmettez-la comme prédicat à LINQ. Comme elle ne capture rien, elle se convertit en délégué sans fermeture.

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

public class Program
{
    public static void Main()
    {
        static bool IsLeapYear(int year)
            => (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

        var years = new List<int> { 1900, 2000, 2004, 2021, 2024 };
        Console.WriteLine(string.Join(", ", years.Where(IsLeapYear)));
    }
}

Vérification rapide

Rappelez-vous ce que static ajoute à une fonction locale.

Récapitulatif

Une fonction locale static ne capture rien.

Elle ne peut pas utiliser les variables locales englobantes ni this ; transmettez les données par des paramètres.
Elle évite les allocations de fermeture cachées.
Le compilateur impose la règle d'absence de capture et détecte les dépendances accidentelles.
Préférez-la lorsque la fonction auxiliaire n'a pas besoin de l'état englobant.

Questions Fréquemment Posées

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

Oui — le texte complet de « Fonctions locales statiques » 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 statiques » ?

Empêchez les captures pour gagner en clarté et en performances. 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 3 sur 4.

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

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