Discussion :

[leSeb]

Bonjour,

D'après ce que l'on peut lire sur le WPF, un des intérêts serait de séparer l'interface du code de l'application (MVVM - Model-Vue-VueModel). D'après ce schéma :
la Vue connait sa VueModel (l'inverse n'est pas vrai)
la VueModel connait son Model (l'inverse n'est pas vrai)

En ce qui concerne le lien entre les données et l'interface, il est réalisé par le principe de Binding qui :
- assure l'affichage des données de la VM dans l'interface
- répercute les modifications utilisateurs pour les placer dans la VM (pas de code behind).

Pour les actions, opération d'enregistrement par exemple, il faut passer par des ICommand qui fait le lien entre un bouton d'interface et la méthode de la VM.

Mais dans ce modèle où et comment gérer les exceptions liées à cette opération ?
Par exemple, lors de mon enregistrement, ma base de données n'est pas accessible, et ma méthode me retourne une Exception.
Comment informer l'utilisateur de cette erreur en respectant le MVVM ?

Merci d'avance.

[Invité]

Question interessante.

J'avais eu ce problème.

Je l'ai résolu comme suit.
Dans ma ViewModelBase, il y a une proprieté CriticalError. Cette proprieté est héritée par toutes ViewModel (ces derniières dérivent de ViewModelBase donc c'est logique).
Dans mes ViewModels, toutes erreurs engendrées me renseignent la proprieté CriticalError.
Dans ma vue, je vais binder la propriété Text d'un TextBox à ma propriété CriticalError.

C'est le seul moyen qui m'a permis de résoudre le problème.

[Thomas Lebrun]

Personnellement, je passe plutot par une interface (IActions) qui définit une méthode ShowMessage.

Ensuite, je dis que chacune de mes vues implémente cette interface. Puis, au moment d'instancier le ViewModel, je passe en paramètre l'instance de la classe qui implémente l'interface (autrement dit this).

Coté ViewModel, j'ai le constructeur qui prend en paramètre un objet du type IActions. J'initiale un membre de la classe du ViewModel avec la valeur récupérée et ensuite, dans le code, j'appelle juste la méthode Show.

Certes, cette technique nécessite d'écrire du code behind mais:
- celui-ci peut facilement être testé
- le principe du MVVM, ce n'est pas de ne pas écrire de code dans le code behind mais d'en écrire le moins possible !

[Invité]

Certes, cette technique nécessite d'écrire du code behind mais:
- celui-ci peut facilement être testé
- le principe du MVVM, ce n'est pas de ne pas écrire de code dans le code behind mais d'en écrire le moins possible !

Je suis d'accords avec toi.

Mais elle oblige la View et la ViewModel à se connaitre mutuellement ce qui n'est pas admissible non ?.

la Vue connait sa VueModel (l'inverse n'est pas vrai)

[ikeas]

oui justement ca me paraissait pas très cohérent que la vue connaisse les vuemodel ....

[leSeb]

oui justement ca me paraissait pas très cohérent que la vue connaisse les vuemodel ....

C'est tout à fait cohérent. L'objectif est que le moteur de l'application ne doit pas dépendre de l'interface (donc ne la connait pas).
Le moteur propose des fonctionnalités (données, actions, ...) par le biais de propriétés et de méthodes et l'interface ne fait que les utiliser : pour cela, elle doit connaitre le ViewModel.

Je pense qu'il y a moyen de faire un mixte de vos (thomas et h2s84) deux solutions pour respecter le modele MVVM.

- Créer une propriété CriticalError dans les classes de ViewModel.
- L'interface surveille la propriété CriticalError de sa ViewModel et affiche le message dès que sa valeur est modifiée (un peu de code behind mais pas trop).

Dans ce cas, le ViewModel ne connait pas la View. Mais c'est bien la View qui détermine l'affichage du message d'erreur.

Qu'en pensez-vous ?

[Thomas Lebrun]

Mais elle oblige la View et la ViewModel à se connaitre mutuellement ce qui n'est pas admissible non ?.

La Vue connait sa VueModel (l'inverse n'est pas vrai) par le DataContext mais le ViewModel ne connait pas la vue, il connait une instance de l'interface (implémentée par la vue). Donc, pour moi, ca roule...

[Jérem22]

Je suis OK avec Thomas: si les classes ViewModel reçoivent une interface implémenté par la vue, on ne "casse" pas le principe MVVM (sans interface en revanche on introduirait un couplage trop important).

Personnellement, ça m'arrive également de faire l'inverse. Par exemple si une classe ViewModel demande à ce que la vue associé soit fermée, je généralise ce concept avec une interface IRequestCloseViewModel (qui contient un event RequestClose). Cela permet de m'assurer un gestion cohérente de ce mécanisme à travers toutes les classes ViewModel.

Pour aller plus loin, tu peux regarder par ici (l'article est en plusieurs parties). L'auteur a conçu tout un framework MVVM qui contient de nombreux services utilisables pour afficher des messages, communiquer entre les classes MVVM tout en restant fidèle à la méthodologie.

[The_badger_man]

Je suis OK avec Thomas: si les classes ViewModel reçoive une interface implémenté par la vue, on ne "casse" pas le principe MVVM (sans interface en revanche on introduirait un couplage trop important).

A ce moment là ton VM qui référence la vue via une interface ça s'appelle un Presenter. Et tu dérives vers le pattern MVP (Model, View, Presenter).

Pas évident ces patterns

[Thomas Lebrun]

J'ai regardé comment faisait Cinch (ou ce mec: http://www.julmar.com/blog/mark/2009...stability.aspx) et effectivement, l'idée de passer par un ServiceProvider n'est pas bête du tout....

L'avantage, c'est que tu restes completement MVVM dans ton approche !

Je vais voir pour essayer de mettre ca en place sur un dev en cours, voir ce que cela donne....

[Thomas Lebrun]

Implémenté, testé et validé

Ca marche nickel, il y a juste quelques petites corrections à faire si vous le voulez en SL

[Invité]

Implémenté, testé et validé

Ca marche nickel, il y a juste quelques petites corrections à faire si vous le voulez en SL

we're waiting for u

[Thomas Lebrun]

Voila la version Silverlight:

L'interface:

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
 
using System;
 
    /// <summary>
    /// Available LogEntry options. 
    /// Abstracted to allow some level of UI Agnosticness
    /// </summary>
    public enum LogType
    {
        /// <summary>
        /// Represent an error.
        /// </summary>
        Error,
 
        /// <summary>
        /// Represent a warning.
        /// </summary>
        Warning,
 
        /// <summary>
        /// Represent an information.
        /// </summary>
        Information
    }
 
    /// <summary>
    /// This interface defines a very very simple logger interface
    /// to allow the ViewModel to log
    /// </summary>
    public interface ILoggerService
    {
        /// <summary>
        /// Logs to the event log using the params provided
        /// </summary>
        /// <param name="logType">The LogType to use.</param>
        /// <param name="logEntry">The actual logEntry string to be logged.</param>
        void Log(LogType logType, String logEntry);
 
        /// <summary>
        /// Logs to the event log using the params provided
        /// </summary>
        /// <param name="logType">The LogType to use.</param>
        /// <param name="ex">An Exception to be logged.</param>
        void Log(LogType logType, Exception ex);
    }

L'implémentation:

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
120
121
122
123
124
125
126
127
128
 
/// <summary>
    /// This class implements the IMessageBoxService for Silverlight purposes.
    /// </summary>
    public class MessageBoxService : IMessageBoxService
    {
        #region IMessageBoxService Members
 
        /// <summary>
        /// Displays an error dialog with a given message.
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        public void ShowError(string message)
        {
            ShowMessage(message, "Error");
        }
 
        /// <summary>
        /// Displays an error dialog with a given message.
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        public void ShowInformation(string message)
        {
            ShowMessage(message, "Information");
        }
 
        /// <summary>
        /// Displays an error dialog with a given message.
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        public void ShowWarning(string message)
        {
            ShowMessage(message, "Warning");
        }
 
        /// <summary>
        /// Displays a OK/Cancel dialog and returns the user input.
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        /// <returns>User selection.</returns>
        public CustomDialogResults ShowOkCancel(string message)
        {
            return ShowQuestionWithButton(message, CustomDialogButtons.OKCancel);
        }
        #endregion
 
        #region Private Methods
 
        /// <summary>
        /// Shows a standard System.Windows.MessageBox using the parameters requested
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        /// <param name="heading">The heading to be displayed</param>
        private void ShowMessage(string message, string heading)
        {
            MessageBox.Show(message, heading, MessageBoxButton.OK);
        }
 
        /// <summary>
        /// Shows a standard System.Windows.MessageBox using the parameters requested
        /// but will return a translated result to enable adhere to the IMessageBoxService
        /// implementation required. 
        /// 
        /// This abstraction allows for different frameworks to use the same ViewModels but supply
        /// alternative implementations of core service interfaces
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        /// <param name="button"></param>
        /// <returns>CustomDialogResults results to use</returns>
        private CustomDialogResults ShowQuestionWithButton(string message, CustomDialogButtons button)
        {
            MessageBoxResult result = MessageBox.Show(message, "Please confirm...", GetButton(button));
 
            return GetResult(result);
        }
 
        /// <summary>
        /// Translates a CustomDialogButtons into a standard Silverlight System.Windows.MessageBox MessageBoxButton.
        /// This abstraction allows for different frameworks to use the same ViewModels but supply
        /// alternative implementations of core service interfaces
        /// </summary>
        /// <param name="btn">The button type to be displayed.</param>
        /// <returns>A standard Silverlight System.Windows.MessageBox MessageBoxButton</returns>
        private MessageBoxButton GetButton(CustomDialogButtons btn)
        {
            MessageBoxButton button = MessageBoxButton.OK;
 
            switch (btn)
            {
                case CustomDialogButtons.OK:
                    button = MessageBoxButton.OK;
                    break;
                case CustomDialogButtons.OKCancel:
                    button = MessageBoxButton.OKCancel;
                    break;
            }
            return button;
        }
 
        /// <summary>
        /// Translates a standard Silverlight System.Windows.MessageBox MessageBoxResult into a
        /// CustomDialogIcons.
        /// This abstraction allows for different frameworks to use the same ViewModels but supply
        /// alternative implementations of core service interfaces
        /// </summary>
        /// <param name="result">The standard Silverlight System.Windows.MessageBox MessageBoxResult</param>
        /// <returns>CustomDialogResults results to use</returns>
        private CustomDialogResults GetResult(MessageBoxResult result)
        {
            CustomDialogResults customDialogResults = CustomDialogResults.None;
 
            switch (result)
            {
                case MessageBoxResult.Cancel:
                    customDialogResults = CustomDialogResults.Cancel;
                    break;
                case MessageBoxResult.None:
                    customDialogResults = CustomDialogResults.None;
                    break;
                case MessageBoxResult.OK:
                    customDialogResults = CustomDialogResults.OK;
                    break;
            }
            return customDialogResults;
        }
 
        #endregion
    }

Le ServiceProvider reste le même:

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
 
public class ServiceProvider : IServiceProvider
    {
        #region Fields
 
        private readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();
 
        #endregion
 
        #region Public Methods
 
        /// <summary>
        /// Clears all services from the resolver list 
        /// </summary>
        public void Clear()
        {
            if (_services != null && _services.Count > 0)
                _services.Clear();
        }
 
        /// <summary>
        /// Adds a new service to the resolver list
        /// </summary>
        /// <param name="type">Service Type (typically an interface)</param>
        /// <param name="value">Object that implements service</param>
        public void Add(Type type, object value)
        {
            if (type == null)
                throw new ArgumentNullException("type");
            if (value == null)
                throw new ArgumentNullException("value");
 
            lock (_services)
            {
                // Replacing existing service
                if (_services.ContainsKey(type))
                    _services[type] = value;
                // Adding new service
                else
                    _services.Add(type, value);
            }
        }
 
        /// <summary>
        /// Remove a service
        /// </summary>
        /// <param name="type">Type to remove</param>
        public void Remove(Type type)
        {
            if (type == null)
                throw new ArgumentNullException("type");
            lock (_services)
            {
                _services.Remove(type);
            }
        }
 
        /// <summary>
        /// This resolves a service type and returns the implementation. Note that this
        /// assumes the key used to register the object is of the appropriate type or
        /// this method will throw an InvalidCastException!
        /// </summary>
        /// <typeparam name="T">Type to resolve</typeparam>
        /// <returns>Implementation</returns>
        public T Resolve<T>()
        {
            return (T)GetService(typeof(T));
        }
 
        /// <summary>
        /// Implementation of IServiceProvider
        /// </summary>
        /// <param name="serviceType">Service Type</param>
        /// <returns>Object implementing service</returns>
        public object GetService(Type serviceType)
        {
            lock (_services)
            {
                object value;
                return _services.TryGetValue(serviceType, out value) ? value : null;
            }
        }
 
        #endregion
    }

Et l'utilisation aussi

Code :

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

1
2
3
4
 
ServiceProvider.Add(typeof(IMessageBoxService), new MessageBoxService());
 
prompt = this.Resolve<IMessageBoxService>();

A+

[Invité]

Je pense que t'as pas mis la bonne implémentation pour le ServiceProvider.

[Thomas Lebrun]

Exact, c'est corrigé maintenant

[Invité]

Si j'ai bien compris le code suivant :

Code :

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

1
2
3
ServiceProvider.Add(typeof(IMessageBoxService), new MessageBoxService());
 
prompt = this.Resolve<IMessageBoxService>();

doit être mis dans le code behind

[Thomas Lebrun]

Non, il doit être mis dans le ViewModel de base

En gros, dans le VM de base, tu as une propriété:

Code :

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

1
2
 
public IMessageBoxService prompt {get; set;};

Cette ligne, dans le constructeur par ex, permet de déclarer une instance de la classe qui implémente l'interface:

ServiceProvider.Add(typeof(IMessageBoxService), new MessageBoxService());

Puis, cette ligne permet d'initialiser la propriété:

Code :

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

prompt = this.Resolve<IMessageBoxService>();

[Invité]

Je viens de tester ta solution en WPF et Silverlight en suivant les infos sur ton blog. ça marche nickel.
Quant à la solution pour Silverlight que t'as fourni dans cette discussion dans ton précédent post j'ai oublié de te notifier que le code de l'interface n'est pas celui de IMessageBoxService mais celui de ILoggerService.

Le bon code de l'interface IMessageBoxService pour la version Silverlight est :

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
 
/// <summary>
    /// Available Button options.
    /// Abstracted to allow some level of UI Agnosticness
    /// </summary>
    public enum CustomDialogButtons
    {
        OK,
        OKCancel,
        YesNo,
        YesNoCancel
    }
 
    /// <summary>
    /// Available Icon options.
    /// Abstracted to allow some level of UI Agnosticness
    /// </summary>
    public enum CustomDialogIcons
    {
        None,
        Information,
        Question,
        Exclamation,
        Stop,
        Warning
    }
 
    /// <summary>
    /// Available DialogResults options.
    /// Abstracted to allow some level of UI Agnosticness
    /// </summary>
    public enum CustomDialogResults
    {
        None,
        OK,
        Cancel,
        Yes,
        No
    }
 
    /// <summary>
    /// This interface defines a interface that will allow
    /// a ViewModel to show a messagebox
    /// </summary>
    public interface IMessageBoxService
    {
        /// <summary>
        /// Shows an error message
        /// </summary>
        /// <param name="message">The error message</param>
        void ShowError(string message);
 
        /// <summary>
        /// Shows an information message
        /// </summary>
        /// <param name="message">The information message</param>
        void ShowInformation(string message);
 
        /// <summary>
        /// Shows an warning message
        /// </summary>
        /// <param name="message">The warning message</param>
        void ShowWarning(string message);
 
        /// <summary>
        /// Displays a OK/Cancel dialog and returns the user input.
        /// </summary>
        /// <param name="message">The message to be displayed.</param>
        /// <param name="icon">The icon to be displayed.</param>
        /// <returns>User selection.</returns>
        CustomDialogResults ShowOkCancel(string message);
    }

Vive le MVVM

[Thomas Lebrun]

Arf, les joies du copier/coller

Sinon, je suis content que cela te plaise

[leSeb]

Merci pour vos réponses.

Je vais essayer de me débrouiller avec ça.