Discussion :

[neo.51]

Bonjour,

Voici mon soucis :

Soit des classes A et B.

Code :

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

1
2
3
4
class B : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
...}

Code :

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

1
2
3
4
5
class A : INotifyPropertyChanged
{
private B m_BInstance;
public event PropertyChangedEventHandler PropertyChanged;
}

Ce que je veux c'est que quand je m'abonne à PropertyChanged de ma classe A, ma classe A s'abonne à PropertyChanged de l'instance de la classe B. Bref un chainage d'event. Le soucis c'est que si je modifie ma classe A en fesant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
class A : INotifyPropertyChanged
{
private B m_BInstance;
public event PropertyChangedEventHandler PropertyChanged;
//Constructeur
A()
{
B.PropertyChanged += new PropertyChangedEventHandler(m_B_PropertyChanged);
}
}

Ma classe A est systèmatiquement abonnée à PropertyChangedEventHandler de ma classe B. Hors je ne voudrais m'abonner à PropertyChangedEventHandler de B uniquement si A est abonné à PropertyChangedEventHandler.

Alors la solution qui consiste à créer une méthode "Abonne" qui déclanche l'abonnement ne me convient pas car je fais ces implémentations d'interfaces pour pouvoir binder mes objets métiers et le framework .NET n'appellera pas d'autres méthodes/event que ceux des interfaces utilisées.

Le fait d'être systèmatiquement abonné ne me plait pas non plus car j'ai peur que ça entrainnne des baisses de performance.

J'espère avoir été clair


d'avance

[Sphax]

Salut,

Qd tu définis un évenement dans une classe, le compilateur génère automatiquement pour toi une méthode add_TonEvent et remove_TonEvent. Ce sont ces méthodes qui sont appelées qd un client de ta classe s'abonne / désabonne à ton evenement, et tu peux surcharger ces méthodes. Exemple:

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
 
class A : INotifyPropertyChanged 
{ 
   private B m_BInstance; 
 
   private event PropertyChangedEventHandler m_PropertyChanged; 
   public event PropertyChangedEventHandler PropertyChanged
   {
      add
      {
         m_PropertyChanged += value; //ça c'est ce qui est fait par défaut
         //ici tu peux t'abonner à l'evenement de B (si ce n'est pas déja fait, à toi de gérer cette logique)
      }
 
     remove
     {
        m_PropertyChanged -= value; //ça c'est ce qui est fait par défaut
         //ici tu peux te désabonner à l'evenement de B (si plus personne n'est abonné à ton evenement, encore à toi de gérer)
      }
   }
}

ça te convient ?

[neo.51]

ok

Donc si j'ai bien suivi :

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
 
        private event PropertyChangedEventHandler m_PropertyChanged;
        public event PropertyChangedEventHandler PropertyChanged
        {
            add
            {
                m_PropertyChanged += value;
                //Si je suis pas abonné
                if(m_PropertyChanged == null)
                    m_BInstance.PropertyChanged += new PropertyChangedEventHandler(m_B_PropertyChanged);//Je m'abonne à B
            }
 
            remove
            {
                m_PropertyChanged -= value;
                //Si je suis abonné
                if(m_PropertyChanged != null)
                    m_BInstance.PropertyChanged -= m_B_PropertyChanged;//Je me désabonne de B
            }
 
        }
 
        //Si B déclanche l'évent et que j'y suis abonné
        void m_B_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            //Je déclanche l'event de A
            this.m_PropertyChanged(this, e);
        }

J'ai bon ?

[Sphax]

Euuu je crois pas mais c'est pas loin . Moi je ferais plutôt:

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
 
        private event PropertyChangedEventHandler m_PropertyChanged;
        public event PropertyChangedEventHandler PropertyChanged
        {
            add
            {
                //Si je suis pas abonné
                if(m_PropertyChanged == null)
                    m_BInstance.PropertyChanged += new PropertyChangedEventHandler(m_B_PropertyChanged);//Je m'abonne à B
 
                m_PropertyChanged += value;
                //car ici m_PropertyChanged n'est plus null forcemment ;)
            }
 
            remove
            {
                m_PropertyChanged -= value;
                //Si plus personne n'est abonné a mon evenement
                if(m_PropertyChanged == null)
                    m_BInstance.PropertyChanged -= m_B_PropertyChanged;//Je me désabonne de B
            }
 
        }
 
        //Si B déclanche l'évent et que j'y suis abonné
        void m_B_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            //Je déclanche l'event de A
            this.m_PropertyChanged(this, e);
        }

Petit détail: attention à synchroniser tout ça si tu fais du multithreading.

[neo.51]

oulà
éffectivement j'aurrais du faire plus attention

Mais je sentais bien que quelque chose clochait


En tous cas merci beaucoup pour ton aide