Le Tutoriel de C# Delegate et Event

View more categories:

1- Qu'est - ce que Delegate?

En C#, chaque fonction (méthode ou constructeur) sont un type de fonction. Voir la méthode  SayHello ci-dessous :
Voyez l'exemple complet:
HelloProgram.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class HelloProgram
    { 
        // C'est la méthode qui a un paramètre de type string et renvoie string
        // Type de fonction:  (string) -> (string)
        public string SayHello(string name)
        {
            return "Hello " + name;
        }
        
        // C'est la méthode qui a deux paramètres et renvoie string
        // Type de fonction: (string, string) -> (string)
        public string SayHello(string firstName, string lastName)
        {
            return "Hello " + firstName + " " + lastName;
        }

        // C'est la méthode qui a un paramètre et ne renvoie rien.
        // Type de fonction: (string) -> ()
        public void Silent(string name)
        {

        }
    }


}
Les deux méthodes suivantes ont le même type de fonction:
C # en utilisant des mots clés délégué ( delegate) (représentatif) pour définir une entité représentative de la fonction (méthode ou constructeur) ont le même type de fonction.
Syntaxe:
// Syntaxe pour définir une delegate:
delegate <return_type> <delegate_name> <parameter_list>
Exemple:
// Définissez un type représentant le type de fonction
// (string,string) -> (string).
private delegate string MyDelegate(string s1, string s2);

2- Exemple avec delegate

MathUtils.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class MathUtils
    {

        // (int, int)  -> (int)
        public static int sum(int a, int b)
        {
            return a + b;
        }

        // (int, int)  -> (int)
        public static int minus(int a, int b)
        {
            return a - b;
        }

        // (int, int)  -> (int)
        public static int multiple(int a, int b)
        {
            return a * b;
        }
 

    }

}
.L'exemple ci-dessous définit un délégué représentant la fonction  IntIntToInt est une fonction du type (int, int) -> (int).
MyFirstDelegate.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class MyFirstDelegate
    {
        // Définit une delegate
        // représentant des fonctions de type(int, int) -> (int)
        delegate int IntIntToInt(int a, int b);



        public static void Main(string[] args)
        {
            // Créer un objet delegate.
            // Transmission (pass) pour le paramètre de fonction est une fonction du même type avec delegate.
            IntIntToInt iiToInt = new IntIntToInt(MathUtils.sum);

            // Lorsque vous exécutez une delegate.
            // Il appellera la fonction (ou la méthode) qu'elle représente.
            int value = iiToInt(10, 20); // 30

            Console.WriteLine("Value = {0}", value);

            // Affecter d'autres valeurs pour  delegate.
            iiToInt = new IntIntToInt(MathUtils.multiple);

            value = iiToInt(10, 20); // 200

            Console.WriteLine("Value = {0}", value);

            Console.Read();

        }


    }


}
Exécutez l'exemple:
Vous pouvez également créer un objet  délégué qui représente les fonctions non-statique (pas statique). Voir par exemple :
HelloProgramTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class HelloProgramTest
    {
        // Créez une Delegate
        // Représenter les types de fonctions: (string) -> (string).
        private delegate string StringStringToString(string s);



        public static void Main(string[] args)  
        {

            // Créez un object HelloProgram.
            HelloProgram program = new HelloProgram();

            // Créez un object Delegate représente la fonction SayHello.
            StringStringToString ssToS = new StringStringToString(program.SayHello);


            // Test 
            string greeting = ssToS("Tom");

            Console.WriteLine(greeting);

            Console.Read();
        }

    }


}

3- Fonction renvoie une fonction

En C #, avec  délégué, vous pouvez créer une fonction qui renvoie une fonction (Le fait qu'une fonction retourne un délégué).
TaxFormulas.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class TaxFormulas
    {
        // Un Delegate qui représente les fonctions de types (float) -> (float).
        public delegate float TaxFormula(float salary);

        // Formule de calcul de l'impôt américain (10% du salaire)..
        public static float UsaFormula(float salary)
        {
            return 10 * salary / 100;
        }

        // Formule de calcul de l'impôt du Vietnam (5% du salaire).
        public static float VietnamFormula(float salary)
        {
            return 5 * salary / 100;
        }

        // Formule de calcul de l'impôt par défaut (7% du salaire).
        public static float DefaultFormula(float salary)
        {
            return 7 * salary / 100;
        }

        // Renvoie une fonction pour calculer la taxe,
        // sur la base du code national (VN, USA, ...)
        public static TaxFormula GetSalaryFormula(string countryCode)
        {
            if (countryCode == "VN")
            {
                return TaxFormulas.VietnamFormula;
            }
            else if (countryCode == "USA")
            {
                return TaxFormulas.UsaFormula;
            }
            return TaxFormulas.DefaultFormula;
        }

    }

}
TaxFormulaTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class TaxFormulaTest
    {


        public static void Main(string[] args)
        {
            float salary = 1000f;

            // La formule pour calculer les taxes au Vietnam.
            TaxFormulas.TaxFormula formula = TaxFormulas.GetSalaryFormula("VN");

            float tax = formula(salary);

            Console.WriteLine("Tax in Vietnam = {0}", tax);

            // ​​​​​​​
            // La formule de calcul de l'impôt au Canada.
            formula = TaxFormulas.GetSalaryFormula("CA");

            tax = formula(salary);

            Console.WriteLine("Tax in Canada = {0}", tax);

            Console.Read();
        }
    }

}
 Exécutez l'exemple:

4- Méthodes anonymes

Basé sur le délégué, vous pouvez créer une méthode anonyme (méthode anonyme), elle est une méthode qui n'a pas de nom, seulement un corps (corps) de la méthode, elle est un bloc (bloc) a zéro ou plus participer nombre et peut-être le type de retour.
AnonymousMethod.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class AnonymousMethod
    {
        // Un Delegate qui représente les fonctions de types: (float) -> (float).
        // Calcul de l'impôt basé sur le salaire.
        public delegate float TaxFormula(float salary);


        public static TaxFormula GetTaxFormula(string countryCode)
        {
            if ("USA" == countryCode)
            {
                TaxFormula usaFormula = delegate(float salary)
                {
                    return 10 * salary / 100;
                };
                return usaFormula;
            }
            else if ("VN" == countryCode)
            {
                TaxFormula vnFormula = delegate(float salary)
                {
                    return 5 * salary / 100;
                };
                return vnFormula;
            }
            return delegate(float salary)
            {
                return 7 * salary / 100;
            };
        }


        public static void Main(string[] args)
        {
            string countryCode = "VN";
            float salary = 1000;

            TaxFormula formula = GetTaxFormula(countryCode);

            float tax = formula(salary);

            Console.WriteLine("countryCode = {0}, salary = {1} -> tax = {2}"
                                    , countryCode, salary, tax);

            Console.Read();
        }
    }

}
 Exécutez l'exemple:
 

5- Multicasting d'un Delegate

C # vous permet d'ajouter (+) deux objets Délégués ensemble pour former un nouvel objet Délégué. Notez que les objets Délégués peuvent être plus d'avoir le même type de fonction et la fonction n'a pas de type de retour. Lorsqu'un nouvel objet délégué est appelé, tous les délégués seront également exécutés. Ce concept appelé  Multicast de Délégué.
Greetings.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class Greetings
    {
        // Type de fonction: (String) -> ()
        public static void Hello(String name)
        {
            Console.WriteLine("Hello " + name);
        }

        // Type de fonction: (String) -> ()
        public static void Bye(string name)
        {
            Console.WriteLine("Bye " + name);
        }

        // Type de fonction: (String) -> ()
        public static void Hi(string name)
        {
            Console.WriteLine("Hi " + name);
        }
    }

}
MulticastingTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpDelegatesTutorial
{
    class MulticastingTest
    {
        // Déclarez un Delegate
        public delegate void Greeting(string name);


        public static void Main(string[] args)
        {
            // Créer des objets Delegate.
            Greeting hello = new Greeting(Greetings.Hello);
            Greeting bye = new Greeting(Greetings.Bye);
            Greeting hi = new Greeting(Greetings.Hi);
            
            // Créer un délégué (somme de deux délégués).
            Greeting greeting = hello + bye;
           
            // Vous pouvez également utiliser l'opérateur + =.
            greeting += hi;

            // Exécutez greeting.
            greeting("Tom");

            Console.Read();


        }
    }

}
Exécutez l'exemple:

6- Qu'est - ce que Event ?

En C #,  Event est un objet spécial de  Delegate, qui contient des méthodes qui seront exécutées simultanément lorsque l'événement a eu lieu. Vous pouvez ajouter les méthodes qui seront exécutées sur l'objet événement de l'objet émettant l'événement .

Exemple:

La classe  Button simule un bouton qui définit un Événement (événement) afin d'informer qu'il vient d'être cliqué. Lorsque le bouton est cliqué, l'événement sera exécuté. Vous devez ajouter les méthodes nécessitant l'exécution de l'événement depuis l'extérieur.
Button.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpEventsTutorial
{
    class Button
    {

        private string label;

        public delegate void ClickHander(Button source, int x, int y);

        // Définir un événement, il n'a pas été attribué de valeur.
        // Sa valeur est attribuée de l'extérieur.
        public event ClickHander OnButtonClick;

        public Button(string label)
        {
            this.label = label;
        }

        // Simuler ce Bouton est cliqué(Click).
        // Déterminez la position x, y que l'utilisateur clique.
        public void Clicked()
        {
            Random random = new Random();

            // Un nombre aléatoire entre 1 -> 100
            int x = random.Next(1, 100);

            // Un nombre aléatoire entre  1 -> 20
            int y = random.Next(1, 20);


            if (OnButtonClick != null)
            {
                // ​​​​​​​
                // Appelez les gestionnaires d'événements.
                OnButtonClick(this, x, y);
            }
            
        }
    }


}
Classe  MyApplication simule une application qui a deux boutons, "Ouvrir un fichier" et "Enregistrer le fichier" .

Vous devez écrire la méthode pour faire quelque chose lorsque l'utilisateur clique sur "Ouvrir le fichier" et ajouter cette méthode pour l'événement  OnButtonClick du bouton  openButton .

Vous devez écrire la méthode pour faire quelque chose lorsque l'utilisateur clique sur "Enregistrer le fichier" et ajouter cette méthode à l'événement  OnButtonClick du bouton  SaveButton .
MyApplication.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CSharpEventsTutorial
{
    class MyApplication
    {
        private Button openButton;
        private Button saveButton;
        private string fileName;

        // Simulation d'une application avec les Boutons.
        public MyApplication()
        {
            // Ajoutez un Bouton à l'interface.
            this.openButton = new Button("Open File");

            // Ajoutez un bouton à l'interface.
            this.saveButton = new Button("Save File");

            // Ajouter la méthode à l'événement du bouton 'Open Button'.
            // (Caractéristiques Multicasting de Delegate)
            this.openButton.OnButtonClick += this.OpenButtonClicked;

            // Ajouter la méthode à l'événement du bouton 'Save Button'.
            // (Caractéristiques Multicasting de Delegate)
            this.saveButton.OnButtonClick += this.SaveButtonClicked;
        }

        private void OpenButtonClicked(Button source, int x, int y)
        {
            // Simulation ouvre une fenêtre pour sélectionner le fichier à ouvrir.
            Console.WriteLine("Open Dialog to Select a file");
            // 
            this.fileName = "File" + x + "_" + y+".txt";
            Console.WriteLine("Openning file: "+ this.fileName);
        }

        private void SaveButtonClicked(Button source, int x, int y)
        {
            if(this.fileName== null)  {
                Console.WriteLine("No file to save!");
                return;
            }
            // Save File
            Console.WriteLine("Saved file: " + this.fileName);
        }
 

        public static void Main(string[] args)
        {

            // Simulation d'ouvrir de l'application
            MyApplication myApp = new MyApplication();

            Console.WriteLine("User Click on Open Button ....");

            // Simulation openButton est cliqué
            myApp.openButton.Clicked();

            Console.WriteLine("\n\n");
            Console.WriteLine("User Click on Save Button ....");

            // Simulation saveButton est cliqué
            myApp.saveButton.Clicked();


            Console.Read();
            
        }
    }

}
 Exécutez l'exemple:

View more categories: