Discussion :

[Papy214]

Bonjour,

J'ai un assistant qui affiche différents usercontrol.
Quand j'affiche un usercontrol en particulier, j'ai besoin de savoir si il implémente un EventHandler d'un nom particulier.

Pour l'instant, selon le type du usercontrol, je sais ou non si l'évènement est implémenté mais je voudrais faire un truc plus générique pour éviter de revenir sur mon code à chaque ajout de page.

Est-ce que la réflexion sur un objet de ce type peut me dépanner ?

Papy !

[Guulh]

Tu peux utiliser cette méthode : http://msdn.microsoft.com/fr-fr/libr...getevents.aspx

[Papy214]

Super, merci !

[Papy214]

euh, finalement ...

La réponse correspond à la question mais en fait il me manque quelque chose.

Disons que j'ai 3 classes qui héritent de UserControl:

UserControl1
UserControl2
UserControl3

UserControl2 seulement implémente un évènement ActiveNext.

Dans mon code, je peux donc savoir que l'objet que je traite à un instant T implémente bien l'évènement recherché.

Mais à ce niveau du code, le type de l'objet est UserControl, qui lui, n'implémente pas cet évènement.

Existe-il une méthode qui me permettrait d'assigner une procédure à un évènement en définissant le type hérité ? Je sais pas si je suis très clair là

Voilà un exemple réduit :

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
void AssignEvent(UserControl control)
{
	Type type = control.GetType();
	if (type.GetEvent("Test") != null)
	{
		// control.Test += new EventHandler(uc_Test); 
		// Là, bien sur ça ne passe pas puisque UserControl de base ne connait pas l'évènement...
	}
}
 
void uc_Test(object sender, EventArgs e)
{
	throw new NotImplementedException();
}
 
private void button1_Click(object sender, EventArgs e)
{
	UserControl1 uc = new UserControl1();
	AssignEvent(uc);
}

[crjo]

Salut,

il y a longtemps que je n'ai pas touché à cela, mais il me semble que ce tu veux faire nécessite ce qu'on appelle la "reflexion", c'est à dire la possibilité d'interroger dynamiquement un objet sur son type, ses méthodes, ses événements...

Jette peut-être un oeil ici :
http://msdn.microsoft.com/fr-fr/library/ms228976.aspx

Je pense que c'est ce que tu recherches. Maintenant, je dirais que la réflexion est quand même quelque chose d'un peu compliqué à mettre en place et que ce n'est peut-être pas la meilleure solution à ton problème. Une solution à base d'interface serait peut-être plus appropriée :

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
    public delegate void TestHandler();
    interface ITestEvent
    {
        event TestHandler Test;
    }
 
    public class UserControl
    { 
    }
 
    public class UserControl1 : UserControl
    { 
    }
 
    public class UserControl2 : UserControl, ITestEvent
    {
        public event TestHandler Test;
    }
 
    class Program
    {
        static void AssignEvent(UserControl uc)
        {
            ITestEvent o = uc as ITestEvent;
            if (o != null)
                // ajout du handler uniquement si uc implémente l'interface
                o.Test += new TestHandler(o_Test);
        }
 
        static void o_Test()
        {
            throw new NotImplementedException();
        }
 
        static void Main(string[] args)
        {
            UserControl1 uc1 = new UserControl1();
            UserControl2 uc2 = new UserControl2();
 
            AssignEvent(uc1);
            AssignEvent(uc2);
        }
    }

I hope it helps

[Guulh]

Mais à ce niveau du code, le type de l'objet est UserControl, qui lui, n'implémente pas cet évènement.

Ca, c'est faux Un objet, une fois créé, ne change jamais de type. donc si tu passes un objet de type X (dérivant de userControl) à une méthode prenant un usercontrol en paramètre, l'appel de getType sur ce paramètre renverra bien X.

Code :

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

1
2
3
4
5
void AssignEvent(UserControl control)
{
	Type type = control.GetType();
	// "type" n'est pas forcément UserControl même
}

[Papy214]

Guulh ...

Oui, je me suis mal exprimé. Je voulais dire que le compilateur ne peut pas associer "uc_Test" dans le code de ma procédure puisque qu'il n'est pas sensé le "connaître" à ce moment là.

[Papy214]

Salut,

ce n'est peut-être pas la meilleure solution à ton problème. Une solution à base d'interface serait peut-être plus appropriée :

I hope it helps

Au début, j'étais parti la-dessus mais je me suis retrouvé rapidement à devoir faire du transtypage parfois en UserControl et parfois basé sur une interface commune. J'ai voulu éviter ça et mon dernier "problème" était cette histoire d'association d'évènement.

Sinon, oui, je suis d'accord, une interface commune était la meilleure solution.

[Guulh]

Guulh ...

Oui, je me suis mal exprimé. Je voulais dire que le compilateur ne peut pas associer "uc_Test" dans le code de ma procédure puisque qu'il n'est pas sensé le "connaître" à ce moment là.

Ah, ok ok (m'apprendra à poster trop tard )

Donc la question est : sachant qu'un objet o est d'un type T qui a un event Bidule, comme abonner une méthode à l'event Bidule de cet objet o ? En utilisant la réflexion, comment ré-écrire o.Bidule += UneMéthode ?
J'ai jamais fait, mais en lisant la doc, Type a une méthode GetEvents, qui renvoie des EventInfo ; EventInfo a une méthode AddEventHandler, qui a l'air de faire l'affaire.