C# Academy · Leçon

Déclarer des fonctions locales

Définissez des fonctions auxiliaires à l’intérieur des méthodes.

Déclarer des fonctions locales est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu'est-ce qu'une fonction locale ?

Une fonction locale est une méthode déclarée à l'intérieur d'une autre méthode. Elle n'est visible que dans son membre englobant, ce qui garde la logique auxiliaire près de son utilisation et en dehors de la surface de la classe.

En déclarer une

Écrivez la fonction locale comme une méthode ordinaire, imbriquée dans le corps de la méthode. Vous pouvez l'appeler avant ou après sa déclaration dans la même portée.

using System;

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

        Console.WriteLine(Square(4));
        Console.WriteLine(Square(7));
    }
}

Fonctions locales avec bloc d'instructions

Les fonctions locales peuvent avoir des corps complets avec plusieurs instructions, des boucles et leurs propres variables locales, comme n'importe quelle méthode.

using System;

public class Program
{
    public static void Main()
    {
        int Factorial(int n)
        {
            int result = 1;
            for (int i = 2; i <= n; i++) result *= i;
            return result;
        }

        Console.WriteLine(Factorial(5));
    }
}

Améliorer la lisibilité

Les fonctions locales vous permettent de nommer une partie de la logique sans encombrer la classe d'une méthode privée utilisée par une seule méthode. Le code associé reste ainsi regroupé.

using System;

public class Program
{
    public static void Main()
    {
        string Format(string label, int value) => label + ": " + value;

        Console.WriteLine(Format("Score", 90));
        Console.WriteLine(Format("Level", 3));
    }
}

Récursivité avec des fonctions locales

Une fonction locale peut s'appeler elle-même, ce qui permet d'exprimer facilement la récursivité exactement là où elle est nécessaire.

using System;

public class Program
{
    public static void Main()
    {
        int Fib(int n) => n < 2 ? n : Fib(n - 1) + Fib(n - 2);

        for (int i = 0; i < 7; i++)
            Console.Write(Fib(i) + " ");
        Console.WriteLine();
    }
}

Les fonctions locales peuvent être déclarées après leur utilisation

Contrairement aux variables locales, une fonction locale peut être référencée plus tôt dans la méthode qu'à l'endroit où elle est déclarée. Le compilateur résout l'ensemble de la portée englobante.

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Greet("Ada")); // used before declared

        string Greet(string name) => "Hello, " + name;
    }
}

Paramètres et types de retour

Les fonctions locales prennent en charge tout ce que font les méthodes ordinaires : plusieurs paramètres, des valeurs de retour, des paramètres ref et out, ainsi que les types génériques.

using System;

public class Program
{
    public static void Main()
    {
        bool TryHalve(int n, out int half)
        {
            half = n / 2;
            return n % 2 == 0;
        }

        if (TryHalve(10, out int result))
            Console.WriteLine("half is " + result);
    }
}

Fonctions locales génériques

Une fonction locale peut être générique et être paramétrée par ses propres arguments de type, indépendamment de la méthode englobante.

using System;

public class Program
{
    public static void Main()
    {
        T Echo<T>(T value)
        {
            Console.WriteLine("echoing " + value);
            return value;
        }

        int n = Echo(42);
        string s = Echo("hi");
        Console.WriteLine(n + " " + s);
    }
}

Imbriquer des fonctions locales

Les fonctions locales peuvent elles-mêmes contenir des fonctions locales. Les fonctions internes ne sont visibles que dans leur parent, ce qui permet de créer des niveaux auxiliaires à portée étroitement limitée.

using System;

public class Program
{
    public static void Main()
    {
        int Compute(int x)
        {
            int Double(int n) => n * 2;
            int AddOne(int n) => n + 1;
            return Double(AddOne(x));
        }

        Console.WriteLine(Compute(5));
    }
}

Fonctions locales pour valider les arguments

Un schéma courant consiste à valider les arguments immédiatement, puis à différer le véritable travail dans une fonction locale. C'est particulièrement utile avec les itérateurs, afin que la validation s'exécute immédiatement.

using System;
using System.Collections.Generic;

public class Program
{
    static IEnumerable<int> Range(int start, int count)
    {
        if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
        return Iterate();

        IEnumerable<int> Iterate()
        {
            for (int i = 0; i < count; i++) yield return start + i;
        }
    }

    public static void Main()
    {
        foreach (var n in Range(10, 3)) Console.WriteLine(n);
    }
}

Quand utiliser les fonctions locales

Choisissez une fonction locale lorsqu'une fonction auxiliaire est utilisée par une seule méthode, qu'elle bénéficie d'un nom explicite ou qu'elle doit accéder à l'état local de la méthode. La classe reste ainsi claire et la logique facile à trouver.

using System;

public class Program
{
    public static void Main()
    {
        int total = 0;
        void Add(int n) => total += n; // helper tied to this method
        Add(3); Add(4); Add(5);
        Console.WriteLine(total);
    }
}

Vérification rapide

Rappelez-vous ce qu'est une fonction locale.

Récapitulatif

Les fonctions locales sont des fonctions auxiliaires nommées, imbriquées dans une méthode.

Elles ne sont visibles que dans leur membre englobant.
Elles prennent en charge les paramètres, les valeurs de retour, out/ref, les types génériques et la récursivité.
Elles peuvent être référencées avant leur déclaration.
Elles sont idéales pour les fonctions auxiliaires utilisées une seule fois et pour la validation immédiate des arguments dans les itérateurs.

Questions Fréquemment Posées

La leçon « Déclarer des fonctions locales » est-elle gratuite ?

Oui — le texte complet de « Déclarer des fonctions locales » 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 « Déclarer des fonctions locales » ?

Définissez des fonctions auxiliaires à l’intérieur des méthodes. 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 1 sur 4.

Combien de temps prend la leçon « Déclarer des fonctions locales » ?

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