Discussion :

[alves.seb]

Je pense aussi qu'utiliser le pattern Mediator pour ouvrir une fenêtre dans le code-behind reste correct en terme Mvvm, du moins je crois.
Je m'inspire pour cela du toolkit mvvm light, mais il y a des chose qui ne me plaise pas trop et que je n'ai pas encore réussi à contourner dans ma petite librairie. Comme par exemple avoir ce genre de chose dans le code-behind :

Code :

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

1
2
3
4
 
if (message.Sender.GetType() == typeof(MainViewModel)
                && message.Target == typeof(MainWindow))
            {

On voit bien ici que le code-behind connait le MainViewModel, ce qui pour moi casse un peu la méthodologie Mvvm.

Ou encore dans le même esprit le viewmodel qui connait la vue (---> typeof(MainWindow)):

Code :

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

1
2
3
4
5
6
7
 
var dialogMessage = new DialogMessage(
                        this,
                        typeof(MainWindow),
                        Resources.MessageBoxText,
                        r => DialogResult = r)
                    {

Bref j'essaie de palier à ça sans que ça soit une usine à gaz à mettre en place. Car comme tu aura pu le comprendre j'essaie de faire quelque de relativement simple à utiliser et à la fois efficace, car souvent j'ai tout de même vu des chose assez complexe qui risque de ne pas convenir à l'utilisation que l'on souhaite en faire chez mon client.

Pour ce qui est de ta proposition, je vais y regarder cette après-midi si j'ai un peu de temps.

Thanks.

[alves.seb]

Pour info j'ai mis sur mon blog les sources de ce petit projet :

http://alves.seb.free.fr/?p=344

Seb.

[Thomas Lebrun]

Je pense aussi qu'utiliser le pattern Mediator pour ouvrir une fenêtre dans le code-behind reste correct en terme Mvvm, du moins je crois.

Heu... cela ne me semble pas logique: le pattern Mediator/Messenger sont censés être utilisé pour permettre à plusieurs ViewModels de communiquer entre eux et non d'interagir avec le code behind d'une vue...

[alves.seb]

Je me suis inspiré de ça :

http://blogs.ugidotnet.org/corrado/a...unication.aspx
(Bon il faut lire entre les lignes car c'est en Italien)

Je suis d'accord avec toi à la base le pattern Mediator/Messenger est censé être utilisé pour communiquer entre les viewmodel. Mais pourquoi pas l'utiliser pour communiquer avec d'autre élément comme le code-behind d'une vue permettant ainsi entre autre d'afficher d'autre Vue ou des MessageBox. Le code-behind ce limiterais juste à ces opérations qui sont pour moi des fonctions propre à une vue. Le viewmodel resterais quand à lui indépendant de la vue donc je ne crois pas casser le model MVVM. Mais je me trompe peut-être.

[alves.seb]

Je suppose que pour la plupart vous connaissait déjà ce lien.
En fait je m'étais inspiré du mvvm light toolkit pour l'implémentation du pattern Mediator mais j'avoue qu'en ayant regardé un peu le lien ci-dessous je vais revoir quelques éléments de ma petite librairie.

Pour ceux que ça intéresse :

http://marlongrech.wordpress.com/200...-applications/

Dans tout les cas en lisant pas mal de post sur le net, je m'aperçois qu'il y a bcp de façon d'implémenter le pattern mvvm et que chacun fait un peu sa petite cuisine. Le principe étant de rester au maximum proche des recommandations.
Donc pour ce qui est d'afficher une boîte de dialogue dans le code-behind de ma vue en passant par le Pattern Mediator, il y en a qui m'ont dit <<oui>> d'autre <<pourquoi pas>> et d'autre <<j'aime pas trop ça>>. Bref rien qui à mon sens va à l'encontre de la méthodologie mvvm, mais qui fait débat c'est certain.

[sundown]

Dans tout les cas en lisant pas mal de post sur le net, je m'aperçois qu'il y a bcp de façon d'implémenter le pattern mvvm et que chacun fait un peu sa petite cuisine. Le principe étant de rester au maximum proche des recommandations.

Je découvre moi aussi MVVM en ce moment, et j'avoue qu'il est difficile d'identifier les bonnes pratiques des mauvaises dans tous les exemples que l'on rencontre sur le net.
On peut publier chaque propriété du Model dans le ViewModel puis binder la vue sur ces propriétés (on retrouve alors un binding XAML du style {binding UserName} ) ; ou alors publier simplement le Model (on retrouve alors un binding du style {binding User.Name} ou User est l'instance du Model).

On peut instancier le ViewModel dans le constructeur de la View (ce qui permet par exemple de passer des paramètres) ou bien directement dans le code XAML en affectant le tag DataContext ; On peut aussi préférer se reposer sur une classe de composition qui va s'occuper d'instancier la View, instancier le ViewModel et ensuite affecter le ViewModel à la View.

Toutes ces approches sont valides, elles ont chacune leurs avantages et leurs inconvénients.

Donc pour ce qui est d'afficher une boîte de dialogue dans le code-behind de ma vue en passant par le Pattern Mediator, il y en a qui m'ont dit <<oui>> d'autre <<pourquoi pas>> et d'autre <<j'aime pas trop ça>>. Bref rien qui à mon sens va à l'encontre de la méthodologie mvvm, mais qui fait débat c'est certain.

Disons que c'est peut être plus dans l'esprit MVVM de confier cette tâche à ton ViewModel :
Ta View déclenche une commande.
Ton ViewModel implémente cette commande avec, à la fin, le post d'un message sur le mediator pour demander l'affichage d'une boite de dialogue via l'interface "messageBox".
Pour ton appli, l'implémentation de l'interface "messageBox" peut être réalisée avec de simple boites de dialogues ou carrément en XAML.
Pour tes tests, l'implémentation de l'interface "messageBox" peut être vide.

[alves.seb]

Ton ViewModel implémente cette commande avec, à la fin, le post d'un message sur le mediator pour demander l'affichage d'une boite de dialogue via l'interface "messageBox".

C'est ce que je pense avoir mise en place dans mon petit toolkit maison.

Mon ViewModel qui implémente ma commande et qui va au travers du pattern Mediator déclencher un messagbox qui sera déclenché dans le codebehind de la vue (C'est ce qui m'interrogeait le plus):

ViewModel

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
 
 private void ActionButtonCommandParameter(Object parameter)
        {
            Mediator.Default.Send<DialogMessage>(MediatorMessages.Message3, new DialogMessage(this, r => DialogResult = r)
            {
                Content = "Une Question Mediator ?",
                Button = MessageBoxButton.YesNo,
                Caption = "Test Dialog",
                DefaultResult = MessageBoxResult.No,
                Icon = MessageBoxImage.Question
 
            });
 
            LbInfo = "Test MVVM Action Bouton parameter :" + DialogResult.ToString();
        }

Mon code behind qui va recevoir l'instruction de déclencher le MessageBox :

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
 
//Dans le constructeur
Mediator.Default.Register(this);
 
//Utilisation d'annotation
[MediatorMessage(MediatorMessages.Message3)]
private void TestMediator3(DialogMessage s)
        {
            var result = MessageBox.Show(
                           this,
                           s.Content,
                           s.Caption,
                           s.Button,
                           s.Icon,
                           s.DefaultResult,
                           s.Options);
 
            if (s.Callback != null)
            {
                s.Callback(result);
            }
        }

Bref je sais pas si c'est correct, mais je tente des chose en fonction de ce que je peut trouver sur le net à ce sujet.

Merci en tout les cas à tous pour vos avis sur la question MVVM qui ont pu me faire avancer.

[SoBaKa]

Et le principe du Navigator ? (voir ici)

- Simple à mettre en place
- Pas de code behind dans les View
- Pas de référence directe au Window dans les ViewModel
- Juste un peu de code à mettre dans le App.xaml.cs pour que le navigator fonctionne pour chaque méthodes...

[alves.seb]

A première vu cela m'a l'air pas mal du tout, je vais approfondir.

A titre de comparaison avec ce que j'ai fait :

- Simple à mettre en place du moins je pense
- Juste quelques lignes dans le code behind des View qui se limite à l'affichage d'autre vue ou des MessageBox (mais qui peut-être revu/amélioré avec ce dont tu propose).
- Je n'ai jamais de référence directe au Window dans les ViewModel et vice-versa.
- Aucun code à mettre dans le App.xaml.cs

Merci pour tes infos.

[alves.seb]

Pour info, une petite mise à jour du mon Toolkit Mvvm disponible sur mon blog:

http://alves.seb.free.fr/?p=363

En tout les cas merci à tous pour votre aide sur le sujet, cela m'a bien aidé à écrire ce petit Toolkit.

[alves.seb]

Après un début d'utilisation de mon toolkit dans un projet, j'ai un peu approfondie et j'ai regardé une solution proposé par Thomas sur ce post qui consiste à passer par un ServiceProvider pour l'affichage d'une MessageBox entre autre. A partir de ça j'ai compléter et adapter mon toolkit afin de pouvoir utiliser ce concept, je me suis inspiré du toolkit mvvmhelpers.

Nouvelle monture pour ceux que ça intéresse : http://alves.seb.free.fr/?p=375