Delégués et évènements

Version imprimable

Je me suis fais un petit exemple pour bien comprendre les évènements.

Par contre j'aimerai utiliser des delegates pour personnaliser mes évènements.

Voici mon petit programme (vous pouvez l'essayer il fonctionne):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
using System;
 
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
using System.Threading;
 
namespace EventTests
{    
 
    //Classe qui déclare les évènements    
    public class EventsManager
    {
 
        /* CE QUE J AIMERAI FAIRE */
 
        //public delegate void CustomEventHandler(object e, EventArgs ea);
        //public event CustomEventHandler Event1;
        //public event CustomEventHandler Event2;
 
        /* CE QUE JE FAIS A LA PLACE */
 
        //Déclaration des évènements
        public EventHandler Event1;
        public EventHandler Event2;
 
    }
 
    //classe métier 
    public class Model
    {     
        private EventsManager eventsManager;    
 
        public Model(EventsManager eventsManager)
        {
            this.eventsManager = eventsManager;
        }
 
        public void method1()
        {
        //Méthode 1 qui génère un évènement 1
            if (eventsManager.Event1 != null)
                eventsManager.Event1(this,EventArgs.Empty);
        }
 
        //Méthode 2 qui génère un évènement 2
        public void method2()
        {
            if (eventsManager.Event2 != null)
                eventsManager.Event2(this, EventArgs.Empty);
        }        
    }
 
 
    //Ecouter des évènements
    public class CustomEventListener
    {        
        private EventsManager em;
 
        public CustomEventListener(EventsManager em)
        {
            this.em = em;
 
            //on associe les évènements aux actions            
            em.Event1 += this.Action1;  //l'action 1 est abonnée à l'évènement 1                        
            em.Event2 += this.Action2;  //l'action 2 est abonnée à l'évènement 2     
        }        
 
        //Différentes actions possibles de l'écouteur
        public void Action1(object sender, EventArgs e)
        {
            Console.WriteLine("action 1");
        }
 
        public void Action2(object sender, EventArgs e)
        {
            Console.WriteLine("action 2");
        }
 
    }
 
    //Exécution du programme
    public class MainTestEvents
    {
        public static void Main(string[] args)
        {
            //on créer les évènements
            EventsManager eventManager = new EventsManager();
 
            //on crée l'écouteur
            CustomEventListener e = new CustomEventListener(eventManager);
 
            //on crée le modèle
            Model model = new Model(eventManager);
 
            model.method1();                       
 
            model.method2();
 
            Console.ReadLine();
        }
 
    }
}

Vous l'aurez compris je n'arrive pas à déclarer mes évènements à partir de delegate.

Message d'erreur

Citation:

Event1 ne peut apparaître qu'à gauche de += ...

Une solution?
peut être que ce model n'est pas bon ?

merci

28/05/2009, 17h53
emmr.rida

Pour déclarer un événement :

Code:

public event EventHandler nom_evenement;
28/05/2009, 18h48
StormimOn

Il suffit de lire la MSDN avec Événements (Guide de programmation C#)

Et dans le cas qui t'intéresse Comment : publier des événements conformes aux indications du .NET Framework (Guide de programmation C#)

;)
29/05/2009, 11h25
piotrr

J'avais déjà vu cet exemple :
Comment : publier des événements conformes aux indications du .NET Framework (Guide de programmation C#)

Mais je ne suis pas très satisfait par celui - ci.

En effet les évènements sont directement déclarés dans les classes métiers.
Si on suit ce raisonnement, on ne peut pas utiliser le même évènement dans plusieurs classes métiers différentes.
29/05/2009, 11h48
Guulh

Citation:

Envoyé par piotrr

Si on suit ce raisonnement, on ne peut pas utiliser le même évènement dans plusieurs classes métiers différentes.

Qu'y a -t-il d'étonnant à ce qu'un événement soit fortement lié à celui qui l'émet ? :)

Si tu veux t'assurer que n classes émettent un événement similaire, tu peux les faire hériter d'une même classe de base, ou leur faire implémenter une même interface.
Par exemple, l'event Click est défini au niveau de Control, pas au niveau de TextBox / ComboBox.

Ce que je veux c'est que n'importe quelle méthode de n'importe quelle classe puisse générer n'importe quelle évènement.

Voici la solution que je propose :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
using System;
 
using System.Collections.Generic;
 
namespace modelEvents
{     
 
    //Classe métier 
    public class ModelHelloClass
    {
        public void HelloWorld()
        {            
            String textHelloWorld = "Hello World";
 
            //elle génère un évènement de type "HelloEventHandler"
            HelloEventHandler.Raise(textHelloWorld);    //on génère l'évènement dans la méthode
        }
    }
 
    //Vue
    public class ViewHelloClass
    {
        public void methodDisplayingHelloWorld(String value)
        {
            //la méthode affiche ce qu'elle reçoit en paramètre
            Console.WriteLine(value); //traitement des données reçues 
 
            //elle génère un évènement de type "HelloPerformedEventHandler"
            HelloPerformedEventHandler.Raise();    //cette méthode génère aussi un évènement
        }
    }
 
 
    /* GESTION DES EVENEMENTS */
 
    //Evènement appellé par la méthode HelloWorld
    public class HelloEventHandler
    {
        //déclaration du delegate
        public delegate void HelloHandler(String value);
 
        //évènement statique qui peut être généré n'importe où
        public static event HelloHandler hello;
 
        //Génère l'évènement
        public static void Raise(String value)
        {
            if (hello != null) //évite la NullReferenceException
                hello(value);   
        }
    }
 
    //Evènement appellé quand l'écouteur la méthode HelloWorld a été appelée
    public class HelloPerformedEventHandler
    {
        //déclaration du delegate 
        public delegate void HelloPerformedHandler();
 
        //évènement qui intervient après un HelloWorld
        public static event HelloPerformedHandler helloPerformed;
 
        //Méthode qui génère l'évènement
        public static void Raise()
        {
            if (helloPerformed != null) //évite la NullReferenceException
                helloPerformed();
        }
    }
 
    //Classe fixant les abonnements et les désabonnements à des évènements pour ce module
    public class HelloEventsSubscription 
    {
        //contient une ou plusieurs références sur des potentiels abonnés
        private ViewHelloClass view;
 
        //constructeur ou on initialise les abonnements
        public HelloEventsSubscription(ViewHelloClass view)
        {
            //Futurs abonnés
            this.view = view;
 
            //On définit les abonnements
 
            //l'évènement hello est abonné à la méthode qui affiche le résultat
            HelloEventHandler.hello += view.methodDisplayingHelloWorld; 
 
            //l'évènement "hello affiché" est abonné à la méthode qui désabonne l'évènement "hello" à la méthode qui affiche le résultat
            HelloPerformedEventHandler.helloPerformed += this.UnSubscribeToHelloEvent;
        }
 
        //Désabonnement de l'évènement "hello" à la méthode qui affiche le résultat
        public void UnSubscribeToHelloEvent()
        {
            HelloEventHandler.hello -= this.view.methodDisplayingHelloWorld;
        }
    }
 
    //point d'entrée 
    public class MainExample
    {
        public static void Main()
        {
 
            //on crée le modèle
            ModelHelloClass modelHello = new ModelHelloClass();
 
            //on crée la vue
            ViewHelloClass viewHello = new ViewHelloClass();
 
            //classe qui définit les abonnements qui nous intéressent ici
            //on lui passe en paramètre tous les écouteurs
            HelloEventsSubscription es = new HelloEventsSubscription(viewHello);
 
            Console.WriteLine("Premier appel à la méthode.");
 
            //on appelle un méthode qui est abonnée à un évènement
            modelHello.HelloWorld();
 
            //l'appelle de la méthode doit appeler un deuxième évènement qui désabonne
 
            Console.WriteLine("Deuxième appel à la méthode, on est désabonné donc il ne se passe rien.");
 
            //Cette méthode est appellée mais pas celle qui affiche le résultat                       
            modelHello.HelloWorld(); 
 
            Console.WriteLine("\nPress enter to quit");
            Console.ReadLine();
        }
    }
}

Qu'en pensez - vous ?

29/05/2009, 12h16
Guulh
Citation:

Envoyé par piotrr

Ce que je veux c'est que n'importe quelle méthode de n'importe quelle classe puisse générer n'importe quelle évènement.

Oula :)
En terme de vocabulaire : pour un événement, le terme usuel est "déclencher".

Comme dit dans la doc sus-citée, la gestion usuelle des event est la suivante :
Code:

1 2 3 4 5 6 7 8 9 class trucMuche { public event EventHandler TrucmucheChanged; protected virtual void On TrucMucheChanged(EventArgs e) { if (TrucmucheChanged != null) TrucmucheChanged(this, e); } }
et après, partout dans le code de la classe, quand tu veux déclencher l'event, tu appelles la méthode OnBidule.
29/05/2009, 12h22
matdur

Tu peux utiliser un agrégateur d'évènements
Voila le lien sur celui de Microsoft dans Prism

http://msdn.microsoft.com/en-us/library/cc707867.aspx

mais tu peux en trouver d'autres sur le net
29/05/2009, 13h50
Guulh

Ah, matdur a mieux compris ta démarche que moi :)

Donc ton idée, c'est que t'aurais une classe (disons X), qui serait la seule à émettre des événements ; un ensemble A de classes (métier, typiquement), qui déclenchent les événements de X ; et un ensemble de classes B (graphiques, typiquement), qui s'abonnent aux événements.
Il existe probablement des cas où cette approche se justifie. Mais elle est très différente du système d'events tel qu'il est couramment pratiqué dans le framework. Usuellement, une classe A émet un event ; une classe B s'abonne directement à cet event, sans intermédiaire.

Ce qui peut porter à confusion, quand on parle d'event, c'est que ça recouvre deux réalités : d'un côté le langage C# propose une certaine syntaxe (mot clé event, possibilité de s'abonner avec +=, etc.) ; de l'autre une recommandation de microsoft utilisée dans tout le framework, qui est de n'avoir que des event de type EventHandler<T>, avec l'habituel void trucMuche(object sender, GnaGnaEventArgs e). Recommandation dont on a pas a priori à s'écarter.