Discussion :

[Stunt_las]

Bonjour,
Voilà quelques temps que je travail sur un projet Silverlight de relativement grande envergure. J’ai décidé d’utiliser le pattern MVVM sur le projet et ça se passe relativement bien, on se rend compte de la réelle puissance des Bindings, etc...

La où ça coince, c’est plus au niveau de l’architecture même de l’application. Prenons un exemple simple, j’ai un écran avec sur la gauche une liste de personnes, et sur la droite un formulaire permettant d’éditer les informations de la personne sélectionné dans la liste. Les modifications de ce formulaire ne sont pas effectives de suite, elles le sont lorsqu’on presse le bouton « sauvegarder » au bas du formulaire.

Comment ça se passe dans l’ombre ? J’ai donc deux vues, la liste (DataGrid) et le formulaire (des TextBox, des ComboBox...), le ViewModel de la liste possède une liste de PersonViewModel, cette liste est l’ItemsSource du DataGrid, et les propriétés des PersonViewModel sont bindées aux colonnes du DataGrid. Le ViewModel du formulaire possède quant à lui un PersonViewModel correspondant à l’item sélectionné dans la liste.

J’ai donc deux instances de PersonViewModel représentant un même objet PersonModel. Sachant, que les ViewModel connaissent leur Model mais pas l’inverse, ça me paraît être le plus naturel.

Ainsi, lorsqu’on modifie les valeurs du formulaire, les changements sont effectifs dans une instance de PersonViewModel.

La où je perds un peu le fil, c’est quand on clic sur le bouton « enregistrer », que doit-il se passer en théorie ? A l’heure actuelle, je récupère les nouvelles valeurs dans le PersonViewModel du formulaire avec le PersonModel correspondant, puis je passe le tout à mon service chargé d’enregistrer l’objet. C’est à ce moment là que ça devient compliqué, je vois plusieurs démarches :

1 – Je modifie le PersonModel avec les nouvelles valeurs, (les changements sont répercutés dans tous les VM correspondant par les INotifyPropertyChangedEvent). Puis j’enregistre cet objet en base. Là où ça coince, c’est si il y a une erreur à l’enregistrement en base, j’ai déjà modifié mon Model, et donc indirectement ce qui est affiché.

2 – Je modifie le PersonModel avec les nouvelles valeurs, (pas d’INotifyPropertyChangedEvent), j’enregistre l’objet en base, puis je crée de nouvelles instances de PersonViewModel à partir du PersonModel fraîchement enregistré.

Bien que je connaisse WPF depuis quelques temps maintenant, le pattern MVVM est tout nouveau pour moi et il est possible qu’une grosse erreur ce soit introduite dans ma façon d’appliquer ce pattern. Ainsi, si vous sentez en me lisant que je ne fais pas ce qu’il faut, ce serait très gentil de me le signaler pour que je change mon approche.

Merci d’avoir eu le courage de tout lire, et je serait ravis de répondre à toute question qui pourrait permettre à des personnes plus expérimentées de comprendre mon architecture et pourquoi pas de m’aider à la corriger.

[Samuel Blanchard]

Bonjour Stunt_las,

J'ai du mal à comprendre pourquoi tu utilises deux PersonViewModel. Normalement, ne devrais-tu pas avoir une liste de personnes et la personne en cours d'édition (qui est un réference de la liste) dans le même ViewModel? Ainsi toute modification de la personne à éditer se reporte automatiquement dans ta liste.

Au cas ou tu veux mettre en place une fonctionnalité ne permettant pas la modification immédiate des propriétés je te conseille de passer par une propriété intermédiaire de type personne (PersonModifing) puis d'appeler une commande permettant la copie de la personne en cours de modification (AcceptPersonModification) vers celle sélectionnée. Quand tu es prêt a enregistré vers ton model appelle la commande SavePersonsModifiedInModel dans l'exemple ci-dessous.

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
 
        public PersonViewModel : INotifyPropertyChanged
        {
 
            public ObservableCollection<Person> Persons
            {
                get;
                private set;
            }
 
            public Dictionnary<int idPerson, Person> ModifedPersons
            {
                get;
                private set;
            }
 
            /// <summary>
            /// Personne selectionnée dans la liste (a binder sur elementName de ta liste box avec un pat à SelectedItem)
            /// </summary>
 
            public Person SelectedPerson
            {
                get
                {
                    return this.selectedPerson;
                }
 
                set
                {
                    if( this.selectedPerson != value )
                    {
                        this.selectedPerson = value;
                        this.NotifyPropertyChanged("SelectedPerson");
                        // on passe une copie de la personne
                        if( value != null )
                        {
                            this.ModifiedPerson =  value.Clone();
                        }
                    }
                }
            }    
 
            private Person selectedPerson;
 
            /// <summary>
            /// Personne en cours de modification (a Binder sur ton formulaire)
            /// </summary>
 
            public Person PersonModifing
            {
                get
                {
                    return this.personModifing;
                }
 
                set
                {
                    this.PersonModifing = value;
                    this.NotifyPropertyChanged("PersonModifing");
                }
            }
 
            private Person personModifing;
 
            /// <summary>
            /// On accepte les modification de la personne
            /// </summary>
 
            public void AcceptPersonModification()
            {
                // on recopie dans la personne selectionné
                this.selectedPerson.Name = PersonModifing.Name;
                //...
 
                // on ajoute dans le dictionnaire des personnes modifiées
                // si la personne dispose d'un id, cela permet de ne pas enregistrer plusieurs fois les modifications.
                this.ModifedPersons.Add( this.selectedPerson.Id, this.selectedPerson );
            }            
 
            public void SavePersonsModifiedInModel()
            {
                // on sauve dans le Model (base de donnée)
                foreach( Person person in ModifedPersons.Values )
                {
                }
            }
        }

Je n'ai pas testé mon code mais je te le fournis comme base de notre discussion.

J'espère avoir pu t'aider un peu.

Bon courage !