C# Academy · Leçon

delegate, Action/Func et fermetures

Transmettez un comportement au moyen de délégués : déclarez des délégués personnalisés, utilisez Action/Func intégrés et observez comment les lambdas capturent les variables (fermetures).

delegate, Action/Func et fermetures est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. 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 3 leçons au total.

Présentation des delegate

Objectif : traiter les méthodes comme des données.

Définissez un type delegate
Utilisez Action/Func
Créez des expressions lambda
Comprenez les fermetures (variables capturées)

Principes des delegate personnalisés

Un delegate est un pointeur de fonction dont le typage est sûr. Affectez-lui des méthodes compatibles et appelez-le comme une fonction.

using System;

// Custom delegate type: a method taking two ints and returning int
public delegate int Op(int x, int y);

public class Program
{
  static int Add(int a, int b) { return a + b; }
  static int Mul(int a, int b) { return a * b; }

  public static void Main(string[] args)
  {
    Op f = Add;                // method group conversion
    Console.WriteLine(f(2, 3)); // 5
    f = Mul;
    Console.WriteLine(f(2, 3)); // 6
  }
}

Action et Func

Action représente les méthodes qui renvoient void ; Func renvoie une valeur. Utilisez des groupes de méthodes ou des expressions lambda.

using System;

public class Program
{
  static void Log(string s) { Console.WriteLine("LOG: " + s); }

  public static void Main(string[] args)
  {
    Action<string> a = Log;                        // no return
    a("hello");

    Func<int, int, int> sum = delegate(int x, int y) { return x + y; }; // lambda/anon method
    Console.WriteLine(sum(3, 4)); // 7

    // Method group to Func
    Func<string, int> len = GetLen;
    Console.WriteLine(len("abc")); // 3
  }

  static int GetLen(string s) { return s == null ? 0 : s.Length; }
}

Démonstration des fermetures

Une fermeture capture des variables de la portée externe. La variable survit à la méthode qui a créé le delegate.

using System;

public class Program
{
  public static void Main(string[] args)
  {
    int counter = 0; // captured variable (lives as long as delegate)
    Action inc = delegate() { counter = counter + 1; Console.WriteLine(counter); };

    inc(); // 1
    inc(); // 2
    Console.WriteLine("Final=" + counter); // 2
  }
}

Méthode d’ordre supérieur

Passez un Func ou un Action pour personnaliser le comportement. C’est la base de nombreuses interfaces de programmation (et de LINQ).

using System;

public class Program
{
  // Apply a transform to each number and sum the results
  static int SumBy(int[] xs, Func<int, int> transform)
  {
    int total = 0;
    for (int i = 0; i < xs.Length; i++)
    {
      total += transform(xs[i]);
    }
    return total;
  }

  public static void Main(string[] args)
  {
    int[] data = new int[] { 1, 2, 3 };
    int sumSquares = SumBy(data, delegate(int x) { return x * x; });
    Console.WriteLine(sumSquares); // 14
  }
}

Conseils sur les delegate

Conseils :

Préférez Action/Func pour éviter des types delegate personnalisés supplémentaires.
Gardez les expressions lambda courtes et claires.
Soyez attentif aux variables capturées ; leur valeur peut changer ultérieurement.
Utilisez des groupes de méthodes lorsqu’une méthode nommée correspond déjà à la signature.

Signification de Func et Action

Vérification rapide : quel type de delegate intégré représente une méthode qui renvoie une valeur ?

Récapitulatif

Récapitulatif : déclarez des types delegate, utilisez Action/Func et écrivez de petites expressions lambda. Les fermetures permettent aux expressions lambda de capturer des variables locales : utilisez-les avec précaution.

Questions Fréquemment Posées

La leçon « delegate, Action/Func et fermetures » est-elle gratuite ?

Oui — le texte complet de « delegate, Action/Func et fermetures » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « delegate, Action/Func et fermetures » ?

Transmettez un comportement au moyen de délégués : déclarez des délégués personnalisés, utilisez Action/Func intégrés et observez comment les lambdas capturent les variables (fermetures). 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 3.

Combien de temps prend la leçon « delegate, Action/Func et fermetures » ?

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

delegate, Action/Func et fermetures
Événements : publication/abonnement, mot-clé event
Modèles d’événements et pièges (fuites mémoire)

← Retour à C# Academy