Discussion :

[igorzup]

Bonjour,

J'ai lié plusieurs UserControl a leur propre ViewModel qui héritent tous d'un ViewModel commun.

Je ne vois pas pourquoi une modification d'une propriété commune qui leve l’événement OnPropertyChanged n'est pas catché par les UC.

Seuls les UC qui modifient elle même le VM répercutent les modifications, les UC qui sont autour ne sont pas affectées

Je sais pas si je suis clair...

Par avance, merci de m’éclairer

[sisqo60]

Bonjour,

Tu dois confondre héritage et instances...
Les propriétés communes de tes instances qui héritent de ta VM de base sont indépendantes.

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
 
public class A
{
    public int identifiant {get;set;}
}
 
public class B : A
{
    public string Libelle {get; set;}
}
 
A monInstanceA = new A();
B monInstanceB = new B();
 
monInstanceA.Identifiant = 100;
monInstanceB.Identifiant = 0;
// monInstanceA et monInstanceB ont tous les deux une propriété Identifiant mais une valeur différente.

Vérifies que tu es lié à la même instance de VM

[igorzup]

oui je te suis.
Mais j'ai un singleton dans le constructeur de mon VM que je fait hériter.
Donc a priori les VM ont une partie commune.

nan?

[igorzup]

bon au final:
- la construction de mes VM apelle bien le meme mainVM (meme instance donc... non?)
- une valeur du mainVM modifiée reste a null dans les autres VM

je pige pooo!

je suis obligé de passer par des copie locale des valeurs dans chaque sous-VM ou quoi?
(ou d'abandonner l'idée des sous-VM.... et d'en faire un seul commun)

[Nathanael Marchand]

bon au final:
- la construction de mes VM apelle bien le meme mainVM (meme instance donc... non?)
- une valeur du mainVM modifiée reste a null dans les autres VM

je pige pooo!

je suis obligé de passer par des copie locale des valeurs dans chaque sous-VM ou quoi?
(ou d'abandonner l'idée des sous-VM.... et d'en faire un seul commun)

Et l'idée d'utiliser des conteneurs d'objets, de l'injection de dépendance, toussa tousa?

[sisqo60]

Mais j'ai un singleton dans le constructeur de mon VM que je fait hériter.
Donc a priori les VM ont une partie commune.

Envoies ton code parce que ça me parait bizarre comme manière de faire, mais sans code je ne peux pas t'en dire plus... On peut toujours trouver une solution et regarde aussi les pistes que t'as donné Nathanael Marchand...

Et l'idée d'utiliser des conteneurs d'objets, de l'injection de dépendance, toussa tousa?

MEF avec ses catalogues, peut l'aider c'est sûr, mais il n'a éventuellement pas besoin de toute cette usine à gaz pour résoudre son problème?


Sinon j'utilise tout ça régulièrement pour beaucoup de projets

[Nathanael Marchand]

Y a des conteneurs un peu moins complexes que MEF (qui d'ailleurs n'en n'est pas vraiment un)

[igorzup]

C'est vrai que j'ai pas cherché trop loin et pas envie d’implémenter MEF pour si peu (locator et compagnie, ca me semble disproportionné) mais y a un peu de cette idée c'est vrai

Passer par unity?

ok pourquoi pas mais juste pour savoir, ce qui cloche la dedans svp:

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
public class mainViewModel : ViewModelBase{
        private static mainViewModel instance;
        private static readonly object myLock = new object();
 
         public mainViewModel() { 
            getInstance(); 
        } 
...
 
 
    public partial class RolesAppViewModel : mainViewModel {
        private RolesApp View;
        public RolesAppViewModel(RolesApp _view) {
            View = _view;
        }           #region NvApp
        private string _NvApp;
      public string NvApp {
           get { return _NvApp; }
            set {
                _NvApp = value;
                OnPropertyChanged("NvApp");
            }
        }
        #endregion

[Lordinaire]

Si je prends un exemple qui se base sur tes VM :

Code :

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

1
2
class RolesAppViewModel : MainViewModel
class Roles2AppViewModel : MainViewModel

Si tu fais appel à OnPropertyChanged("MyProperty"); d'une propiété de RolesAppViewModel, celle-ci ne s'appliquera qu'à ton VM RolesAppViewModel.
Si tu fais appel à OnPropertyChanged("MyProperty"); d'une propiété de MainViewModel, celle-ci s'appliquera à tous tes VMs héritant de MainViewModel (ici RolesAppViewModel et Roles2AppViewModel)

J'espère avoir été clair

[igorzup]

Bah c'est justement pas ce qui se passe en fait... Et c'est ca que je pige po!

pas plus pour la levée d’événements.
J'ai vraiment des instance de mainviewmodel différente dans chaque VM filles.
(et pourtant le passage par le singleton et même l’envoi de mon instance semble respectée)

Ca dois être gros comme une maison cette erreur, mais j'avoue que du coup je l'ai laissé de coté pour l'instant.

Si quelqu'un vois, ou aurais une idée...

[Nathanael Marchand]

Bon on va récapituler parce que là c'est pas gégé
Déjà, ton singleton n'est pas bon, rien n'en garantit l'unicité.
Premier point: revoir le pattern singleton.

Seconde chose: les évènements sont par instance. Ton BaseViewModel possède un évènement PropertyChanged qu'il peut lever. Je répète que le fonctionnement est par instance donc, si tu as une instance vm1 et une instance vm2. Que la première lève l'évènement, il n'y a aucune raison que la seconde le fasse.
Rajouter l'héritage dessus n'y change rien.

Bon si on rajoute qu'un singleton sur une classe de base (ce que t'as l'air de vouloir faire avec mainViewModel, et auquel cas il faudrait d'ailleurs la noter comme abstract) ne veut strictement rien dire (puisque cette classe de base n'est jamais instanciée, ce sont les classes qui en héritent qui sont instanciées).

Il faudrait donc revoir la notion d'objet, de classe, d'héritage et d'instance. Ca peut sembler que du lexique mais non si il y a des mots différents c'est que les sens le sont!

[sisqo60]

Tu ne sembles pas comprendre l'objet, je continue mon petit exemple :

Code :

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

1
2
3
4
public class A {     public int identifiant {get;set;} }   public class B : A {     public string Libelle {get; set;} }   A monInstanceA = new A(); B monInstanceB = new B();   monInstanceA.Identifiant = 100; monInstanceB.Identifiant = 0;
//monInstanceA et monInstanceB ont tous les deux une propriété Identifiant mais une valeur différente.
monInstanceA  = (A)monInstanceB;
//Tu auras donc monInstanceA.Identifiant qui sera à 0 puisque qu as changé la référence de l'objet.

Il faut revoir tes cours objet!!!

[igorzup]

ok... bah je me fait bien basher moi!! (ca doit être mérité, mais un souci la)

nathanael, t'a réponse m’intéresse.
En quoi mon singleton ne garanti pas l'unicité stp... ca doit venir de la

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 public class mainViewModel : ViewModelBase{         
private static mainViewModel instance;         
private static readonly object myLock = new object();           
public mainViewModel() {              
     getInstance();          
}        
public mainViewModel(string arg) {}        
public static mainViewModel getInstance() {             
     lock (myLock) {                 
     if (instance == null) instance = new mainViewModel("init");
     return instance;             
}         
}

pour finir nathanael, peux tu me répondre sur ce point:
Si je passe l'instance de mon Vm pere dans le constructeur de mes deux VM filles (puisque ca marche par instance comme nous sommes d'accord et comme tu a repété), pourquoi une levée d’événement du VMpere levée a partir de VMfilleA ne leve pas le meme pour VMfilleB?

Merci en tout cas pour vos réponses, ca fait quand meme plaiz de voir les reponses de sisqo60 et Lordinaire
Je précise que j'ai écrit strictement ce qu'ils m'ont repondu depuis le debut et que c'est justement le probleme

[Nathanael Marchand]

ok... bah je me fait bien basher moi!! (ca doit être mérité, mais un souci la)

nathanael, t'a réponse m’intéresse.
En quoi mon singleton ne garanti pas l'unicité stp... ca doit venir de la

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 public class mainViewModel : ViewModelBase{         
private static mainViewModel instance;         
private static readonly object myLock = new object();           
public mainViewModel() {              
     getInstance();          
}        
public mainViewModel(string arg) {}        
public static mainViewModel getInstance() {             
     lock (myLock) {                 
     if (instance == null) instance = new mainViewModel("init");
     return instance;             
}         
}

La clef du singleton et ce qui garantit l'unicité, c'est le constructeur qui doit être private. Ainsi, tu es sur que le seul new sur cette classe sera dans cette classe. Car ici, ton constructeur est public et rien ne t'interdit donc d'ailleurs instancier cette classe apu singleton

Oui mais si tu ne lis pas ce passage avant de passer ton constructeur en private, tu vas t'apercevoir que le code ne compile pas. Car pour le coup, rendre le constructeur privé empêche les classes qui en héritent d'appeler ce constructeur... Comme je le disais, hériter d'une classe qui est singleton n'a pas de sens! Elle devrait être d'ailleurs sealed.

pour finir nathanael, peux tu me répondre sur ce point:
Si je passe l'instance de mon Vm pere dans le constructeur de mes deux VM filles (puisque ca marche par instance comme nous sommes d'accord et comme tu a repété), pourquoi une levée d’événement du VMpere levée a partir de VMfilleA ne leve pas le meme pour VMfilleB?

Pour le reste, je retourne la question, qu'est ce qui ferait que l'un déclenche l'autre? Tu as trois personnes, un père et deux fils: tu demandes a un fils l'heure qu'il est, pourquoi les deux devraient te répondre?

Attention, ne pas confondre agrégation et héritage, deux notions différentes

[igorzup]

merci nathanael,

ok pour le constructeur laissé public... erratum, sans importance dans notre cas, mais c'est vrai qu'il est nécessaire de verrouiller cet accès depuis l’extérieur... donc oui mais non

pour répondre a ta métaphore précédente, c'est comme si les deux fils avaient la montre du père, une montre pour deux
une montre qui se dérègle et l'un peux la régler pour l'autre

encore une fois, pourquoi avec un singleton sur le VM pere, les deux enfants se retrouvent avec deux pères différents?

il n'y a pas de raison particulières nan?

[Nathanael Marchand]

Ben non, avec l'héritage chaque fils a sa propre montre justement!
C'est avec la composition que les fils se partagent une montre.

[Lordinaire]

Je t'ai fait un petit exemple pour que tu comprennes bien le fonctionnement de tout ça :

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
 
    /// <summary>
    /// Mon context unique
    /// </summary>
    public class ContextViewModel : ViewModelBase
    {
        private string _myPropertyContext;
        public string MyPropertyContext
        {
            get { return _myPropertyContext; }
            set
            {
                _myPropertyContext = value;
                RaisePropertyChanged("MyPropertyContext");
            }
        }
    }
 
    /// <summary>
    /// Class abstraite de base à tous les ViewModels
    /// embarquant un ContextViewModel "unique"
    /// </summary>
    public abstract class MyViewModelBase : ViewModelBase
    {
        private static ContextViewModel _context;
        public ContextViewModel Context
        {
            get
            {
                if (_context == null)
                {
                    _context = new ContextViewModel();
                }
 
                return _context;
            }
        }
 
        private string _myPropertyBase;
        public string MyPropertyBase
        {
            get { return _myPropertyBase; }
            set
            {
                _myPropertyBase = value;
                RaisePropertyChanged("MyPropertyBase");
            }
        }
 
        public void SetMyPropertyBase(string txt)
        {
            MyPropertyBase = txt;
        }
    }
 
    public class Ex1ViewModel : MyViewModelBase
    {
        private string _myProperty;
        public string MyProperty
        {
            get { return _myProperty; }
            set
            {
                _myProperty = value;
                RaisePropertyChanged("MyProperty");
            }
        }
    }
 
    public class Ex2ViewModel : MyViewModelBase
    {
        private string _myProperty;
        public string MyProperty
        {
            get { return _myProperty; }
            set
            {
                _myProperty = value;
                RaisePropertyChanged("MyProperty");
            }
        }
    }
 
    /// <summary>
    /// Début du programme ici
    /// </summary>
    public class MainViewModel : MyViewModelBase
    {
        public Ex1ViewModel Ex1 { get; set; }
        public Ex2ViewModel Ex2 { get; set; }
 
        public MainViewModel()
        {
            Ex1 = new Ex1ViewModel();
            Ex2 = new Ex2ViewModel();
 
            Ex1.MyProperty = "toto";
            Console.WriteLine("Ex1.MyProperty = " + Ex1.MyProperty);
            // Ex1.MyProperty = toto
 
            Ex2.MyProperty = "titi";
            Console.WriteLine("Ex1.MyProperty = " + Ex1.MyProperty);
            Console.WriteLine("Ex2.MyProperty = " + Ex2.MyProperty);
            // Ex1.MyProperty = toto
            // Ex2.MyProperty = titi
 
            Ex1.Context.MyPropertyContext = "tata";
            Console.WriteLine("Ex1.Context.MyPropertyContext = " + Ex1.Context.MyPropertyContext);
            Console.WriteLine("Ex2.Context.MyPropertyContext = " + Ex2.Context.MyPropertyContext);
            // Ex1.Context.MyPropertyContext = tata
            // Ex2.Context.MyPropertyContext = tata
 
            Ex1.MyPropertyBase = "tutu";
            Console.WriteLine("Ex1.MyPropertyBase = " + Ex1.MyPropertyBase);
            Console.WriteLine("Ex2.MyPropertyBase = " + Ex2.MyPropertyBase);
            // Ex1.MyPropertyBase = tutu
            // Ex2.MyPropertyBase = 
        }
    }

On part du principe que le le programme commence comme ça :

Code :

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

1
2
 
MainViewModel mainVM = new MainviewModel();

Essaye de bien comprendre pourquoi la console affiche ces résultats et tu seras proche du but

[igorzup]

Merci beaucoup Lordinaire.... tu t'est vraiment pris la tete pour le coup!!!

bon, dans ton exemple tres détaillé c'est comme si je voulais avoir :

Code :

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

1
2
3
4
5
Ex1.Context.MyPropertyContext = "tata";
            Console.WriteLine("Ex1.Context.MyPropertyContext = " + Ex1.Context.MyPropertyContext);
            Console.WriteLine("Ex2.Context.MyPropertyContext = " + Ex2.Context.MyPropertyContext);
            // Ex1.Context.MyPropertyContext = tata
            // Ex2.Context.MyPropertyContext = tata

mais sans le ".Context." (du coup j'ai un singleton sur le constructeur)

[Nathanael Marchand]

Merci beaucoup Lordinaire.... tu t'est vraiment pris la tete pour le coup!!!

bon, dans ton exemple tres détaillé c'est comme si je voulais avoir :

Code :

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

1
2
3
4
5
Ex1.Context.MyPropertyContext = "tata";
            Console.WriteLine("Ex1.Context.MyPropertyContext = " + Ex1.Context.MyPropertyContext);
            Console.WriteLine("Ex2.Context.MyPropertyContext = " + Ex2.Context.MyPropertyContext);
            // Ex1.Context.MyPropertyContext = tata
            // Ex2.Context.MyPropertyContext = tata

mais sans le ".Context." (du coup j'ai un singleton sur le constructeur)

Et ca n'est pas possible avec de l'héritage !
Il faut bien comprendre ce que c'est l'héritage: quand une classe F hérite de P, il n y a pas un P caché dans F, c'est F qui EST un P. Tu ne peux pas donc avoir f1 et f2 qui pointent sur un même P puisque f1 et f2 SONT des P.

[Lordinaire]

Tu es obligé de passer par une classe intermédiaire qui sera en singleton. La classe héritée en singleton comme tu l'as fait ne fera jamais ce que tu veux.

Tu t'embrouilles vraiment sur l'héritage