12 : Délégués

Un délégué (delegate) est un type qui définit une signature de méthode. Ainsi, les instances de délégués peuvent pointer et invoquer une méthode ou une liste de méthodes qui correspondent à cette signature. Une déclaration de délégué consiste en un nom et une signture de méthode.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    delegate bool Filtre(string chaine, string compare);
    class Delegues
    {
        static void Main(string[] args)
        {
            Filtre f = new Filtre(DebutAlphabet);
            string[] animaux = new string[]
                { "Cheval", "Fourmi", "Girafe", "Lion", "Poule", "Vache", "Yack" };
            // affiche tous les animaux avant "L" dans l'alphabet
            Affiche(animaux, "L", DebutAlphabet);
            Console.ReadKey();
        }
        // méthode de filtre
        static bool DebutAlphabet(string chaine, string compare)
        {
            return compare.CompareTo(chaine) > 0;
        }
        // méthode d'affichage du résultat
        static void Affiche(string[] noms, string compare, Filtre f)
        {
            int cpt = 0;
            foreach (string nom in noms)
                if (f(nom, compare)) // invoque le délégué
                    Console.WriteLine("Chaine N°{0} : {1}", cpt++, nom);
        }
    }
}

Chaîne N°0 : Cheval
Chaîne N°1 : Fourmi
Chaîne N°2 : Girafe

Cet exemple affiche tous les animaux avant "L" dans l'alphabet...

Notez que la signature d'un délégué contient son type de retour. Il permet également l'utilisation d'un modificateur params dans sa liste de paramètres, ce qui étend la liste d'éléments qui caractérise une signature de méthode ordinaire. Le nom de la méthode cible n'a aucune importance pour le délégué.

12.1. Délégués multiples

Les délégués peuvent pointer et invoquer de nombreuses méthodes.

Code

Résultat

Remarques

using System;

namespace Exemples
{
    delegate void LanceMethode();
    public class Test
    {
        public Test()
        {
            LanceMethode methodes = null;
            methodes += new LanceMethode(Methode1);
            methodes += new LanceMethode(Methode2);
            methodes();
        }
        void Methode1()
        {
            Console.WriteLine("Methode1");
        }
        void Methode2()
        {
            Console.WriteLine("Methode2");
        }
    }
    class DeleguesMultiples1
    {
        static void Main(string[] args)
        {
            new Test(); // affiche Methode1 et Methode2
            Console.ReadKey();
        }
    }
}

Methode1
Methode2

Dans cet exemple, nous déclarons un délégué très simple appelé LanceMethode, que nous utilisons pour pointer et invoquer les méthodes methode1 et methode2 de manière séquentielle (en utilisant l'opérateur +=).

using System;

namespace Exemples
{
    delegate void LanceMethode();
    public class Test
    {
        public Test()
        {
            LanceMethode methodes = null;
            methodes += new LanceMethode(Methode1);
            methodes += new LanceMethode(Methode2);
            methodes -= new LanceMethode(Methode1);
            methodes();
        }
        void Methode1()
        {
            Console.WriteLine("Methode1");
        }
        void Methode2()
        {
            Console.WriteLine("Methode2");
        }
    }
    class DeleguesMultiples2
    {
        static void Main(string[] args)
        {
            new Test(); // affiche Methode2 uniquement
            Console.ReadKey();
        }
    }
}

Methode2

Un délégué peut également être supprimé d'un autre délégué en utilisant l'opérateur -=.

Les délégués sont invoqués dans l'ordre dans lequel ils sont ajoutés. Sil le type de retour d'un délégué est non vide, alors la valeur du dernier délégué invoqué est retournée.