EventHandler dans une interface

**nicoboud2** · 14/07/2009, 21h11

Bonjour,

Je m'arrache les cheveux sur quelque chose que je pensais simple à l'origine. J'utilise une interface pour définir l'ensemble des méthodes/fonctions que doit définir un Plugin.

IPlugin :

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
 
using System;
using System.Data;
//using System.Collections.Generic;
using System.Windows;
 
namespace test.PluginInterface
{
    public interface IPlugin
    {
        event EventHandler<ValidParametersEventArgs> OnParametersChanged;
        string Traitement();
        void Refresh();
        string getName();
        System.Windows.Forms.UserControl VisualComponent();
 
    }
 
    public class ValidParametersEventArgs : EventArgs
    {
        private bool validParameters = false;
 
        public ValidParametersEventArgs(bool validParameters)
        {
            if (validParameters == null) throw new NullReferenceException();
            this.validParameters = validParameters;
        }
 
        public Boolean ValidParameters
        {
            get { return this.validParameters; }
        }
    }
}

Je souhaiterais imposer que toute classe répondant à la définition de cette interface implémente un événement "OnParametersChanged" qui permettrait de savoir si les valeurs renseignées dans mes différents éléments winforms (un DateTimePicker, un Label, ... n'importe quoi) sont cohérentes entre elles. Pour ça j'ai créé un EventArgs perso pour mon événement qui renvoie juste un booléen pour me dire si oui ou non les données renseignées sont cohérentes. Cette analyse sera faite dans le code du Plugin.

Cela me servira à rendre actif/inactif un bouton (qui lui est conçut en dehors du plugin).

Mais il m'est impossible de compiler !!!!! J'ai essayé des modifications dans tous les sens, car à la fin, je n'y comprenais plus rien.

Pour info, j'ai consulté ça (qui m'a bien aidé) :
http://geekswithblogs.net/technetbyt...10.aspx#390040

... et quand j'applique exactement la même méthode, j'ai un message me disant que je n'implémente pas le membre d'interface OnParametersChanged.

Je tiens aussi à préciser que j'arrive à compiler si je n'utilise pas le type précis de mon EventArgs perso. Bref, les problèmes ont commencé quand j'ai voulu utiliser autre chose que le EventArgs par défaut que gère un EventHandler.

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
132
133
134
135
136
 
using System;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Windows.Forms;
using test.PluginInterface;
 
namespace test
{
    //public delegate void ValidParametersEventHandler(object sender, ValidParametersEventArgs e);
    public delegate void EventHandler<ValidParametersEventArgs>(object sender, ValidParametersEventArgs e);
 
    public class Req1 : System.Windows.Forms.UserControl, IPlugin
    {
        private System.ComponentModel.Container components = null;
        private System.Windows.Forms.DataGridView DGV_res;
        private System.Windows.Forms.Panel PNL_bottom;
        private System.Windows.Forms.Label LBL_EndDate;
        private System.Windows.Forms.DateTimePicker DTP_startDate;
        private System.Windows.Forms.Label LBL_StartDate;
        private System.Windows.Forms.DateTimePicker DTP_endDate;
        private Label LBL_Description;
        private System.Windows.Forms.GroupBox GB_RangePeriod;
 
        public event EventHandler<ValidParametersEventArgs> ParametersChangedEvent;
        public event EventHandler<ValidParametersEventArgs> ParametersChanged
        {
            add
            {
                if (ParametersChangedEvent != null)
                {
                    lock (ParametersChangedEvent)
                    {
                        ParametersChangedEvent += value;
                    }
                }
                else
                {
                    //ParametersChangedEvent = new EventHandler(value);
                    ParametersChangedEvent = new EventHandler<ValidParametersEventArgs>(value);
                }
            }
            remove
            {
                if (ParametersChangedEvent != null)
                {
                    lock (ParametersChangedEvent)
                    {
                        ParametersChangedEvent -= value;
                    }
                }
            }
        }
 
        protected virtual EventHandler<ValidParametersEventArgs> OnParametersChanged(ValidParametersEventArgs e)
        //protected void OnParametersChanged(EventArgs e)
        {
            if (OnParametersChanged != null)
                OnParametersChanged(this, e);
        }
 
 
 
        // Constructeur : Initilialise la partie visuelle du composant
        public Req1()
		{
			InitializeComponent();
            DTP_startDate.Value = new DateTime(DateTime.Today.Year, DateTime.Today.Month - 1, 1);
            DTP_endDate.Value = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1).AddDays(-1);
		}
 
        // Destructeur
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }        
 
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Req1));
        (...)
        }
 
        // Fonction de traitement
        // ne retourne rien pour l'instant
        public string Traitement()
        {
            return "Traitement de" + this.getName();
        }
 
        public string getName()
        {
            return ("Req1");
        }
 
        // Permet de récupérer le contrôle utilisateur qui est la classe d'où
        // le return this.
        public System.Windows.Forms.UserControl VisualComponent()
        {
            return this;
        }
 
        private void DTP_startDate_ValueChanged(object sender, EventArgs e)
        {
            partialRefresh();
        }
 
        private void DTP_endDate_ValueChanged(object sender, EventArgs e)
        {
            partialRefresh();
        }
 
        private void partialRefresh()
        {
            (...)
            /*ValidParametersEventArgs evArgs = new ValidParametersEventArgs(DTP_startDate.Value.CompareTo(DTP_endDate.Value) <= 0 && DTP_startDate.Value.CompareTo(DateTime.Now) <= 0);
            if (evArgs != null)
                OnParametersChanged(evArgs);*/
 
            EventHandler handler = ParametersChangedEvent;
            if (handler != null)
            {
                ValidParametersEventArgs evArgs = new ValidParametersEventArgs(DTP_startDate.Value.CompareTo(DTP_endDate.Value) <= 0 && DTP_startDate.Value.CompareTo(DateTime.Now) <= 0);
                handler(this, evArgs);
            }
        }
    }
}

Quelqu'un aurait-il une idée de ce qui cloche ??? Merci d'avance.

**Kaidan** · 15/07/2009, 04h22

Donc le jeu, c'est de deviner quelle est l'erreur de compilation, c'est ça ?

**nicoboud2** · 15/07/2009, 10h47

Envoyé par Kaidan

Donc le jeu, c'est de deviner quelle est l'erreur de compilation, c'est ça ?

Bien sûr que non, toute aide est la bienvenue, que ce soit pour me dire que telle déclaration semble étrange, qu'une autre façon de faire serait plus logique, que "moi j'ai déjà fait un truc similaire, et j'ai contourné le problème en faisant ça", me renvoyer vers un lien intéressant, ... n'importe quoi !

J'essayais de présenter mon problème précisément, c'est tout, car il est difficile de l'expliquer en 2 lignes.

**Kaidan** · 15/07/2009, 12h40

Je voulais dire qu'il serait intéressant d'avoir l'erreur de compilation et non le "ça compile pas".

**smyley** · 15/07/2009, 13h47

Code c# :

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
 
public delegate void MyIsValidHandler(bool isValidParameters);
 
public interface IMyInterface
{
   event MyIsValidHandler OnParametersChanged;
}
 
public class MyClass : IMyInterface
{
   public event MyIsValidHandler OnParametersChanged;
 
   protected virtual void RaiseOnParametersChanged(bool isValid)
   {
      if(OnParametersChanged != null)
         OnParametersChanged(isValid);
   }
 
   public void Machin()
   {
     RaiseOnParametersChanged(true);
   }
}
 
public class Exemple 
{
   public void Test()
   {
       MyClass t = new MyClass();
       t.OnParametersChanged += delegate(bool isValid)
       {
          MessageBox.Show(isValid.ToString());
       };
 
       t.Machin();
   }
}

J'ai pas testé, mais ça doit être cohérent.
Ps. lit les cours C# et surtout lis bien comment on se sert des event et delegate, parce que là ton code c'est vraiment ...

**nicoboud2** · 15/07/2009, 13h58

Envoyé par Kaidan

Je voulais dire qu'il serait intéressant d'avoir l'erreur de compilation et non le "ça compile pas".

Autant pour moi.

Le code cité en exemple me donne cette erreur :
'Test.Req1' n'implémente pas le membre d'interface 'Test.PluginInterface.IPlugin.OnParametersChanged"
D:\Mes Documents\Visual Studio 2005\Projects\Test\Req1\Req1.cs 14 18 Req1

Pourtant ...

**smyley** · 15/07/2009, 14h00

Envoyé par nicoboud2

Pourtant ...

cf. mon post.
Parce qu'avec

Code c# :

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

public delegate void EventHandler<ValidParametersEventArgs>(object sender, ValidParametersEventArgs e);

tu crées un délégué générique ayant comme paramètre générique ValidParametersEventArgs qui peut donc donner EventHandler<string> et rester "valide", et je pense que ce n'est pas ce que tu as voulu faire ...

**nicoboud2** · 15/07/2009, 21h13

Smyley, merci pour ton aide.

Je n'ai pas eu le temps de me replonger dans les cours sur les delegate et cie. Je me permets qd même cette question : dans l'exemple que tu donnes, tu fais un

Code :

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

t.OnParametersChanged += delegate(bool isValid)

Or je pensais plutôt "m'abonner" à un événement en faisant quelque chose du genre (en reprenant ton exemple) :

Code :

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

1
2
//plugin étant un objet vérifiant l'interface IPlugin
plugin.OnParametersChanged += new EventHandler(la_méthode_que_je_veux_lancer);

... mon idée étant vraiment de fonctionner comme avec n'importe quel autre événement.

Le code que tu proposes est-il équivalent à :

Code :

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

1
2
3
4
5
6
plugin.OnParametersChanged += new EventHandler(plugin_OnParametersChanged);
 
void plugin_OnParametersChanged(object sender, EventArgs e)
{
      MessageBox.Show("isValid : " + e.ToString());
}

? Pendant ce temps, j'essais de me plonger dans les delegate et autres event.

**smyley** · 15/07/2009, 23h28

Oui. La structure "delegate(...)" s'appelle des méthodes anonymes. C'est dans les cours de C# 3.0 ...

**nicoboud2** · 16/07/2009, 09h40

Envoyé par smyley

Oui. La structure "delegate(...)" s'appelle des méthodes anonymes. C'est dans les cours de C# 3.0 ...

Mais je code en C# 2.0.

**nicoboud2** · 16/07/2009, 09h53

Bon, ça compile, maintenant il faut que je teste pour voir si ça fait bien ce que je voulais au départ.

**smyley** · 16/07/2009, 12h47

Envoyé par nicoboud2

Mais je code en C# 2.0.

Bah au temps pour moi, c'est aussi possible en C# 2.0.

**nicoboud2** · 16/07/2009, 15h32

Je n'ai pas trop poussé mes tests, mais ça a l'air de fonctionner.
Pour ceux qui aurait un pb équivalent, voilà ce que j'ai fait.

IPlugin

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
using System;
using System.Data;
using System.Windows;
 
namespace Test.PluginInterface
{
    public delegate void MyIsValidHandler(object sender,
                    ValidParametersEventArgs e);
 
    public class ValidParametersEventArgs : EventArgs
    {
        private bool validParameters = false;
 
        public ValidParametersEventArgs(bool validParameters)
        {
            //if (validParameters == null) throw new NullReferenceException();
            this.validParameters = validParameters;
        }
 
        public bool ValidParameters
        {
            get { return this.validParameters; }
        }
    }
 
    public interface IPlugin
    {
        event MyIsValidHandler OnParametersChanged;
 
        // les déclarations de mes autres fonctions/méthodes
        (...)
 
    }
}

Le code de ma classe qui implémente IPlugin :

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
using System;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Windows.Forms;
using Test.PluginInterface;
 
namespace Test
{
    public class Req1 : System.Windows.Forms.UserControl, IPlugin
    {
        public event MyIsValidHandler OnParametersChanged;
 
        protected virtual void RaiseOnParametersChanged(bool isValid)
        {
            if (OnParametersChanged != null)
                OnParametersChanged(this,
                    new ValidParametersEventArgs(isValid));
        }
 
        // Constructeur : Initilialise la partie visuelle du composant
        public Req1()
	{
		InitializeComponent();
		(...)
	}
 
        private void InitializeComponent()
        {
		(...)
        }
 
        private void fonctionXouY()
        {
      		//if
      		RaiseOnParametersChanged(true);
      		//else
      		RaiseOnParametersChanged(false);
        }
    }
}

et dans la WinForm "au-dessus", il faudra placer :

Code :

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

plugin.OnParametersChanged += new MyIsValidHandler(plugin_OnParametersChanged);

et la fonction suivante, par exemple :

Code :

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

1
2
3
4
void plugin_OnParametersChanged(object sender, ValidParametersEventArgs e)
{
    MessageBox.Show("isValid : " + e.ValidParameters);
}

Merci à tous pour votre aide !

EventHandler dans une interface

Windows Forms

Discussions similaires

Partager

Partager