Discussion :

[Oufti]

Salut,

Je cherche un exemple complet et fonctionnel de l'implémentation du modèle MVC en C# et Winforms avec le .NET 2.0

Voila 2 jours que je suis sur Google sans rien trouver ....

Merci,

[Piotrek]

Salut

Il y a deux articles sur MVC dans la section tuto (cherche simplement "MVC") dans la page

C'est en VB.Net cependant

[Oufti]

Il y a deux articles sur MVC dans la section tuto (cherche simplement "MVC") dans la page

Je l'ai évidemment fait mais c'est ni complet ni fonctionnel ....

[algabus]

J'ai le même problème. Je souhaite implémenté un système MVC en C# mais je ne trouve rien de concluant sur le web.

J'ai implémenté il y a qq temps un MVC en C++ avec la librairie Qt qui base tous ces widgets sur le principe MVC. Il existe déjà dans la librairie Qt ainsi toute un panel de classe pour mettre un système MVC.

Dans les librairies C#, n'y a-t-il rien qui existe pour mettre en place un MVC? Ou sinon, quel classe me conseilleriez-vous d'utiliser?


Voici le schéma MVC que je souhaite implémenté :

Base de données SQL

/\
||
\/

Modèle (lecture/écriture des données)

/\
||
\/

Modèles intermédiaires (proxy, filtres)

/\
||
\/

Controleurs (edit et combobox)

/\
||
\/

Vues (tableau de données, edit, combobox)

[theMonz31]

salut

beh, personnellement, je trouve que le tuto (surtout celui qui est assez recent < 3 mois) est largement complet pour comprendre la philosophie du MVC

Autant en C++/MFC microsoft fournissait des templates pour faire "du pseudo" MVC via le Doc & View, autant cela n'est plus le cas avec la plateforme .Net

Mais de là à dire que le tuto est incomplet et ne permet pas de s'en sortir (je ne suis pas le rédacteur du tutoriel), je trouve cela un peu "abusif" (et je pese
mes mots )

Si le tuto n'est , toutefois pas suffisant pour vous, eh beh, je vous conseille de vous orienter vers de la litterature en discutant

Apres, MVC étant un pattern, le langage pour le mettre en oeuvre n'est pas important

The Monz, Toulouse

[algabus]

Je n'ai pas dit que ce tutoriel n'était pas complet, mais pas concluant...

MVC est un motif de conception qui n'a rien à voir avec un langage ou une librairie en particulier. J'en suis tout à fait conscient. Toutefois, si une librairie m'offre des classes déjà prévues pour fonctionner selon le schéma MVC, je m'en réjouis! C'est le cas de Qt, où il suffit de faire un "setModel(monModel)" sur la vue et le pattern MVC est en place! ... presque aussi simple ...

[theMonz31]

salut

malheureusement, il n'y pas de framework .Net permettant de faire du MVC de façon simple et directe sans avoir "peu de chose" à coder...

J'ai cru comprendre qu'en Java, il y avait un tel framework... malheureusement,
.Net est encore jeune et est parfois le "parent" pauvre ...

Maintenant, j'ai pas fait de recherche, mais peut-etre que sur Source forge, il y a des projets MVC pour .Net en cours de réalisation ? à voir !!!

The Monz, Toulouse

[algabus]

J'ai trouvé ce projet sur sourceforge. Il s'agit d'un framework .NET 2.0 pour implémenter un MVC sur une application WinForms ou sur une appli Web.

Il y a une documentation fournie dans l'API. Sinon une intro et un "QuickStart" bien foutu. Le tout est en anglais.

http://sourceforge.net/projects/ingeniousmvc

Remarque : la doc est à télécharger depuis la même page où on peut télécharger l'API.. et non pas dans la partie documentation..

[leblanc.philippe]

En fais, le modèle MVC est facile à implémenter si vous vous donner la peine de le faire.

Un classe Observable qui à comme propriété une liste contenant tout les Observer, un attribut indiquant si l'objet est changer et principalement 4 fonctions:

• setChanged: Change l'état de l'objet a changer
• notifyObserver: Averti les Observer que l'objet à changer en appelant la fonction Update de chaque Observer.
• addObserver: Ajoute un Observer à la liste
• removeObserver: Supprime un Observer de la liste

Un interface Observer ayant une simple fonction:

• Update(Observable ob, Object arg): "Ob" étant la référence vers l'objet Observable qui à changer et "arg" étant un argument quelle conte passer en parametre à la fonction. Cette fonction rafraichie la fenètre avec les nouvelles valeurs de l'objet Observable.

Le controleur en fais sont des actions qui ce produisent. Donc un click sur un bouton ou un Timer appelant une fonction de notre objet Observable. Normalement, nos Objets d'affaire hériteraient de la classe Observable et nos formulaire C# implémenterais l'interface Observer.

Bonne chance

[Chafouin]

Le modèle MVC est relativement simple a implémenter avec les evenement et le principe des delegate


declaration de l'evenement à lancer lors d'une modification et de la methode de notification:

Code :

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

1
2
3
4
5
6
7
8
9
 public delegate void MonEventHandler(object sender);
          public event MonEventHandler MonEvent;
 
        // notification de changement
        public void Notify()
        {
            if (MonEvent != null)
                MonEvent(this);
        }

l'ajout de la methode update de la vue a la liste de notification du modèle:

Code :

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

1
2
MonObjetModele objModel = new MonObjetModele();
      objModel.MonEvent += new MonObjetModele.MonEventHandler(MaVue.update);

MaVue.update est la methode permettant de mettre à jour la vue:

Code :

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

1
2
3
4
5
6
7
 public void update(object sender)
{
      if (sender is MonObjetModele )
      {   
          // appels aux getters du Modèle
      }
}

[Omsalam]

Bonjour,

J'ai du mal à comprendre ce que dit Chafouin.
J'ai tenté de réaliser une calculatrice en MVC mais à mon avis ce que j'ai fait n'as rien de telle.

La vue : Crée en winform. Pour ca je pense qu'il n'y a pas de problème.
Le controlleur :

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
 
 public partial class Form1 : Form
    {
        modele mymod = new modele();
        public Form1()
        {
            InitializeComponent();
        }
 
 
        private void textBox1_TextChanged(object sender, EventArgs e)
        {
 
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            textBox1.Text = "1";
            mymod.setNombre(1);
        }
 
 
        private void button2_Click(object sender, EventArgs e)
        {
            textBox1.Text = "2";
            mymod.setNombre(2);
        }
 
        private void buttonPlus_Click(object sender, EventArgs e)
        {
            textBox1.Text = "+";
            mymod.setOperateur("+");
        }
 
        private void buttonMoins_Click(object sender, EventArgs e)
        {
            textBox1.Text = "-";
        }
 
        private void buttonDiv_Click(object sender, EventArgs e)
        {
            textBox1.Text = "/";
        }
 
        private void buttonFoi_Click(object sender, EventArgs e)
        {
           // textBox1.Text = "*";
            textBox1.Text = mymod.getResultat().ToString(); 
        }
    }

Le contrôleur ici gère les action utilisateur. Cependant ce n'est pas le model qui met a jour la vue, est ce correct ?

Le modele :

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
 public class modele
    {
        private int nombre = -1;
        private int resultat = -1;
        private string operateur = null;
 
        /* Effectue le calcul */
        public void calcul(int secondNombre)
        {
            if (operateur == "+")
            {
                resultat = (nombre + secondNombre);
            }
        }
 
        /* Affichage forcé du résultat*/
        public int getResultat()
        {
            return resultat;
        }
 
        /* Définit l'opérateur de l'opération
         * @param operateur */
        public void setOperateur(string optr)
        {
            operateur = optr;
        }
 
        /* Définit le nombre à utiliser pour l'opération
         * @param nbre */
        public void setNombre(int nbre)
        {
            if (nombre == -1)
            {
                nombre = nbre;
            }
            else
            {
                calcul(nbre);
            }
        }

Le modèle sauvegarde les nombre, effectue les calcul.

voila ici dans ce code pour moi il y a bien une séparation entre ce que voit l'utilisateur, ce qui traite les données, et une classe qui gère ces composants.
Cependant ici il n'a y ni delegate, ni d'event ...

voila, si vous pouvez m'éclairer.
Cordialement.
Sammy

[RobPred5]

Bon je suppose que tout le monde a abandonné ce topic mais je me lance:

Le contrôleur ici gère les action utilisateur. Cependant ce n'est pas le model qui met a jour la vue, est ce correct ?

Justement, le model doit pouvoir prévenir la vue d'une modification des données. Dans ton cas si tu possèdes une deuxième vue liée à ton modèle, elle ne rafraichira pas ses données (puisque le controleur ne modifiera qu'une seule vue).

Pour ma part je pense que le plus simple pour mettre en place un pattern MVC en .NET est d'opérer de la manière suivante:

La VUE: comme il a été dit, il suffit de créer un winform

Le contrôleur: il suffit d'utiliser la classe partielle correspondant à la vue et de gérer les événements, cependant contrairement à l'exemple précédent, cette classe ne doit pas modifier les différents éléments de la vue. Ainsi pour reprendre l'exemple précédent, on aura:

Code :

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

1
2
3
4
5
6
7
8
 
 private void button1_Click(object sender, EventArgs e)
        {
             //Le controlleur ne modifie pas la vue
            //textBox1.Text = "1";
           //
            mymod.setNombre(1);
        }

Enfin, afin d'effectuer la liaison entre le modèle et la vue et le contrôleur il suffit d'utiliser du databinding, le modèle servant de source de données. Afin que cela fonctionne il ne faut cependant pas oublier de faire implémenter l'interface INotifyPropertyChanged par le modèle afin que celui-ci "prévienne" les vues de chaque modification de ses propriétés.