[C#][Reflection] Comment utiliser System.Type ?

Version imprimable

Bonjour,

J'écrit un petit bout de code qui vise à désabonner des evenements.

Bref dans ma naïveté de débutant j'ai écrit cela
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 class RegisteredEventManager { public RegisteredEventManager() { } private class RegisteredEvent { private Type pType; private System.Delegate pEvent; private object pAttachedMethod; public RegisteredEvent(Type T, System.Delegate Event, object AttachedMethod) { this.pType = T; this.pEvent = Event; this.pAttachedMethod = AttachedMethod; } public void Unregister() { (this.pType)this.pEvent -= this.pAttachedMethod; } } }
Mais comme vous l'aurez déja deviné cette ligne

Code:

(this.pType)this.pEvent -= this.pAttachedMethod;

ne fonctionne pas...
Je comprend bien pourquoi, mais je n'ai pas encore trouvé le moyen
d'y palier.

Aussi me demandais je si une âme charitable m'aiderai à résoudre
ce petit problème.

Merci, Bye

25/01/2006, 22h44
NicolasG
Je ne comprend pas ce que tu veux faire avec cette classe
mais l'inscription d'un gestionnaire d'événement a cette syntaxe :
Code:

1 2 this.button1.Click += new System.EventHandler(this.button1_Click);
et pour supprimer cette inscription :
Code:

1 2 this.button1.Click -= new System.EventHandler(this.button1_Click);
On peut remarquer que l'on crée un nouveau EventHandler pour supprimer l'inscription du premier.
25/01/2006, 23h00
ePoX

En fait le but est de collecter des references sur des evenements de
différents objets, et de différents type tant qu'à faire.

La classe étant peuplée d'évènement, il faudrait ensuite que j'appelle
une méthode qui me désabonne tout ce petit monde.

Mais plus je cherche, plus j'ai le sentiment que ça vas pas se faire
d'un coup de baguette magique :/

Donc au départ j'avais pensé qu'une classe contenant une référence
vers l'evenement, son type, et sa méthode associé je pourrais
simplement le faire à coup de cast... Mais pas du tout.

D'après ce que j'ai pu lire il faudrait que j'invoque une méthode de
l'evenement, en l'occurence Remove
(mais bon la dessus aussi je bute parce que cet evenement
je le déclare dans une interface et il semble que je n'ai pas le droit de
déclarer les accesseurs add / remove pour l'evenement dans l'interface),
pour pouvoir explicitement demander à cette méthode de se désabonner.

bref ça sent pas très bon tout ça :/

bye
25/01/2006, 23h05
smyley
Code:

1 2 3 4 Type f = typeof(TonType); System.Reflection.EventInfo[] eventDeCetteClasse = f.GetEvents(); eventDeCetteClasse[0].RemoveEventHandler(ObjetCible,ZeDelegate);
Ce code désenregistre le premier event de l'objet ObjetCible
répondant au type ZeDelegate ( type du delegate ).
Voilà donc un point de départ :)

Encore merci Smiley :)

Je vais peut être y arriver
Mais le fait est que sa se complique,

je vais remettre cette classe dans son contexte.
C'est dans une petite appli en .Net Remoting en WKO.singleton.

Donc côté serveur j'ai cette classe

Code:

1
2
3
4
5
6
7
8
9
 
class GroupeListe : MarshalByRefObject, IGroupeListe
{
  protected ArrayList Items;
  private object eventLock_;
  private event GroupListEventHandler m_OnAddedGroup;
  private event GroupListEventHandler m_OnRemovedGroup;
  //....
}

Pour faire le pont avec le client j'ai l'interface associée :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public interface IGroupeListe
{
  IEnumerator GetEnumerator();
  IGroupe this[int index] { get;set;}
  void Add(IGroupe E);
  int Count {get;}
  IGroupe CreateGroup();
  void RemoveGroup(IGroupe G);
  event GroupListEventHandler OnAddedGroup;
  event GroupListEventHandler OnRemovedGroup;
}

Et quand j'essaie d'utiliser la classe suivante sur mon objet distant :

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
 
class RegisteredEventManager
{
  public RegisteredEventManager()
  {
  }
  public class RegisteredEvent
  {
    private string pEventName;
    private System.Delegate pDelegue;
    private object pTargetObject;
    private Type pTargetType;
    public RegisteredEvent( object TargetObject, Type TargetType , System.Delegate Delegue , string EventName )
    {
      this.pEventName = EventName;
      this.pTargetObject = TargetObject;
      this.pTargetType = TargetType;
      this.pDelegue = Delegue;
    }
    public void Unregister()
    {
      try
     {
        System.Windows.Forms.MessageBox.Show(this.pTargetType.Name);
        Type pType = this.pTargetType;
        Type[] pInterfaces = pType.GetInterfaces();
        for( int i =0; i<pInterfaces.Length; i++)
        {
          System.Windows.Forms.MessageBox.Show(pInterfaces[i].Name);
        }
        EventInfo[] pTargetObjectEvents = pType.GetEvents();
        for( int i=0;i< pTargetObjectEvents.Length; i++)
        {
          if( pTargetObjectEvents[i].Name == this.pEventName )
          {
            //MethodInfo pRemoveEventsMethod = pTargetObjectEvents[i].GetRemoveMethod();
            //object[] pRemoveEventsMethodArgs = new object[] { this.pDelegue };
            //pRemoveEventsMethod.Invoke(this.pTargetObject, pRemoveEventsMethodArgs);
            pTargetObjectEvents[i].RemoveEventHandler(this.pTargetObject, this.pDelegue);
          }
        }
      }
      catch(Exception Ex)
      {
        System.Windows.Forms.MessageBox.Show(Ex.Message);
      }
    }
  }
}

Le problème c'est que mon objet TargetObject dérive de MBR,
soit c'est plutot normal, par contre

Code:

pInterfaces = pType.GetInterfaces();

me retourne 0.
Concernant

Code:

pTargetObjectEvents.Length.ToString()

il me retourne 0 aussi :s
Ce qui me semble à peu près logique, et encore que ça m'échappe
un peu.
Donc comme tu l'auras deviné, je peux toujours courir pour
retrouver mon evenement sur mon objet dérivant de MBR.
Il faudrait plutot que je le caste selon une interface.
Mais j'ai pas encore réussi à trouver le bout de code qui permet de
passer un type d'interface en parametre, et un bout de code qui me
permet de caster cet objet dans le type d'interface fournie :s

J'espère que mes explications sont claires,
Encore merci de t'être penché sur mon cas :)

bye

27/01/2006, 18h48
ePoX

Ok resolved. Mais la solution n'est pas tip top.

En fait j'utilise la meme classe RegisteredEventManager
j'ai juste rajouté une méthode dans l'objet cible
public Type GetInterface() puisqu'elle est exécutée côté serveur
me permet de faire la relation objet<=>interface.

Mais bon si quelqu'un à une solution plus standard
je veux bien que l'on me la montre.

Encore merci,
bye