la programmation

Délégués en C#: Flexibilité Dynamique

En langage C#, les délégués (ou « delegates » en anglais) sont des types de données qui permettent de déclarer, assigner et appeler des méthodes de manière dynamique. Ils fournissent une manière flexible et puissante de réaliser des opérations telles que les événements, les rappels (callbacks) et la programmation orientée événements.

Articles similaires

Un délégué est essentiellement un type qui représente des méthodes avec une signature spécifique. Il peut être utilisé pour passer des méthodes en tant que paramètres à d’autres méthodes, ou pour stocker une référence à une méthode. En d’autres termes, les délégués permettent de traiter les méthodes comme des entités de première classe, ce qui signifie qu’elles peuvent être manipulées et passées comme des paramètres de la même manière que les variables.

Pour déclarer un délégué en C#, vous utilisez le mot-clé delegate, suivi de la signature de la méthode que le délégué représente. Par exemple :

csharp
delegate void MonDelegate(int x, int y);

Cette déclaration crée un nouveau type de délégué appelé MonDelegate, qui peut représenter n’importe quelle méthode prenant deux entiers en paramètres et retournant void.

Une fois qu’un délégué est défini, vous pouvez l’instancier en lui passant une méthode qui correspond à sa signature. Par exemple :

csharp
class Program
{
    static void Main(string[] args)
    {
        MonDelegate delegateInstance = MaMethode;
        delegateInstance(10, 20); // Appelle la méthode MaMethode avec les arguments 10 et 20
    }

    static void MaMethode(int x, int y)
    {
        Console.WriteLine($"La somme de {x} et {y} est : {x + y}");
    }
}

Dans cet exemple, delegateInstance est instancié avec la méthode MaMethode. Lorsque delegateInstance est appelé, il appelle effectivement MaMethode avec les arguments fournis.

Les délégués peuvent également être utilisés pour créer des événements dans C#. Un événement est essentiellement une notification qu’une classe peut déclencher pour informer d’autres parties du programme qu’une action spécifique s’est produite. Par exemple :

csharp
class Button
{
    public event EventHandler Click;

    public void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Button button = new Button();
        button.Click += Button_Click; // Abonnez-vous à l'événement Click
        button.OnClick(); // Déclenche l'événement Click
    }

    static void Button_Click(object sender, EventArgs e)
    {
        Console.WriteLine("Le bouton a été cliqué !");
    }
}

Dans cet exemple, la classe Button définit un événement Click, qui est un délégué de type EventHandler. Lorsque la méthode OnClick est appelée, elle déclenche l’événement Click, ce qui à son tour appelle toutes les méthodes abonnées à cet événement.

En résumé, les délégués en C# offrent une manière flexible et puissante de travailler avec des méthodes, en leur permettant d’être passés comme des paramètres, stockés en tant que variables et utilisés pour créer des événements. Ils sont largement utilisés dans le développement d’applications .NET pour implémenter des fonctionnalités telles que les événements, les rappels et la programmation orientée événements.

Plus de connaissances

Bien sûr, plongeons un peu plus dans les détails des délégués en C#.

Utilisation des délégués

  1. Passage de méthodes en tant que paramètres : Les délégués permettent de passer des méthodes comme des paramètres à d’autres méthodes. Cela peut être utile pour fournir une logique personnalisée à une méthode sans avoir à la réécrire plusieurs fois. Par exemple :
csharp
class Calculateur
{
    public int EffectuerOperation(int x, int y, Func<int, int, int> operation)
    {
        return operation(x, y);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Calculateur calculateur = new Calculateur();
        int somme = calculateur.EffectuerOperation(10, 5, (a, b) => a + b);
        Console.WriteLine("Somme : " + somme); // Affiche : Somme : 15
    }
}

Dans cet exemple, EffectuerOperation prend une méthode prenant deux entiers en paramètres et renvoyant un entier. Nous passons une lambda expression (a, b) => a + b qui représente une méthode effectuant une addition.

  1. Délégués prédéfinis : .NET Framework fournit plusieurs délégués prédéfinis dans l’espace de noms System et System.Collections.Generic. Par exemple, Action est un délégué prédéfini qui ne retourne pas de valeur, tandis que Func est un délégué générique prédéfini qui peut prendre jusqu’à 16 paramètres et renvoyer une valeur.
csharp
Action<int, int> action = (x, y) => Console.WriteLine(x + y);
action(3, 4); // Affiche : 7

Func<int, int, int> fonction = (x, y) => x * y;
int produit = fonction(3, 4); // produit vaut 12
  1. Combinaison de délégués : Les délégués peuvent être combinés à l’aide des opérateurs + et -. Lorsque plusieurs délégués sont combinés, ils sont invoqués séquentiellement lors de l’appel du délégué résultant.
csharp
Action<int> methode1 = x => Console.WriteLine("Méthode 1 : " + x);
Action<int> methode2 = x => Console.WriteLine("Méthode 2 : " + x);

Action<int> methodeCombinee = methode1 + methode2;
methodeCombinee(5);
// Affiche :
// Méthode 1 : 5
// Méthode 2 : 5
  1. Déclaration de délégué multicas : Les délégués multicas permettent d’appeler plusieurs méthodes en une seule invocation de délégué.
csharp
delegate void MonDelegateMulticast(int x);

void Methode1(int x) => Console.WriteLine("Méthode 1 : " + x);
void Methode2(int x) => Console.WriteLine("Méthode 2 : " + x);

MonDelegateMulticast delegateMulticast = Methode1;
delegateMulticast += Methode2;

delegateMulticast(10);
// Affiche :
// Méthode 1 : 10
// Méthode 2 : 10
  1. Gestion de la nullabilité : À partir de C# 8.0, les délégués peuvent être marqués comme étant nullable ou non-nullable. Cela permet de spécifier si un délégué peut être null ou non.
csharp
delegate void MonDelegateNonNull(int x)!;
delegate void MonDelegateNullable(int x)?;

MonDelegateNonNull delegateNonNull = Methode1; // Ne peut pas être null
MonDelegateNullable? delegateNullable = null; // Peut être null

Utilisation des délégués avec des événements

Les délégués sont couramment utilisés pour créer des événements dans C#. Un événement est une manière pour une classe d’informer les autres classes qu’un événement s’est produit. Les délégués sont utilisés pour définir la signature de l’événement.

csharp
public class Bouton
{
    public event EventHandler Clic;

    protected virtual void OnClic(EventArgs e)
    {
        Clic?.Invoke(this, e);
    }

    public void SimulerClic()
    {
        OnClic(EventArgs.Empty);
    }
}

public class Observateur
{
    public Observateur(Bouton bouton)
    {
        bouton.Clic += BoutonClic;
    }

    private void BoutonClic(object sender, EventArgs e)
    {
        Console.WriteLine("Le bouton a été cliqué !");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Bouton bouton = new Bouton();
        Observateur observateur = new Observateur(bouton);

        bouton.SimulerClic(); // Déclenche l'événement Clic
    }
}

Dans cet exemple, la classe Bouton définit un événement Clic, qui est invoqué lorsqu’un bouton est cliqué. La classe Observateur s’abonne à cet événement lors de son initialisation, et réagit en conséquence lorsqu’un clic se produit.

Conclusion

Les délégués en C# offrent une flexibilité et une puissance considérables dans la manière dont les méthodes peuvent être manipulées et utilisées dans un programme. Que ce soit pour la mise en œuvre de rappels, la gestion des événements ou la fourniture de logique personnalisée à des méthodes existantes, les délégués sont un outil essentiel pour les développeurs C#.

Bouton retour en haut de la page