Discussion :

[piotrr]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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

merci

[emmr.rida]

Pour déclarer un événement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public event EventHandler nom_evenement;

[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#)

[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.

[Guulh]

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.

[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.

Voici la solution que je propose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?