Discussion :

[jdddeschamps]

Bonjour,

J'ai besoin de conseils pour vérifier que nous avons fait les bons choix de POO.

Contexte :
J'ai 10 ans d'expérience en vb5-vb6 et j'ai écrit un programme en c# en "pair programming" avec un collègue qui a 10 ans d'expérience en VBA.
Nous voulions apprendre un langage POO. Nous avons appris le java puis le C++ et finalement nous avons choisi le c#.
Nous utilisons les conventions de codage d'Aviva : https://csharpguidelines.codeplex.com/
Nous n'avions pas d'expérience en POO avant ce projet.
Nous avons déjà programmé plusieurs heures et avant d'aller plus loin, nous souhaiterions vérifier que notre projet est bien conçu.

Objet du projet :
Le projet simule une expérience de physique ou n(t)= f(criticality(t))
- l'utilisateur défini graphiquement une courbe de criticality en fonction du temps
- le programme calcule la valeur n(t) et affiche le résultat

Contraintes de l'UI
la courbe de criticality(t) est une succession de fonctions linéaires (donc de segment). L'utilisateur peut déplacer les extrémités, ajouter ou supprimer des segments. Pour cela, nous utilisons une collection de segments (dt, dcriticality) qui sont tracés dans un panel.

Classes
- une classe Experiment héritée de form : une feuille (ou un formulaire) représente une expérience (une succession de variations de criticality(t), son calcul, son résultat)
- une classe Reactor, membre de Experiment, qui calcule n=f(criticality)
- une classe CriticalityPanel1 héritée de Panel.
- une classe CriticalityVariation (dt, dcriticality) et sa collection CriticalityVariations qui est un membre de Experiment
- une classe criticalityVariationPoint (dt, dcriticality, dx, dy) et sa collection qui est un membre de CriticalityPanel

Fonctionnement :
Experiment crée une instance de CriticalityVariations
puis une instance de CriticalityPanel qui fabrique CriticalityVariationPoints

Code :

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

1
2
3
4
5
6
7
8
 
private void Experiment_Load(object sender, EventArgs e)
        {            
            reactor = new Reactor(criticalityVariations, precursors);
            criticalityPanel1.LoadCriticality(criticalityVariations);
            criticalityPanel1.OnCriticalityChange += criticalityPanel1_OnCriticalityChange;
            Display();
        }

Quand l'utilisateur modifie le graphique criticality(t) dans criticalityPanel1, ce dernier envoie un évènement à Experiment avec la nouvelle collection CriticalityVariations :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
       protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            if (draging)
            {
                draging = false;
                criticalityVariationsPoints.updateVariations(selectedPoint);
                this.Refresh();
                CriticalityVariationsEventArgs cve =
                    new CriticalityVariationsEventArgs((CriticalityVariations)(criticalityVariationsPoints));
                OnCriticalityChange(this, cve);
            }
        }

Ainsi, Experiment peut recalculer n(t) et afficher le résultat :

Code :

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

1
2
3
4
5
6
7
8
9
 
        void criticalityPanel1_OnCriticalityChange(object sender, CriticalityVariationsEventArgs e)
        {
            criticalityVariations = e.CriticalityVariationsUpdated;
 
            reactor = new Reactor(criticalityVariations, precursors);
            Display();
            //throw new NotImplementedException();
        }

Le choix de faire de la collection CriticalityVariations un membre de la classe Experiment est-il bon ?
Le choix de demander à criticalityPanel1 d'envoyer la nouvelle collection modifiée par l'utilisateur à Experiment est-il le bon ?
Avons-nous fait quelque chose de simple, facilement compréhensible et maintenable ou avons-nous tout faux ?

Merci pour vos conseils ...

[theMonz31]

salut

je n'ai pas tout compris mais ce que je verrais serait déjà de séparer la représentation (form, panel) du comportement.

Pour moi, la classe qui gère ta courbe ne doit rien avoir à faire avec la classe qui va gérer la représentation graphique.

[jdddeschamps]

Bonjour,

je n'ai pas tout compris

En effet, vu le nombre d'affichages et le peu de réponses, je n'ai peut-être pas été très clair.
Plutôt que de décrire ce que j'ai fait, je vais mieux expliquer ce à quoi je dois aboutir :

Le projet calcule et affiche n(t) sur une form en fonction de la courbe a(t) tracée à la souris par l'utilisateur dans la même form : n(t) = F(a(t))

L'utilisateur ajoute, supprime et modifie à la souris des segments de droite qui consitutent la courbe a(t).
Il faut donc enregistrer les segments de droite dans une collection pour que l'utilisateur puisse cliquer sur les extrémités et les déplacer ou supprimer des segments.
Il faut également afficher sur la courbe a(t) les valeurs physiques (a dans son unité et t en secondes).

Comment faut-il architecturer le projet pour calculer n(t) quand l'utilisateur déplace un segment et relâche le bouton ?

Je procède ainsi :
- une classe CriticalityPanel1 héritée de Panel où est dessinée a(t) et où l'utilisateur modifie la courbe à l'aide de la souris
- une classe CriticalityVariationsPoints qui contient les segments en x,y et les valeurs physiques en delta_a et delta_t. Membre de CriticalityPanel1.
- une classe CriticalityVariations qui contient toutes les valeurs physiques en delta_a et delta_t

Pour moi, la classe qui gère ta courbe ne doit rien avoir à faire avec la classe qui va gérer la représentation graphique.

J'ai le sentiment d'avoir respecter ce point puisqu'il existe :
- une collection CriticalityVariationsPoints qui gère la représentation graphique de la courbe ;
- une collection CriticalityVariations qui gère la courbe elle même et qui permet de transmettre la courbe a(t) de criticalityPanel1 à la form et inversement.

Fonctionnement :
- Quand l'utilisateur relâche la souris, criticalityPanel1 envoie un évènement vers la form mère, avec la courbe a(t) en argument (une instance de CriticalityVariations)
- la form calcule n(t)
- la form affiche n(t) dans un objet Chart

Est-ce la bonne architecture ?
Est-ce farfelu ?
Est-ce acceptable ?
Peut-être le peu de réponses signifie-t-il qu'il n'y a rien de choquant à procéder de la sorte ?

Merci

[theMonz31]

j'aurais tendance à dire que la "bonne" architecture, c'est celle qui fonctionne et te permet de résoudre ton problème.

Après, on peut toujours trouver mieux, plus évolutif, etc...

L'essentiel pour moi est que ton soft fonctionne.. après, l'architecture peut évoluer à l'usage...et en fonction des contraintes que tu rencontrerais !!!

[jdddeschamps]

OK, merci.

Comme c'est notre premier projet et que nous en sommes au début, nous voulions nous assurer que nous n'avions pas fait fausse route.
Effectivement, le soft fonctionne jusqu'à maintenant et l'architecture actuelle ne devrait pas nous empêcher de le mener jusqu'au bout.
Vu ta réponse, j'en déduis que nos choix ne vont pas à l'encontre des bonnes pratiques en génie logiciel ...